@daiso-tech/core 0.9.0 → 0.10.0

package/dist/types/collection/contracts/async-collection.contract.d.ts

@@ -3,7 +3,7 @@
  */
 import type { AsyncReduce, CrossJoinResult, AsyncPredicate, AsyncForEach, AsyncMap, AsyncModifier, AsyncTap, AsyncTransform, Comparator } from "../../collection/contracts/_shared";
 import type { RecordItem, AsyncLazyable, AsyncIterableValue } from "../../_shared/types";
-import type { TimeSpan } from "../../utilities/_module";
+import type { LazyPromise, TimeSpan } from "../../utilities/_module";
 export type AsyncCollapse<TValue> = TValue extends Array<infer TItem> | Iterable<infer TItem> | IAsyncCollection<infer TItem> ? TItem : TValue;
 /**
  * The <i>IAsyncCollection</i> contract offers a fluent and efficient approach to working with {@link AsyncIterable} objects.
@@ -93,9 +93,9 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * // { 0: "a", 1: "b", 2: "c" }
      * ```
      */
-    reduce(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>): PromiseLike<TInput>;
-    reduce(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>, initialValue: TInput): PromiseLike<TInput>;
-    reduce<TOutput>(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>, initialValue: TOutput): PromiseLike<TOutput>;
+    reduce(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>): LazyPromise<TInput>;
+    reduce(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>, initialValue: TInput): LazyPromise<TInput>;
+    reduce<TOutput>(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>, initialValue: TOutput): LazyPromise<TOutput>;
     /**
      * The <i>join</i> method joins the collection's items with <i> separator </i>. An error will be thrown when if a none string item is encounterd.
      * @throws {TypeCollectionError}
@@ -116,7 +116,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * // "1_2_3_4"
      * ```
      */
-    join(separator?: string): PromiseLike<Extract<TInput, string>>;
+    join(separator?: string): LazyPromise<Extract<TInput, string>>;
     /**
      * The <i>collapse</i> method collapses a collection of iterables into a single, flat collection.
      * @example
@@ -192,7 +192,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.get(5);
      * ```
      */
-    get(index: number): PromiseLike<TInput | null>;
+    get(index: number): LazyPromise<TInput | null>;
     /**
      * The <i>getOrFail</i> method returns the item by index. If the item is not found an error will be thrown.
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
@@ -209,7 +209,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.getOrFail(5);
      * ```
      */
-    getOrFail(index: number): PromiseLike<TInput>;
+    getOrFail(index: number): LazyPromise<TInput>;
     /**
      * The <i>page</i> method returns a new collection containing the items that would be present on <i> page </i> with custom <i> pageSize </i>.
      * @example
@@ -237,7 +237,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    sum(): PromiseLike<Extract<TInput, number>>;
+    sum(): LazyPromise<Extract<TInput, number>>;
     /**
      * The <i>average</i> method returns the average of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @example
@@ -252,7 +252,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    average(): PromiseLike<Extract<TInput, number>>;
+    average(): LazyPromise<Extract<TInput, number>>;
     /**
      * The <i>median</i> method returns the median of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @example
@@ -267,7 +267,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    median(): PromiseLike<Extract<TInput, number>>;
+    median(): LazyPromise<Extract<TInput, number>>;
     /**
      * The <i>min</i> method returns the min of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @example
@@ -282,7 +282,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    min(): PromiseLike<Extract<TInput, number>>;
+    min(): LazyPromise<Extract<TInput, number>>;
     /**
      * The <i>max</i> method returns the max of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @example
@@ -297,7 +297,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    max(): PromiseLike<Extract<TInput, number>>;
+    max(): LazyPromise<Extract<TInput, number>>;
     /**
      * The <i>percentage</i> method may be used to quickly determine the percentage of items in the collection that pass <i>predicateFn</i>.
      * @example
@@ -311,7 +311,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    percentage(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
+    percentage(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
      * The <i>some</i> method determines whether at least one item in the collection matches <i>predicateFn</i>.
      * @example
@@ -324,7 +324,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    some<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<boolean>;
+    some<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<boolean>;
     /**
      * The <i>every</i> method determines whether all items in the collection matches <i>predicateFn</i>.
      * @example
@@ -337,7 +337,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    every<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<boolean>;
+    every<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<boolean>;
     /**
      * The <i>take</i> method takes the first <i>limit</i> items.
      * @example
@@ -517,7 +517,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * // [ 1, 2, 1, 3 ]
      * ```
      */
