@daiso-tech/core 0.7.0 → 0.8.1

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

@@ -2,7 +2,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 EnsureType, type Lazyable } from "../../../_shared/types";
+import { type Lazyable } from "../../../_shared/types";
 import { type RecordItem } from "../../../_shared/types";
 /**
  * All methods in <i>ListCollection</i> are executed eagerly.
@@ -25,16 +25,16 @@ export declare class ListCollection<TInput> implements ICollection<TInput> {
     reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>): TInput;
     reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>, initialValue: TInput): TInput;
     reduce<TOutput>(reduceFn: Reduce<TInput, ICollection<TInput>, TOutput>, initialValue: TOutput): TOutput;
-    join(separator?: string): EnsureType<TInput, string>;
+    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>>;
     page(page: number, pageSize: number): ICollection<TInput>;
-    sum(): EnsureType<TInput, number>;
-    average(): EnsureType<TInput, number>;
-    median(): EnsureType<TInput, number>;
-    min(): EnsureType<TInput, number>;
-    max(): EnsureType<TInput, number>;
+    sum(): Extract<TInput, number>;
+    average(): Extract<TInput, number>;
+    median(): Extract<TInput, number>;
+    min(): Extract<TInput, number>;
+    max(): Extract<TInput, number>;
     percentage(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
     some<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;
     every<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;

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

@@ -0,0 +1,4 @@
+export * from "../../event-bus/contracts/_shared";
+export * from "../../event-bus/contracts/event-bus.contract";
+export * from "../../event-bus/contracts/event-bus-adapter.contract";
+export * from "../../event-bus/contracts/event-bus-manager.contract";

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

@@ -0,0 +1,38 @@
+/**
+ * @module EventBus
+ */
+import type { Promisable } from "../../_shared/types";
+export type IBaseEvent = {
+    type: string;
+};
+export type Listener<TEvent extends IBaseEvent> = (event: TEvent) => Promisable<void>;
+/**
+ * @group Errors
+ */
+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
+ */
+export declare class RemoveListenerEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class AddListenerEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class DispatchEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
+/**
+ * The <i>IEventBusAdapter</i> contract defines a way for dispatching and listening to events independent of underlying technology.
+ * This interface is not meant to be used directly, instead you should use <i>IEventBus</i>
+ * @group Contracts
+ */
+export type IEventBusAdapter = {
+    /**
+     * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
+     */
+    addListener(event: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    /**
+     * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>event</i>.
+     */
+    removeListener(event: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    /**
+     * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
+     */
+    dispatch(events: IBaseEvent[]): PromiseLike<void>;
+};

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

@@ -0,0 +1,120 @@
+/**
+ * @module EventBus
+ */
+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 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 configure and switch between different <i>{@link IEventBusAdapter | event adapters}</i> dynamically.
+ * @group Contracts
+ */
+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

@@ -0,0 +1,119 @@
+/**
+ * @module EventBus
+ */
+import type { OneOrMore } from "../../_shared/types";
+import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
+export type SelectEvent<TEvents extends IBaseEvent, TEventType extends TEvents["type"]> = Extract<TEvents, {
+    type: IBaseEvent extends TEvents ? string : TEventType;
+}>;
+export type Unsubscribe = () => PromiseLike<void>;
+/**
+ * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
+ * @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 {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 {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 {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 {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.
+     */
+    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>.
+ * @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 {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>.
+ * @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>;
+};

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

@@ -0,0 +1,5 @@
+export * from "../../event-bus/implementations/_shared/test-utilities/_module";
+export * from "../../event-bus/implementations/event-bus/_module";
+export * from "../../event-bus/implementations/memory-event-bus-adapter/_module";
+export * from "../../event-bus/implementations/redis-event-bus-adapter/_module";
+export * from "../../event-bus/implementations/no-op-event-bus-adapter/_module";

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

@@ -0,0 +1 @@
+export * from "../../../../event-bus/implementations/_shared/test-utilities/event-bus-adapter.test-suite";

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

@@ -0,0 +1,36 @@
+/**
+ * @module EventBus
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import type { IEventBusAdapter } from "../../../../event-bus/contracts/_module";
+import { type Promisable } from "../../../../_shared/types";
+/**
+ * @group Utilities
+ */
+export type EventBusTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    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 eventBusAdapterTestSuite(settings: EventBusTestSuiteSettings): void;

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

@@ -0,0 +1,2 @@
+export * from "../../../event-bus/implementations/event-bus/event-bus";
+export * from "../../../event-bus/implementations/event-bus/event-bus-manager";

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

@@ -0,0 +1,26 @@
+/**
+ * @module EventBus
+ */
+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>;
+    rootNamespace: string;
+};
+/**
+ * @group Derivables
+ */
+export declare class EventBusManager<TAdapters extends string = string, TEvent extends IBaseEvent = IBaseEvent> implements IEventBusManager<TAdapters> {
+    private readonly adapters;
+    private readonly defaultAdapter;
+    private readonly rootNamespace;
+    private validator;
+    constructor(settings: EventBusManagerSettings<TAdapters>);
+    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/event-bus/implementations/event-bus/event-bus.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { SelectEvent, Unsubscribe } from "../../../event-bus/contracts/_module";
+import { type IEventBus, type INamespacedEventBus, type IEventBusAdapter, type Listener, type IBaseEvent } from "../../../event-bus/contracts/_module";
+import type { OneOrMore } from "../../../_shared/types";
+/**
+ * @group Derivables
+ */
+export type EventBusSettings<TEvents extends IBaseEvent> = {
+    /**
+     * You can prefix all keys with a given <i>namespace</i>.
+     * This useful if you want to add multitenancy but still use the same database.
+     * @default {""}
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     *
+     * const eventBusA = new EventBus(new MemoryEventBusAdapter(), {
+     *   rootNamespace: "@a/"
+     * });
+     * const eventBusB = new EventBus(new MemoryEventBusAdapter(), {
+     *   rootNamespace: "@b/"
+     * });
+     *
+     * (async () => {
+     *   eventBusB.addListener("add", event => {
+     *     // This will never be logged because eventBusB has different namespace
+     *     console.log("eventBusB:", event);
+     *   });
+     *
+     *   eventBusB.addListener("add", event => {
+     *     // This will be logged
+     *     console.log("eventBusB:", event);
+     *   });
+     *
+     *   await eventBusA.dispatch([
+     *     { type: "add", a: 1, b: 2 }
+     *   ]);
+     * })();
+     * ```
+     */
+    rootNamespace?: string;
+    /**
+     * You can pass a custom <i>{@link Validator}</i> to validate, transform and sanitize your data.
+     * You could also use <i>{@link zodValidator}</i> which enables you to use zod for validating, transforming, and sanitizing.
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter, zodValidator } from "@daiso-tech/core";
+     * import { z } from "zod";
+     *
+     * const addEventSchema = z.object({
+     *   type: z.literal("add"),
+     *   a: z.number(),
+     *   b: z.number(),
+     * });
+     *
+     * const subEventSchema = z.object({
+     *   type: z.literal("sub"),
+     *   c: z.number(),
+     *   d: z.number(),
+     * });
+     *
+     * const eventBus = new EventBus(new MemoryEventBusAdapter(), {
+     *   // Event type will be infered from validator
+     *   validator: zodValidator(addEventSchema.or(subEventSchema))
+     * });
+     *
+     * (async () => {
+     *   // An Typescript error will be seen and ValidationError will be thrown during runtime.
+     *   await eventBus.dispatch([
+     *     {
+     *       type: "none existing",
+     *       noneExistingField: 20
+     *     }
+     *   ]);
+     * })();
+     * ```
+     */
+    validator?: Validator<TEvents>;
+};
+/**
+ * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
+ * @group Derivables
+ */
+export declare class EventBus<TEvents extends IBaseEvent = IBaseEvent> implements INamespacedEventBus<TEvents> {
+    private readonly eventBusAdapter;
+    private readonly namespace_;
+    private readonly validator;
+    constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings<TEvents>);
+    withNamespace(namespace: string): IEventBus<TEvents>;
+    getNamespace(): string;
+    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
+}

package/dist/types/event-bus/implementations/event-bus/with-namespace-event-bus-adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithNamespaceEventBusAdapter implements IEventBusAdapter {
+    private readonly eventBusAdapter;
+    private readonly namespace;
+    private readonly listenerMap;
+    constructor(eventBusAdapter: IEventBusAdapter, namespace: string);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

package/dist/types/event-bus/implementations/event-bus/with-validation-event-bus-adapter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../../utilities/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithValidationEventBusAdapter implements IEventBusAdapter {
+    private readonly eventBusAdapter;
+    private readonly validator;
+    private readonly listenerMap;
+    constructor(eventBusAdapter: IEventBusAdapter, validator: Validator<IBaseEvent>);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

package/dist/types/event-bus/implementations/memory-event-bus-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../event-bus/implementations/memory-event-bus-adapter/_module";

package/dist/types/event-bus/implementations/memory-event-bus-adapter/memory-event-bus-adapter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+import { EventEmitter } from "node:events";
+/**
+ * @group Adapters
+ */
+export declare class MemoryEventBusAdapter implements IEventBusAdapter {
+    private readonly eventEmiter;
+    constructor(eventEmiter?: EventEmitter<[never]>);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

package/dist/types/event-bus/implementations/no-op-event-bus-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter";

package/dist/types/event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module EventBus
+ */
+import type { Listener, IBaseEvent } from "../../../_module";
+import type { IEventBusAdapter } from "../../../event-bus/contracts/event-bus-adapter.contract";
+/**
+ * This <i>NoOpEventBusAdapter</i> will do nothing and is used for easily mocking IEventBus for testing.
+ * @group Adapters
+ */
+export declare class NoOpEventBusAdapter implements IEventBusAdapter {
+    addListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(_events: IBaseEvent[]): Promise<void>;
+}

package/dist/types/event-bus/implementations/redis-event-bus-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../event-bus/implementations/memory-event-bus-adapter/_module";

package/dist/types/event-bus/implementations/redis-event-bus-adapter/redis-event-bus-adapter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module EventBus
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+import type Redis from "ioredis";
+/**
+ * @group Adapters
+ */
+export type RedisEventBusAdapterSettings = {
+    dispatcherClient: Redis;
+    listenerClient: Redis;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class RedisEventBusAdapter implements IEventBusAdapter {
+    private readonly serializer;
+    private readonly dispatcherClient;
+    private readonly listenerClient;
+    private readonly eventEmitter;
+    constructor({ dispatcherClient, listenerClient, serializer, }: RedisEventBusAdapterSettings);
+    private redisListener;
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

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/_module.d.ts

@@ -1,3 +1,5 @@
 export * from "../../storage/contracts/_shared";
 export * from "../../storage/contracts/storage.contract";
 export * from "../../storage/contracts/storage-adapter.contract";
+export * from "../../storage/contracts/storage-events.contract";
+export * from "../../storage/contracts/storage-manager.contract";