@daiso-tech/core 0.8.0 → 0.9.0

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-update-iterable.d.ts

@@ -1,14 +1,14 @@
 /**
  * @module Collection
  */
-import { type AsyncPredicate, type AsyncMap, type IAsyncCollection, type ChangendItem } from "../../../../collection/contracts/_module";
+import { type AsyncPredicate, type AsyncMap, type IAsyncCollection } from "../../../../collection/contracts/_module";
 /**
  * @internal
  */
-export declare class AsyncUpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements AsyncIterable<ChangendItem<TInput, TFilterOutput, TMapOutput>> {
+export declare class AsyncUpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements AsyncIterable<TInput | TFilterOutput | TMapOutput> {
     private collection;
     private predicateFn;
     private mapFn;
     constructor(collection: IAsyncCollection<TInput>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>);
-    [Symbol.asyncIterator](): AsyncIterator<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    [Symbol.asyncIterator](): AsyncIterator<TInput | TFilterOutput | TMapOutput>;
 }

package/dist/types/collection/implementations/async-iterable-collection/async-iterable-collection.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type ChangendItem, type AsyncReduce, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type AsyncReduce, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type AsyncIterableValue, type AsyncLazyable } from "../../../_shared/types";
 import { type RecordItem } from "../../../_shared/types";
 import type { TimeSpan } from "../../../utilities/_module";
@@ -34,7 +34,10 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     join(separator?: string): LazyPromise<Extract<TInput, string>>;
     collapse(): IAsyncCollection<AsyncCollapse<TInput>>;
     flatMap<TOutput>(mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, Iterable<TOutput>>): IAsyncCollection<TOutput>;
-    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>): IAsyncCollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>): IAsyncCollection<TInput | TFilterOutput | TMapOutput>;
+    set(index: number, value: TInput | AsyncMap<TInput, IAsyncCollection<TInput>, TInput>): IAsyncCollection<TInput>;
+    get(index: number): LazyPromise<TInput | null>;
+    getOrFail(index: number): LazyPromise<TInput>;
     page(page: number, pageSize: number): IAsyncCollection<TInput>;
     sum(): LazyPromise<Extract<TInput, number>>;
     average(): LazyPromise<Extract<TInput, number>>;

package/dist/types/collection/implementations/iterable-collection/_shared/update-iterable.d.ts

@@ -1,14 +1,14 @@
 /**
  * @module Collection
  */
-import { type Predicate, type ICollection, type Map, type ChangendItem } from "../../../../collection/contracts/_module";
+import { type Predicate, type ICollection, type Map } from "../../../../collection/contracts/_module";
 /**
  * @internal
  */
-export declare class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<ChangendItem<TInput, TFilterOutput, TMapOutput>> {
+export declare class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<TInput | TFilterOutput | TMapOutput> {
     private collection;
     private predicateFn;
     private mapFn;
     constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>);
-    [Symbol.iterator](): Iterator<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    [Symbol.iterator](): Iterator<TInput | TFilterOutput | TMapOutput>;
 }

