@daiso-tech/core 0.15.0 → 0.17.4

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

@@ -5,9 +5,8 @@ import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */
-export declare class AsyncMergeIterable<TInput, TExtended> implements AsyncIterable<TInput | TExtended> {
-    private iterableA;
-    private iterableB;
-    constructor(iterableA: AsyncIterableValue<TInput>, iterableB: AsyncIterableValue<TExtended>);
-    [Symbol.asyncIterator](): AsyncIterator<TInput | TExtended>;
+export declare class AsyncMergeIterable<TInput> implements AsyncIterable<TInput> {
+    private readonly iterables;
+    constructor(iterables: AsyncIterableValue<AsyncIterableValue<TInput>>);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
 }

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,22 +5,213 @@ 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 { 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 static createLazyPromise;
+    /**
+     * 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>);
+    constructor(iterable?: AsyncIterableValue<TInput>, settings?: AsyncIterableCollectionSettings);
+    private createLazyPromise;
     [Symbol.asyncIterator](): AsyncIterator<TInput>;
     toIterator(): AsyncIterator<TInput, void>;
     entries(): IAsyncCollection<[number, TInput]>;

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

@@ -4,9 +4,8 @@
 /**
  * @internal
  */
-export declare class MergeIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
-    private iterableA;
-    private iterableB;
-    constructor(iterableA: Iterable<TInput>, iterableB: Iterable<TExtended>);
-    [Symbol.iterator](): Iterator<TInput | TExtended>;
+export declare class MergeIterable<TInput> implements Iterable<TInput> {
+    private iterables;
+    constructor(iterables: Iterable<Iterable<TInput>>);
+    [Symbol.iterator](): Iterator<TInput>;
 }

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

@@ -9,12 +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,10 +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

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