@daiso-tech/core 0.16.0 → 0.17.4

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

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type RetrySettings } from "../../../../async/utilities/retry/_module";
+import { type RetrySettings } from "../../../../async/utilities/_module";
 /**
  * @internal
  */

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

@@ -5,26 +5,212 @@ import type { EnsureMap, EnsureRecord } from "../../../collection/contracts/_mod
 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 "../../../utilities/_module";
 import type { TimeSpan } from "../../../utilities/_module";
-import type { LazyPromiseSettings } from "../../../async/_module";
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
 import { LazyPromise } from "../../../async/_module";
+/**
+ * @group Adapters
+ */
+export type AsyncIterableCollectionSettings = {
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     */
+    timeout?: TimeSpan | null;
+};
 /**
  * All methods that return <i>{@link IAsyncCollection}</i> are executed lazly.
  * The methods that return <i>{@link IAsyncCollection}</i> will only be executed when <i>forEach</i> method is called or <i>for await</i> loop.
  * The methods that return <i>{@link PromiseLike}</i> object will execute only when awaited or <i>then</i> method is called.
  * @group Adapters
  */
-export declare class AsyncIterableCollection<TInput> implements IAsyncCollection<TInput> {
+export declare class AsyncIterableCollection<TInput = unknown> implements IAsyncCollection<TInput> {
     private readonly iterable;
-    private readonly settings;
+    /**
+     * The <i>concat<i> static method is a convenient utility for easily concatenating multiple <i>{@link Iterable}</i> or <i>{@link AsyncIterable}</i>.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * class MyAsyncIterable implements AsyncIterable<number> {
+     *   async *[Symbol.iterator](): Iterator<number> {
+     *     yield "a";
+     *     yield "b";
+     *     yield "c";
+     *   }
+     * }
+     *
+     * class MyIterable implements Iterable<number> {
+     *   *[Symbol.iterator](): Iterator<number> {
+     *     yield 1;
+     *     yield 2;
+     *     yield 3;
+     *   }
+     * }
+     *
+     * const collection = AsyncIterableCollection.concat([
+     *   new MyAsyncIterable(),
+     *   new MyIterable(),
+     *   new Set([1, 2, 3]),
+     *   new Map([["a", 1], ["b", 2]]),
+     *   ["a", "b", "c"]
+     * ]);
+     * await collection.toArray();
+     * // ["a", "b", "c", 1, 2, 3, 1, 2, 3, ["a", 1], ["b", 2], "a", "b", "c"]
+     * ```
+     */
     static concat<TValue>(iterables: AsyncIterableValue<AsyncIterableValue<TValue>>): IAsyncCollection<TValue>;
+    /**
+     * The <i>difference</i> static method is used to compute the difference between two <i>{@link Iterable}</i> instances. By default, the equality check is performed on each item.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = AsyncIterableCollection.difference(
+     *   [1, 2, 2, 3, 4, 5],
+     *   [2, 4, 6, 8]
+     * );
+     * await collection.toArray();
+     * // [1, 3, 5]
+     * ```
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = AsyncIterableCollection.difference(
+     *   [
+     *     { name: "iPhone 6", brand: "Apple", type: "phone" },
+     *     { name: "iPhone 5", brand: "Apple", type: "phone" },
+     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
+     *     { name: "Galaxy S6", brand: "Samsung", type: "phone" },
+     *     { name: "Galaxy Gear", brand: "Samsung", type: "watch" },
+     *   ],
+     *   [
+     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
+     *   ],
+     *   (product) => product.type
+     * );
+     * await collection.toArray();
+     * // [
+     * //   { name: "iPhone 6", brand: "Apple", type: "phone" },
+     * //   { name: "iPhone 5", brand: "Apple", type: "phone" },
+     * //   { name: "Galaxy S6", brand: "Samsung", type: "phone" },
+     * // ]
+     * ```
+     */
     static difference<TValue, TSelect>(iterableA: AsyncIterableValue<TValue>, iterableB: AsyncIterableValue<TValue>, selectFn?: AsyncMap<TValue, IAsyncCollection<TValue>, TSelect>): IAsyncCollection<TValue>;
+    /**
+     * The <i>zip</i> static method merges together the values of <i>iterableA</i> with the values of the <i>iterableB</i> at their corresponding index.
+     * The returned collection has size of the shortest collection.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";;
+     *
+     * const collection = AsyncIterableCollection.zip(["Chair", "Desk"], [100, 200]);
+     * await collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";;
+     *
+     * const collection = AsyncIterableCollection.zip(["Chair", "Desk", "Couch"], [100, 200]);
+     * await collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";;
+     *
+     * const collection = AsyncIterableCollection.zip(["Chair", "Desk"], [100, 200, 300]);
+     * await collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     */
     static zip<TValueA, TValueB>(iterableA: AsyncIterableValue<TValueA>, iterableB: AsyncIterableValue<TValueB>): IAsyncCollection<[TValueA, TValueB]>;
     private static DEFAULT_CHUNK_SIZE;
+    private static defaultRetryPolicy;
     private static makeCollection;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
     /**
      * The <i>constructor</i> takes an <i>{@link Iterable}</i> or <i>{@link AsyncIterable}</i>.
+     *
+     * Works with <i>Array</i>.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new AsyncIterableCollection([1, 2, 3, 4]);
+     * ```
+     *
+     * Works with <i>String</i>.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new AsyncIterableCollection("ABCDE");
+     * ```
+     *
+     * Works with <i>Set</i>.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new AsyncIterableCollection(new Set([1, 2, 2 4]));
+     * ```
+     *
+     * Works with <i>Map</i>.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new AsyncIterableCollection(new Map([["a", 1], ["b", 2]]));
+     * ```
+     *
+     * Works with any <i>Iterable</i>.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * class MyIterable implements Iterable<number> {
+     *   *[Symbol.iterator](): Iterator<number> {
+     *     yield 1;
+     *     yield 2;
+     *     yield 3;
+     *   }
+     * }
+     * const collection = new AsyncIterableCollection(new MyIterable());
+     * ```
+     *
+     * Works with any <i>AsyncIterable</i>.
+     * @example
+     * ```ts
+     * import { AsyncIterableCollection } from "@daiso-tech/core";
+     *
+     * class MyIterable implements AsyncIterable<number> {
+     *   async *[Symbol.iterator](): Iterator<number> {
+     *     yield 1;
+     *     yield 2;
+     *     yield 3;
+     *   }
+     * }
+     * const collection = new AsyncIterableCollection(new MyIterable());
+     * ```
      */
-    constructor(iterable?: AsyncIterableValue<TInput>, settings?: LazyPromiseSettings);
+    constructor(iterable?: AsyncIterableValue<TInput>, settings?: AsyncIterableCollectionSettings);
     private createLazyPromise;
     [Symbol.asyncIterator](): AsyncIterator<TInput>;
     toIterator(): AsyncIterator<TInput, void>;

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

@@ -9,15 +9,152 @@ import { type Lazyable } from "../../../utilities/_module";
  * The rest of the methods are executed eagerly.
  * @group Adapters
  */
-export declare class IterableCollection<TInput> implements ICollection<TInput> {
+export declare class IterableCollection<TInput = unknown> implements ICollection<TInput> {
     private readonly iterable;
+    /**
+     * The <i>concat<i> static method is a convenient utility for easily concatenating multiple <i>{@link Iterable}</i>.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * class MyIterable implements Iterable<number> {
+     *   *[Symbol.iterator](): Iterator<number> {
+     *     yield 1;
+     *     yield 2;
+     *     yield 3;
+     *   }
+     * }
+     *
+     * const collection = IterableCollection.concat([
+     *   new MyIterable(),
+     *   new Set([1, 2, 3]),
+     *   new Map([["a", 1], ["b", 2]]),
+     *   ["a", "b", "c"]
+     * ]);
+     * collection.toArray();
+     * // [1, 2, 3, 1, 2, 3, ["a", 1], ["b", 2], "a", "b", "c"]
+     * ```
+     */
     static concat<TValue>(iterables: Iterable<Iterable<TValue>>): ICollection<TValue>;
+    /**
+     * The <i>difference</i> static method is used to compute the difference between two <i>{@link Iterable}</i> instances. By default, the equality check is performed on each item.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = IterableCollection.difference(
+     *   [1, 2, 2, 3, 4, 5],
+     *   [2, 4, 6, 8]
+     * );
+     * collection.toArray();
+     * // [1, 3, 5]
+     * ```
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = IterableCollection.difference(
+     *   [
+     *     { name: "iPhone 6", brand: "Apple", type: "phone" },
+     *     { name: "iPhone 5", brand: "Apple", type: "phone" },
+     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
+     *     { name: "Galaxy S6", brand: "Samsung", type: "phone" },
+     *     { name: "Galaxy Gear", brand: "Samsung", type: "watch" },
+     *   ],
+     *   [
+     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
+     *   ],
+     *   (product) => product.type
+     * );
+     * collection.toArray();
+     * // [
+     * //   { name: "iPhone 6", brand: "Apple", type: "phone" },
+     * //   { name: "iPhone 5", brand: "Apple", type: "phone" },
+     * //   { name: "Galaxy S6", brand: "Samsung", type: "phone" },
+     * // ]
+     * ```
+     */
     static difference<TValue, TSelect>(iterableA: Iterable<TValue>, iterableB: Iterable<TValue>, selectFn?: Map<TValue, ICollection<TValue>, TSelect>): ICollection<TValue>;
+    /**
+     * The <i>zip</i> static method merges together the values of <i>iterableA</i> with the values of the <i>iterableB</i> at their corresponding index.
+     * The returned collection has size of the shortest collection.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";;
+     *
+     * const collection = IterableCollection.zip(["Chair", "Desk"], [100, 200]);
+     * collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";;
+     *
+     * const collection = IterableCollection.zip(["Chair", "Desk", "Couch"], [100, 200]);
+     * collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";;
+     *
+     * const collection = IterableCollection.zip(["Chair", "Desk"], [100, 200, 300]);
+     * collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     */
     static zip<TValueA, TValueB>(iterableA: Iterable<TValueA>, iterableB: Iterable<TValueB>): ICollection<[TValueA, TValueB]>;
     private static DEFAULT_CHUNK_SIZE;
     private static makeCollection;
     /**
      * The <i>constructor</i> takes an <i>{@link Iterable}</i>.
+     *
+     * Works with <i>Array</i>.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new IterableCollection([1, 2, 3, 4]);
+     * ```
+     *
+     * Works with <i>String</i>.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new IterableCollection("ABCDE");
+     * ```
+     *
+     * Works with <i>Set</i>.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new IterableCollection(new Set([1, 2, 2 4]));
+     * ```
+     *
+     * Works with <i>Map</i>.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * const collection = new IterableCollection(new Map([["a", 1], ["b", 2]]));
+     * ```
+     *
+     * Works with any <i>Iterable</i>.
+     * @example
+     * ```ts
+     * import { IterableCollection } from "@daiso-tech/core";
+     *
+     * class MyIterable implements Iterable<number> {
+     *   *[Symbol.iterator](): Iterator<number> {
+     *     yield 1;
+     *     yield 2;
+     *     yield 3;
+     *   }
+     * }
+     * const collection = new IterableCollection(new MyIterable());
+     * ```
      */
     constructor(iterable: Iterable<TInput>);
     [Symbol.iterator](): Iterator<TInput>;

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

@@ -8,13 +8,150 @@ import { type Lazyable } from "../../../utilities/_module";
  * All methods in <i>ListCollection</i> are executed eagerly.
  * @group Adapters
  */
-export declare class ListCollection<TInput> implements ICollection<TInput> {
+export declare class ListCollection<TInput = unknown> implements ICollection<TInput> {
+    /**
+     * The <i>concat<i> static method is a convenient utility for easily concatenating multiple <i>{@link Iterable}</i>.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * class MyIterable implements Iterable<number> {
+     *   *[Symbol.iterator](): Iterator<number> {
+     *     yield 1;
+     *     yield 2;
+     *     yield 3;
+     *   }
+     * }
+     *
+     * const collection = ListCollection.concat([
+     *   new MyIterable(),
+     *   new Set([1, 2, 3]),
+     *   new Map([["a", 1], ["b", 2]]),
+     *   ["a", "b", "c"]
+     * ]);
+     * collection.toArray();
+     * // [1, 2, 3, 1, 2, 3, ["a", 1], ["b", 2], "a", "b", "c"]
+     * ```
+     */
     static concat<TValue>(iterables: Iterable<Iterable<TValue>>): ICollection<TValue>;
+    /**
+     * The <i>difference</i> static method is used to compute the difference between two <i>{@link Iterable}</i> instances. By default, the equality check is performed on each item.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * const collection = ListCollection.difference(
+     *   [1, 2, 2, 3, 4, 5],
+     *   [2, 4, 6, 8]
+     * );
+     * collection.toArray();
+     * // [1, 3, 5]
+     * ```
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * const collection = ListCollection.difference(
+     *   [
+     *     { name: "iPhone 6", brand: "Apple", type: "phone" },
+     *     { name: "iPhone 5", brand: "Apple", type: "phone" },
+     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
+     *     { name: "Galaxy S6", brand: "Samsung", type: "phone" },
+     *     { name: "Galaxy Gear", brand: "Samsung", type: "watch" },
+     *   ],
+     *   [
+     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
+     *   ],
+     *   (product) => product.type
+     * );
+     * collection.toArray();
+     * // [
+     * //   { name: "iPhone 6", brand: "Apple", type: "phone" },
+     * //   { name: "iPhone 5", brand: "Apple", type: "phone" },
+     * //   { name: "Galaxy S6", brand: "Samsung", type: "phone" },
+     * // ]
+     * ```
+     */
     static difference<TValue, TSelect>(iterableA: Iterable<TValue>, iterableB: Iterable<TValue>, selectFn?: Map<TValue, ICollection<TValue>, TSelect>): ICollection<TValue>;
+    /**
+     * The <i>zip</i> static method merges together the values of <i>iterableA</i> with the values of the <i>iterableB</i> at their corresponding index.
+     * The returned collection has size of the shortest collection.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";;
+     *
+     * const collection = ListCollection.zip(["Chair", "Desk"], [100, 200]);
+     * collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";;
+     *
+     * const collection = ListCollection.zip(["Chair", "Desk", "Couch"], [100, 200]);
+     * collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";;
+     *
+     * const collection = ListCollection.zip(["Chair", "Desk"], [100, 200, 300]);
+     * collection.toArray();
+     * // [["Chair", 100], ["Desk", 200]]
+     * ```
+     */
     static zip<TValueA, TValueB>(iterableA: Iterable<TValueA>, iterableB: Iterable<TValueB>): ICollection<[TValueA, TValueB]>;
     private array;
     /**
      * The <i>constructor</i> takes an <i>{@link Iterable}</i>.
+     *
+     * Works with <i>Array</i>.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * const collection = new ListCollection([1, 2, 3, 4]);
+     * ```
+     *
+     * Works with <i>String</i>.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * const collection = new ListCollection("ABCDE");
+     * ```
+     *
+     * Works with <i>Set</i>.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * const collection = new ListCollection(new Set([1, 2, 2 4]));
+     * ```
+     *
+     * Works with <i>Map</i>.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * const collection = new ListCollection(new Map([["a", 1], ["b", 2]]));
+     * ```
+     *
+     * Works with any <i>Iterable</i>.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";
+     *
+     * class MyIterable implements Iterable<number> {
+     *   *[Symbol.iterator](): Iterator<number> {
+     *     yield 1;
+     *     yield 2;
+     *     yield 3;
+     *   }
+     * }
+     * const collection = new ListCollection(new MyIterable());
+     * ```
      */
     constructor(iterable?: Iterable<TInput>);
     [Symbol.iterator](): Iterator<TInput>;

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

@@ -1,5 +1,5 @@
 export * from "../../event-bus/contracts/_shared";
-export * from "../../event-bus/contracts/event-bus.errors";
-export * from "../../event-bus/contracts/event-bus.contract";
 export * from "../../event-bus/contracts/event-bus-adapter.contract";
 export * from "../../event-bus/contracts/event-bus-factory.contract";
+export * from "../../event-bus/contracts/event-bus.contract";
+export * from "../../event-bus/contracts/event-bus.errors";

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

@@ -1,5 +1,16 @@
 /**
  * @module EventBus
  */
+import type { ISerializable } from "../../serde/contracts/_module";
 import type { Promisable } from "../../utilities/_module";
+/**
+ * @group Contracts
+ */
 export type Listener<TEvent> = (event: TEvent) => Promisable<void>;
+/**
+ * @group Contracts
+ */
+export declare abstract class BaseEvent<TData extends Record<string, unknown> = Record<string, unknown>> implements ISerializable<TData> {
+    static deserialize(_serializedEvent: any): BaseEvent;
+    abstract serialize(): TData;
+}

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

@@ -3,9 +3,7 @@
  */
 import type { Listener } from "../../event-bus/contracts/_shared";
 import type { OneOrMore } from "../../utilities/_module";
-export type IBaseEvent = {
-    type: string;
-};
+import type { BaseEvent } 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>
@@ -15,15 +13,15 @@ export type IEventBusAdapter = {
     /**
      * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>eventName</i>.
      */
-    addListener(eventName: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    addListener(eventName: string, listener: Listener<BaseEvent>): PromiseLike<void>;
     /**
      * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>eventName</i>.
      */
-    removeListener(eventName: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    removeListener(eventName: string, listener: Listener<BaseEvent>): PromiseLike<void>;
     /**
      * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
      */
-    dispatch(event: IBaseEvent): PromiseLike<void>;
+    dispatch(eventName: string, eventData: BaseEvent): PromiseLike<void>;
     getGroup(): string;
     withGroup(group: OneOrMore<string>): IEventBusAdapter;
 };

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

@@ -1,53 +1,59 @@
 /**
  * @module EventBus
  */
-import type { BaseEvents, IGroupableEventBus } from "../../event-bus/contracts/event-bus.contract";
+import type { IGroupableEventBus } from "../../event-bus/contracts/event-bus.contract";
+import type { BaseEvent } from "../../event-bus/contracts/_shared";
 /**
  * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link IGroupableEventBus}</i> dynamically.
  * @group Contracts
  */
-export type IEventBusFactory<TDrivers extends string = string, TEvents extends BaseEvents = BaseEvents> = {
+export type IEventBusFactory<TAdapters extends string = string> = {
     /**
-     * The <i>use</i> method will throw an error if you provide it unregisted driver.
-     * If no default driver is defined an error will be thrown by <i>use</i> method.
-     * @throws {UnregisteredDriverError} {@link UnregisteredDriverError}
-     * @throws {DefaultDriverNotDefinedError} {@link DefaultDriverNotDefinedError}
+     * The <i>use</i> method will throw an error if you provide it unregisted adapter.
+     * If no default adapter is defined an error will be thrown by <i>use</i> method.
+     * @throws {UnregisteredAdapterError} {@link UnregisteredAdapterError}
+     * @throws {DefaultAdapterNotDefinedError} {@link DefaultAdapterNotDefinedError}
      * @example
      * ```ts
      * import { type IEventBusFactory } from "@daiso-tech/core";
      *
+     * type SerializedAddEvent = {
+     *   a: number;
+     *   b: number;
+     * };
+     *
+     * class AddEvent extends BaseEvent<SerializedAddEvent> {
+     *   // This needed for adapters that need to deserialize like the redis dapter.
+     *   static override deserialize({ a, b }: SerializedAddEvent): AddEvent {
+     *     return new AddEvent(a, b);
+     *   }
+     *
+     *   constructor(public readonly a: number, public readonly b: number) {
+     *     super();
+     *   }
+     *
+     *   // This needed for adapters that need to serialize like the redis adapter.
+     *   override serialize(): SerializedAddEvent {
+     *     return {
+     *       a: this.a,
+     *       b: this.b
+     *     };
+     *   }
+     * }
+     *
+     * // Asume the inputed eventFactory has registered both a memory and Redis IEventBusAdapter.
+     * // The memory IEventBusAdapter adapter is the default.
      * async function main(eventFactory: IEventBusFactory): Promise<void> {
-     *   // Will dispatch envent using the default driver
+     *   // Will dispatch envent using the default adapter
      *   await eventBusFactory
      *     .use()
-     *     .dispatch({ type: "add", a: 1, b: 2 });
+     *     .dispatch(new AddEvent(1, 2));
      *   // Will dispatch envent using the redis addapter
      *   await eventBusFactory
      *     .use("redis")
-     *     .dispatch({ type: "add", a: 1, b: 2 });
-     * }
-     * ```
-     */
-    use(driverName?: TDrivers): IGroupableEventBus<TEvents>;
-    /**
-     * The <i>withTypes</i> method is used to set the event types of the <i>{@link IEventBus}</i>.
-     * @example
-     * ```ts
-     * import { type IEventBusFactory } from "@daiso-tech/core";
-     *
-     * async function main(eventBusFactory: IEventBusFactory): Promise<void> {
-     *   type AddEvent = {
-     *     type: "add";
-     *     a: number;
-     *     b: number;
-     *   };
-     *   await eventBusFactory
-     *     .withTypes<AddEvent>()
-     *     .use()
-     *     // You will se an typescript error
-     *     .dispatch({ type: "add" });
+     *     .dispatch(new AddEvent(1, 2));
      * }
      * ```
      */
-    withType<TOutput extends TEvents = TEvents>(): IEventBusFactory<TDrivers, TOutput>;
+    use<TEvents extends BaseEvent = BaseEvent>(adapterName?: TAdapters): IGroupableEventBus<TEvents>;
 };