package/dist/types/collection/implementations/iterable-collection/iterable-collection.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type Collapse, type Comparator, type Predicate, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type Collapse, type Comparator, type Predicate, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type Reduce, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type Lazyable } from "../../../_shared/types";
 import { type RecordItem } from "../../../_shared/types";
 /**
@@ -31,7 +31,10 @@ export declare class IterableCollection<TInput> implements ICollection<TInput> {
     join(separator?: string): Extract<TInput, string>;
     collapse(): ICollection<Collapse<TInput>>;
     flatMap<TOutput>(mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>): ICollection<TOutput>;
-    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<TInput | TFilterOutput | TMapOutput>;
+    set(index: number, value: TInput | Map<TInput, ICollection<TInput>, TInput>): ICollection<TInput>;
+    get(index: number): TInput | null;
+    getOrFail(index: number): TInput;
     page(page: number, pageSize: number): ICollection<TInput>;
     sum(): Extract<TInput, number>;
     average(): Extract<TInput, number>;

package/dist/types/collection/implementations/list-collection/list-collection.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type Collapse, type Comparator, type Predicate, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type ForEach, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type Collapse, type Comparator, type Predicate, type ICollection, type Map, type Modifier, type Tap, type Transform, type Reduce, type ForEach, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type Lazyable } from "../../../_shared/types";
 import { type RecordItem } from "../../../_shared/types";
 /**
@@ -28,7 +28,10 @@ export declare class ListCollection<TInput> implements ICollection<TInput> {
     join(separator?: string): Extract<TInput, string>;
     collapse(): ICollection<Collapse<TInput>>;
     flatMap<TOutput>(mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>): ICollection<TOutput>;
-    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<TInput | TFilterOutput | TMapOutput>;
+    set(index: number, value: TInput | Map<TInput, ICollection<TInput>, TInput>): ICollection<TInput>;
+    get(index: number): TInput | null;
+    getOrFail(index: number): TInput;
     page(page: number, pageSize: number): ICollection<TInput>;
     sum(): Extract<TInput, number>;
     average(): Extract<TInput, number>;

package/dist/types/event-bus/contracts/_shared.d.ts

@@ -12,6 +12,12 @@ export type Listener<TEvent extends IBaseEvent> = (event: TEvent) => Promisable<
 export declare class EventBusError extends Error {
     constructor(message: string, cause?: unknown);
 }
+/**
+ * @group Errors
+ */
+export declare class UnexpectedEventBusError extends EventBusError {
+    constructor(message: string, cause?: unknown);
+}
 /**
  * @group Errors
  */

package/dist/types/event-bus/contracts/event-bus-manager.contract.d.ts

@@ -1,20 +1,120 @@
 /**
  * @module EventBus
  */
-import type { Validator } from "../../utilities/_module";
+import { type Validator } from "../../utilities/_module";
 import type { INamespacedEventBus } from "../../event-bus/contracts/event-bus.contract";
 import type { IBaseEvent } from "../../event-bus/contracts/_shared";
 /**
+ * The <i>IEventBusFactory</i> contract makes it easy to switch between different <i>{@link IEventBusAdapter | event adapters}</i> dynamically.
  * @group Contracts
  */