-    pipe<TOutput = TInput>(callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput>;
+    pipe<TOutput = TInput>(callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
      * The <i>tap</i> method passes a copy of the original collection to <i>callback</i>, allowing you to do something with the items while not affecting the original collection.
      * @example
@@ -1074,7 +1074,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
-    first<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput | null>;
+    first<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | null>;
     /**
      * The <i>firstOr</i> method returns the first item in the collection that passes <i> predicateFn </i>
      * By default it will get the first item. If the collection is empty or no items passes <i> predicateFn </i> than <i> defaultValue </i>.
@@ -1112,7 +1112,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput | TExtended>;
+    firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | TExtended>;
     /**
      * The <i>firstOrFail</i> method returns the first item in the collection that passes <i> predicateFn </i>.
      * By default it will get the first item. If the collection is empty or no items passes <i> predicateFn </i> than error is thrown.
@@ -1143,7 +1143,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
-    firstOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput>;
+    firstOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
      * The <i>last</i> method returns the last item in the collection that passes <i> predicateFn </i>.
      * By default it will get the last item. If the collection is empty or no items passes <i> predicateFn </i> than null i returned.
@@ -1174,7 +1174,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
-    last<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput | null>;
+    last<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | null>;
     /**
      * The <i>lastOr</i> method returns the last item in the collection that passes <i> predicateFn </i>.
      * By default it will get the last item. If the collection is empty or no items passes <i> predicateFn </i> than <i> defaultValue </i>.
@@ -1212,7 +1212,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput | TExtended>;
+    lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | TExtended>;
     /**
      * The <i>lastOrFail</i> method returns the last item in the collection that passes <i> predicateFn </i>.
      * By default it will get the last item. If the collection is empty or no items passes <i> predicateFn </i> than error is thrown.
@@ -1243,7 +1243,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
-    lastOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput>;
+    lastOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
      * The <i>before</i> method returns the item that comes before the first item that matches <i>predicateFn</i>.
      * If the <i>predicateFn</i> does not match or matches the first item then null is returned.
@@ -1265,7 +1265,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    before(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<TInput | null>;
+    before(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | null>;
     /**
      * The <i>beforeOr</i> method returns the item that comes before the first item that matches <i>predicateFn</i>.
      * If the collection is empty or the <i>predicateFn</i> does not match or matches the first item then <i>defaultValue</i> is returned.
@@ -1295,7 +1295,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    beforeOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<TInput | TExtended>;
+    beforeOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | TExtended>;
     /**
      * The <i>beforeOrFail</i> method returns the item that comes before the first item that matches <i>predicateFn</i>.
      * If the collection is empty or the <i>predicateFn</i> does not match or matches the first item then an error is thrown.
@@ -1318,7 +1318,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
-    beforeOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<TInput>;
+    beforeOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput>;
     /**
      * The <i>after</i> method returns the item that comes after the first item that matches <i>predicateFn</i>.
      * If the collection is empty or the <i>predicateFn</i> does not match or matches the last item then null is returned.
@@ -1340,7 +1340,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    after(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<TInput | null>;
+    after(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | null>;
     /**
      * The <i>afterOr</i> method returns the item that comes after the first item that matches <i>predicateFn</i>.
      * If the collection is empty or the <i>predicateFn</i> does not match or matches the last item then <i>defaultValue</i> is returned.
@@ -1370,7 +1370,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    afterOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<TInput | TExtended>;
+    afterOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | TExtended>;
     /**
      * The <i>afterOrFail</i> method returns the item that comes after the first item that matches <i>predicateFn</i>.
      * If the collection is empty or the <i>predicateFn</i> does not match or matches the last item then an error is thrown.
@@ -1393,7 +1393,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
-    afterOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<TInput>;
+    afterOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput>;
     /**
      * The <i>sole</i> method returns the first item in the collection that passes <i>predicateFn</i>, but only if <i>predicateFn</i> matches exactly one item.
      * If no items matches or multiple items are found an error will be thrown.
@@ -1425,7 +1425,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @throws {MultipleItemsFoundCollectionError} {@link MultipleItemsFoundCollectionError}
      */
-    sole<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput>;
+    sole<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
      * The <i>nth</i> method creates a new collection consisting of every n-th item.
      * @example
@@ -1450,22 +1450,22 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    count(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
+    count(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
      * The <i>size</i> returns the size of the collection.
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    size(): PromiseLike<number>;
+    size(): LazyPromise<number>;
     /**
      * The <i>isEmpty</i> returns true if the collection is empty.
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    isEmpty(): PromiseLike<boolean>;
+    isEmpty(): LazyPromise<boolean>;
     /**
      * The <i>isNotEmpty</i> returns true if the collection is not empty.
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    isNotEmpty(): PromiseLike<boolean>;
+    isNotEmpty(): LazyPromise<boolean>;
     /**
      * The <i>searchFirst</i> return the index of the first item that matches <i>predicateFn</i>.
      * @example
@@ -1478,7 +1478,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    searchFirst(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
+    searchFirst(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
      * The <i>searchLast</i> return the index of the last item that matches <i>predicateFn</i>.
      * @example
@@ -1491,17 +1491,17 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    searchLast(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
+    searchLast(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
      * The <i>forEach</i> method iterates through all items in the collection.
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>): PromiseLike<void>;
+    forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>): LazyPromise<void>;
     /**
      * The <i>toArray</i> method converts the collection to a new array.
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    toArray(): PromiseLike<TInput[]>;
+    toArray(): LazyPromise<TInput[]>;
     /**
      * The <i>delay</i> method will add delay between each iteration.
      * This method is especially useful for situations where you may be interacting with external APIs that rate limit incoming requests:

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

@@ -1,12 +1,13 @@
 /**
  * @module EventBus
  */
+import type { LazyPromise } from "../../_module";
 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>;
+export type Unsubscribe = () => LazyPromise<void>;
 /**
  * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
  * @group Contracts
@@ -17,35 +18,35 @@ export type IListenable<TEvents extends IBaseEvent = IBaseEvent> = {
      * 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>;
+    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<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>;
+    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<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>;
+    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<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>;
+    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<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>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<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>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
 };
 /**
  * The <i>IEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
@@ -58,7 +59,7 @@ export type IEventBus<TEvents extends IBaseEvent = IBaseEvent> = IListenable<TEv
 
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
-    dispatch(events: OneOrMore<TEvents>): PromiseLike<void>;
+    dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
     /**
      * The <i>getNamespace</i> method return the complete namespace.
      * @example

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

@@ -96,7 +96,7 @@ export declare class EventBus<TEvents extends IBaseEvent = IBaseEvent> implement
     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>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
     dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
 }

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

@@ -26,9 +26,9 @@ export type ISerializer<TSerialized = unknown> = {
     /**
      * @throws {SerializationError} {@link SerializationError}
      */
-    serialize<TValue>(value: TValue): Promise<TSerialized>;
+    serialize<TValue>(value: TValue): PromiseLike<TSerialized>;
     /**
      * @throws {DeserializationError} {@link DeserializationError}
      */
-    deserialize<TValue>(value: TSerialized): Promise<TValue>;
+    deserialize<TValue>(value: TSerialized): PromiseLike<TValue>;
 };

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

@@ -4,6 +4,7 @@
 import type { IListenable } from "../../event-bus/contracts/_module";
 import { type AnyFunction, type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
 import type { AllStorageEvents } from "../../storage/contracts/_module";
+import type { LazyPromise } from "../../_module";
 export type StorageValue<T> = Exclude<T, AnyFunction | undefined | null>;
 /**
  * The <i>IStorageListenable</i> contract defines a way for listening <i>{@link IStorage}</i> crud operations.
@@ -19,98 +20,98 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * The <i>exists</i> method returns true when <i>key</i> is found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    exists(key: string): PromiseLike<boolean>;
+    exists(key: string): LazyPromise<boolean>;
     /**
      * The <i>existsMany</i> method returns true for the <i>keys</i> that are found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    existsMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>missing</i> method returns true when <i>key</i> is not found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missing(key: string): PromiseLike<boolean>;
+    missing(key: string): LazyPromise<boolean>;
     /**
      * The <i>missingMany</i> method returns true for the <i>keys</i> that are not found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missingMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>get</i> method returns the value when <i>key</i> is found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    get(key: string): PromiseLike<TType | null>;
+    get(key: string): LazyPromise<TType | null>;
     /**
      * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
+    getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
     /**
      * The <i>getOr</i> method returns the value when <i>key</i> is found otherwise <i>defaultValue</i> will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOr(key: string, defaultValue: AsyncLazyable<TType>): PromiseLike<TType>;
+    getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
     /**
      * The <i>getOrMany</i> method returns the value for the keys that are found otherwise defaultValue will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): PromiseLike<Record<TKeys, TType>>;
+    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
     /**
      * The <i>getOrFail</i> method returns the value when <i>key</i> is found otherwise an error will be thrown.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {KeyNotFoundStorageError} {@link KeyNotFoundStorageError}
      */
-    getOrFail(key: string): PromiseLike<TType>;
+    getOrFail(key: string): LazyPromise<TType>;
     /**
      * The <i>add</i> method adds a <i>key</i> with given <i>value</i> when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    add(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    add(key: string, value: StorageValue<TType>): LazyPromise<boolean>;
     /**
      * The <i>addMany</i> method adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>update</i> method updates the given <i>key</i> with given <i>value</i>. Returns true when key otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    update(key: string, value: TType): PromiseLike<boolean>;
+    update(key: string, value: TType): LazyPromise<boolean>;
     /**
      * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>put</i> method replaces the key with given <i>value</i> if found. If the <i>key</i> is not found it will just be added. True is returned if the key is found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    put(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    put(key: string, value: StorageValue<TType>): LazyPromise<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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>remove</i> method removes the given <i>key</i> when found. Returns true if the key is found otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    remove(key: string): PromiseLike<boolean>;
+    remove(key: string): LazyPromise<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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>getAndRemove</i> method removes the given <i>key</i> and returns it when found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getAndRemove(key: string): PromiseLike<TType | null>;
+    getAndRemove(key: string): LazyPromise<TType | null>;
     /**
      * The <i>getOrAdd</i> method will retrieve the given <i>key</i> if found otherwise <i>valueToAdd</i> will be added and returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): PromiseLike<TType>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): LazyPromise<TType>;
     /**
      * 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.
@@ -118,7 +119,7 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
-    increment(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     /**
      * The <i>decrement</i> method will decrement the given <i>key</i> if found otherwise nonthing will occur.
      * Returns true if key exists otherwise false will be returned.
@@ -127,12 +128,12 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * @throws {TypeStorageError} {@link TypeStorageError}
      * An error will thrown if the key is not a number.
      */
-    decrement(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     /**
      * The <i>clear</i> method removes all the keys in the storage.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    clear(): PromiseLike<void>;
+    clear(): LazyPromise<void>;
     /**
      * The <i>getNamespace</i> method return the complete namespace.
      * @example

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

@@ -81,12 +81,12 @@ export declare class Storage<TType = unknown> implements INamespacedStorage<TTyp
     private readonly validator;
     private readonly eventBus;
     constructor(storageAdapter: IStorageAdapter<any>, settings?: StorageSettings<TType>);
-    addListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    addListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    removeListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    removeListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    subscribe<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
-    subscribeMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
+    addListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    subscribe<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
     withNamespace(namespace: string): IStorage<TType>;
     getNamespace(): string;
     exists(key: string): LazyPromise<boolean>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@daiso-tech/core",
     "private": false,
-    "version": "0.9.0",
+    "version": "0.10.0",
     "author": "Yousif Abdulkarim",
     "license": "Apache-2.0",
     "main": "./dist/cjs/_module.js",