-export type EventBusManagerUseSettings<TType, TAdapters extends string = string> = {
-    adapter?: TAdapters;
-    validator?: Validator<TType>;
+export type IEventBusFactory<TAdapters extends string = string, TEvents extends IBaseEvent = IBaseEvent> = {
+    /**
+     * @example
+     * ```ts
+     * import { EventBusManager, MemoryEventBusAdapter, RedisEventBusAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const eventBusManager = new EventBusManager({
+     *   adapters: {
+     *     memory: new MemoryEventBusAdapter(),
+     *     redis: new RedisEventBusAdapter({
+     *       dispatcherClient: new Redis();
+     *       listenerClient: new Redis();
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   rootNamespace: "@storage/"
+     * });
+     *
+     * (async () => {
+     *   // Will dispatch envent using the default adapter which is the memory addapter
+     *   await eventBusManager
+     *     .use()
+     *     .dispatch({ type: "add", a: 1, b: 2 });
+     *   // Will dispatch envent using the redis addapter
+     *   await eventBusManager
+     *     .use("redis")
+     *     .dispatch({ type: "add", a: 1, b: 2 });
+     * })();
+     * ```
+     */
+    use(adapter?: TAdapters): INamespacedEventBus<TEvents>;
 };
 /**
- * The <i>IEventBusManager</i> contract makes it easy to switch between different <i>{@link IEventBusAdapter | event bus adapters}</i> dynamically.
+ * The <i>IEventBusManager</i> contract makes it easy to configure and switch between different <i>{@link IEventBusAdapter | event adapters}</i> dynamically.
  * @group Contracts
  */
-export type IEventBusManager<TAdapters extends string = string> = {
-    use<TEvents extends IBaseEvent = IBaseEvent>(settings?: EventBusManagerUseSettings<TEvents, TAdapters>): INamespacedEventBus<TEvents>;
+export type IEventBusManager<TAdapters extends string = string, TEvents extends IBaseEvent = IBaseEvent> = IEventBusFactory<TAdapters, TEvents> & {
+    /**
+     * The <i>withValidation</i> method is used to set a <i>validator</i>, which validates the event during runtime.
+     * The type is inferred from the provided <i>validator</i>.
+     * @example
+     * ```ts
+     * import { EventBusManager, MemoryEventBusAdapter, RedisEventBusAdapter, zodValidator } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     * import { z } from "zod"
+     *
+     * const eventBusManager = new EventBusManager({
+     *   adapters: {
+     *     memory: new MemoryEventBusAdapter(),
+     *     redis: new RedisEventBusAdapter({
+     *       dispatcherClient: new Redis();
+     *       listenerClient: new Redis();
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   rootNamespace: "@storage/"
+     * });
+     *
+     * (async () => {
+     *   const addEventSchema = z.zod({
+     *     type: z.literal("add"),
+     *     a: z.number(),
+     *     b: z.number(),
+     *   });
+     *   await eventBusManager
+     *     .withValidation(zodValidator(addEventSchema))
+     *     .use()
+     *     // You will se an typescript error and get runtime erorr
+     *     .dispatch({ type: "add" });
+     * })();
+     * ```
+     */
+    withValidation<TOutput extends TEvents = TEvents>(validator: Validator<TOutput>): IEventBusFactory<TAdapters, TOutput>;
+    /**
+     * The <i>withTypes</i> method is used to set the event types of the <i>{@link IEventBus}</i>.
+     * @example
+     * ```ts
+     * import { EventBusManager, MemoryEventBusAdapter, RedisEventBusAdapter, zodValidator } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     * import { z } from "zod"
+     *
+     * const eventBusManager = new EventBusManager({
+     *   adapters: {
+     *     memory: new MemoryEventBusAdapter(),
+     *     redis: new RedisEventBusAdapter({
+     *       dispatcherClient: new Redis();
+     *       listenerClient: new Redis();
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   rootNamespace: "@storage/"
+     * });
+     *
+     * (async () => {
+     *   type AddEvent = {
+     *     type: "add";
+     *     a: number;
+     *     b: number;
+     *   };
+     *   await eventBusManager
+     *     .withTypes<AddEvent>()
+     *     .use()
+     *     // You will se an typescript error
+     *     .dispatch({ type: "add" });
+     * })();
+     * ```
+     */
+    withType<TOutput extends TEvents = TEvents>(): IEventBusFactory<TAdapters, TOutput>;
 };

package/dist/types/event-bus/contracts/event-bus.contract.d.ts

@@ -9,83 +9,111 @@ export type SelectEvent<TEvents extends IBaseEvent, TEventType extends TEvents["
 export type Unsubscribe = () => PromiseLike<void>;
 /**
  * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
- * @throws {EventBusError} {@link EventBusError}
- * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
- * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
  * @group Contracts
  */
 export type IListenable<TEvents extends IBaseEvent = IBaseEvent> = {
     /**
      * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
-     * @throws {EventBusError} {@link EventBusError}
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
     addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
     /**
      * The <i>addListenerMany</i> method is used for adding multiple <i>{@link Listener | listeners}</i> for certain <i>events</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
-     * @throws {EventBusError} {@link EventBusError}
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
     addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
     /**
      * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
-     * @throws {EventBusError} {@link EventBusError}
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
     removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
     /**
      * The <i>removeListener</i> method is used for removing multiple <i>{@link Listener | listeners}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
-     * @throws {EventBusError} {@link EventBusError}
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
     removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
     /**
      * The <i>subscribe</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
-     * @throws {EventBusError} {@link EventBusError}
-     * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
     subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    /**
+     * The <i>subscribeMany</i> method is used for adding <i>{@link Listener | listener}</i> for multiple <i>events</i>.
+     * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
+     */
     subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
 };
 /**
  * The <i>IEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * It commes with more convient methods compared to <i>IEventBusAdapter</i>.
- * @throws {EventBusError} {@link EventBusError}
- * @throws {DispatchEventBusError} {@link DispatchEventBusError}
- * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
- * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
  * @group Contracts
  */
 export type IEventBus<TEvents extends IBaseEvent = IBaseEvent> = IListenable<TEvents> & {
     /**
      * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
-     * @throws {EventBusError} {@link EventBusError}
+
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
     dispatch(events: OneOrMore<TEvents>): PromiseLike<void>;
+    /**
+     * The <i>getNamespace</i> method return the complete namespace.
+     * @example
+     * ```ts
+     *   const eventBus = new EventBus(new MemoryEventBusAdapter(), {
+     *     rootNamespace: "@root/"
+     *   });
+     *
+     *   // Will be "@root/"
+     *   console.log(eventBus.getNamespace())
+     *
+     *   const eventBusA = eventBus.withNamespace("a/");
+     *
+     *   // Will be "@root/a/"
+     *   console.log(eventBusA.getNamespace())
+     * ```
+     */
+    getNamespace(): string;
 };
 /**
  * The <i>INamespacedEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * It commes with one extra method which is useful for multitennat applications compared to <i>IEventBus</i>.
- * @throws {EventBusError} {@link EventBusError}
- * @throws {DispatchEventBusError} {@link DispatchEventBusError}
- * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
- * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
  * @group Contracts
  */
 export type INamespacedEventBus<TEvents extends IBaseEvent = IBaseEvent> = IEventBus<TEvents> & {
     /**
      * The <i>withNamespace</i> method returns new instance of <i>{@link IEventBus}</i> where all the events names will be prefixed with a given <i>namespace</i>.
      * This useful for multitennat applications.
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     *
+     * (async () => {
+     *   const eventBus = new EventBus(new MemoryEventBusAdapter());
+     *
+     *   const eventBusA = eventBus.withNamespace("a");
+     *   await eventBusA.subscribe("add", (event) => {
+     *     // This will be logged
+     *     console.log("eventBusA:", event);
+     *   });
+     *
+     *   const eventBusB = eventBus.withNamespace("b");
+     *   await eventBusB.subscribe("add", (event) => {
+     *     // This will never be logged
+     *     console.log("eventBusB:", event);
+     *   });
+     *
+     *   await eventBusA.dispatch({
+     *     type: "add",
+     *     a: 1,
+     *     b: 2
+     *   })
+     * })();
+     *
+     * ```
      */
     withNamespace(namespace: string): IEventBus<TEvents>;
-    /**
-     * The <i>getNamespace</i> method return the complete namespace.
-     */
-    getNamespace(): string;
 };

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

@@ -15,6 +15,22 @@ export type EventBusTestSuiteSettings = {
     createAdapter: () => Promisable<IEventBusAdapter>;
 };
 /**
+ * The <i>eventBusAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBusAdapter}</i> with vitest.
+ * @example
+ * ```ts
+ * import { eventBusAdapterTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
+ * import { expext, test, describe, beforeEach } from "vitest";
+ *
+ * describe("class: MemoryEventBusAdapter", () => {
+ *   eventBusAdapterTestSuite({
+ *     createAdapter: () => new MemoryEventBusAdapter(),
+ *     test,
+ *     beforeEach,
+ *     expect,
+ *     describe,
+ *   });
+ * });
+ * ```
  * @group Utilities
  */
-export declare function eventBusTestSuite(settings: EventBusTestSuiteSettings): void;
+export declare function eventBusAdapterTestSuite(settings: EventBusTestSuiteSettings): void;

package/dist/types/event-bus/implementations/event-bus/event-bus-manager.d.ts

@@ -1,23 +1,26 @@
 /**
  * @module EventBus
  */
-import type { INamespacedEventBus, IEventBusAdapter, IEventBusManager, EventBusManagerUseSettings, IBaseEvent } from "../../../event-bus/contracts/_module";
-import { type EventBusSettings } from "../../../event-bus/implementations/event-bus/event-bus";
+import { type Validator } from "../../../utilities/_module";
+import type { INamespacedEventBus, IEventBusAdapter, IEventBusManager, IBaseEvent, IEventBusFactory } from "../../../event-bus/contracts/_module";
 /**
  * @group Derivables
  */
 export type EventBusManagerSettings<TAdapters extends string = string> = {
     adapters: Record<TAdapters, IEventBusAdapter>;
     defaultAdapter: NoInfer<TAdapters>;
-    adapterSettings?: Omit<EventBusSettings<any>, "validator">;
+    rootNamespace: string;
 };
 /**
  * @group Derivables
  */
-export declare class EventBusManager<TAdapters extends string = string> implements IEventBusManager<TAdapters> {
+export declare class EventBusManager<TAdapters extends string = string, TEvent extends IBaseEvent = IBaseEvent> implements IEventBusManager<TAdapters> {
     private readonly adapters;
     private readonly defaultAdapter;
-    private readonly adapterSettings;
+    private readonly rootNamespace;
+    private validator;
     constructor(settings: EventBusManagerSettings<TAdapters>);
-    use<TEvents extends IBaseEvent = IBaseEvent>(adapterSettings: EventBusManagerUseSettings<TEvents, TAdapters>): INamespacedEventBus<TEvents>;
+    use(adapter?: TAdapters): INamespacedEventBus<TEvent>;
+    withValidation<TOutput extends IBaseEvent = IBaseEvent>(validator: Validator<TOutput>): IEventBusFactory<TAdapters, TOutput>;
+    withType<TOutput extends IBaseEvent = IBaseEvent>(): IEventBusFactory<TAdapters, TOutput>;
 }

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

@@ -21,9 +21,6 @@ export declare class DeserializationError extends SerializerError {
 }
 /**
  * @group Contracts
- * @throws {SerializerError} {@link SerializerError}
- * @throws {SerializationError} {@link SerializationError}
- * @throws {DeserializationError} {@link DeserializationError}
  */
 export type ISerializer<TSerialized = unknown> = {
     /**

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

@@ -4,55 +4,38 @@
 /**
  * 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>
- * @throws {StorageError} {@link StorageError}
- * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
- * @throws {TypeStorageError} {@link TypeStorageError}
  * @group Contracts
  */
-export type IStorageAdapter<TType> = {
+export type IStorageAdapter<TType = unknown> = {
     /**
      * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
     /**
      * 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 {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     addMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * 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 {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     putMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * The <i>removesMany</i> method 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}
      */
     removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
      * 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 {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
     increment(key: string, value: number): PromiseLike<boolean>;
     /**
      * The <i>clear</i> method removes all keys that starts <i>prefix</i>.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     clear(prefix: string): PromiseLike<void>;
 };

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

@@ -79,6 +79,7 @@ export type KeysRemovedStorageEvent = StorageEvent & {
     keys: string[];
 };
 /**
+ * This event will be triggered when storage is cleared.
  * @group Events
  */
 export type KeysClearedStorageEvent = StorageEvent & {

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

@@ -4,16 +4,97 @@
 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 StorageManagerUseSettings<TType, TAdapters extends string = string> = {
-    adapter?: TAdapters;
-    validator?: Validator<TType>;
+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 switch between different <i>{@link IStorageAdapter | storage adapters}</i> dynamically.
+ * 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> = {
-    use<TType>(settings?: StorageManagerUseSettings<TType, TAdapters>): INamespacedStorage<TType>;
+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>;
 };