@daiso-tech/core 0.4.0 → 0.6.0

package/dist/types/contracts/collection/_shared.d.ts

@@ -48,19 +48,19 @@ export type ForEach<TInput, TCollection> = (item: TInput, index: number, collect
 export type Modifier<TInput, TOutput> = (collection: TInput) => TOutput;
 export type Tap<TCollection> = (collection: TCollection) => void;
 export type Transform<TInput, TOutput> = (value: TInput) => TOutput;
-export type AsyncPredicate_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => Promise<boolean>;
+export type AsyncPredicate_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => PromiseLike<boolean>;
 export type AsyncPredicate<TInput, TCollection, TOutput extends TInput = TInput> = AsyncPredicate_<TInput, TCollection> | Predicate<TInput, TCollection, TOutput>;
-export type AsyncReduce_<TInput, TCollection, TOutput> = (output: TOutput, item: TInput, index: number, collection: TCollection) => Promise<TOutput>;
+export type AsyncReduce_<TInput, TCollection, TOutput> = (output: TOutput, item: TInput, index: number, collection: TCollection) => PromiseLike<TOutput>;
 export type AsyncReduce<TInput, TCollection, TOutput> = AsyncReduce_<TInput, TCollection, TOutput> | Reduce<TInput, TCollection, TOutput>;
-export type AsyncMap_<TInput, TCollection, TOutput> = (item: TInput, index: number, collection: TCollection) => Promise<TOutput>;
+export type AsyncMap_<TInput, TCollection, TOutput> = (item: TInput, index: number, collection: TCollection) => PromiseLike<TOutput>;
 export type AsyncMap<TInput, TCollection, TOutput> = AsyncMap_<TInput, TCollection, TOutput> | Map<TInput, TCollection, TOutput>;
-export type AsyncForEach_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => Promise<void>;
+export type AsyncForEach_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => PromiseLike<void>;
 export type AsyncForEach<TInput, TCollection> = ForEach<TInput, TCollection> | AsyncForEach_<TInput, TCollection>;
-export type AsyncModifier_<TInput, TOutput> = (collection: TInput) => Promise<TOutput>;
+export type AsyncModifier_<TInput, TOutput> = (collection: TInput) => PromiseLike<TOutput>;
 export type AsyncModifier<TInput, TOutput> = Modifier<TInput, TOutput> | AsyncModifier_<TInput, TOutput>;
-export type AsyncTap_<TCollection> = (collection: TCollection) => Promise<void>;
+export type AsyncTap_<TCollection> = (collection: TCollection) => PromiseLike<void>;
 export type AsyncTap<TCollection> = Tap<TCollection> | AsyncTap_<TCollection>;
-export type AsyncTransform_<TInput, TOutput> = (value: TInput) => Promise<TOutput>;
+export type AsyncTransform_<TInput, TOutput> = (value: TInput) => PromiseLike<TOutput>;
 export type AsyncTransform<TInput, TOutput> = Transform<TInput, TOutput> | AsyncTransform_<TInput, TOutput>;
 export type CrossJoinResult<TInput, TExtended> = TInput extends [
     infer R,

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

@@ -3,6 +3,7 @@
  */
 import type { AsyncReduce, CrossJoinResult, AsyncPredicate, AsyncForEach, AsyncMap, AsyncModifier, AsyncTap, AsyncTransform, Comparator, ChangendItem } from "../../contracts/collection/_shared";
 import type { RecordItem, AsyncLazyable, EnsureType, AsyncIterableValue } from "../../_shared/types";
+import type { TimeSpan } from "../../_module";
 export type AsyncCollapse<TValue> = TValue extends Array<infer TItem> | Iterable<infer TItem> | IAsyncCollection<infer TItem> ? TItem : TValue;
 /**
  * <i>IAsyncCollection</i> is immutable. The <i>throwOnIndexOverflow</i> parameter in the <i>IAsyncCollection</i> methods is used for preventing the index to overflow by throwing an error.
@@ -87,9 +88,9 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * );
      * // { 0: "a", 1: "b", 2: "c" }
      */
-    reduce(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>): Promise<TInput>;
-    reduce(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>, initialValue: TInput): Promise<TInput>;
-    reduce<TOutput>(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>, initialValue: TOutput): Promise<TOutput>;
+    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>;
     /**
      * 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}
@@ -106,7 +107,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.map(item => item.toString()).join("_");
      * // "1_2_3_4"
      */
-    join(separator?: string): Promise<EnsureType<TInput, string>>;
+    join(separator?: string): PromiseLike<EnsureType<TInput, string>>;
     /**
      * The <i>collapse</i> method collapses a collection of iterables into a single, flat collection.
      * @example
@@ -164,7 +165,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    sum(): Promise<EnsureType<TInput, number>>;
+    sum(): PromiseLike<EnsureType<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
@@ -178,7 +179,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    average(): Promise<EnsureType<TInput, number>>;
+    average(): PromiseLike<EnsureType<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
@@ -192,7 +193,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    median(): Promise<EnsureType<TInput, number>>;
+    median(): PromiseLike<EnsureType<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
@@ -206,7 +207,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    min(): Promise<EnsureType<TInput, number>>;
+    min(): PromiseLike<EnsureType<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
@@ -220,7 +221,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    max(): Promise<EnsureType<TInput, number>>;
+    max(): PromiseLike<EnsureType<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
@@ -233,7 +234,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
-    percentage(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<number>;
+    percentage(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
     /**
      * The <i>some</i> method determines whether at least one item in the collection matches <i>predicateFn</i>.
      * @example
@@ -245,7 +246,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    some<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): Promise<boolean>;
+    some<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<boolean>;
     /**
      * The <i>every</i> method determines whether all items in the collection matches <i>predicateFn</i>.
      * @example
@@ -257,7 +258,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    every<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): Promise<boolean>;
+    every<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<boolean>;
     /**
      * The <i>take</i> method takes the first <i>limit</i> items.
      * @example
@@ -409,7 +410,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * console.log(piped);
      * // [ 1, 2, 1, 3 ]
      */
-    pipe<TOutput = TInput>(callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>): Promise<TOutput>;
+    pipe<TOutput = TInput>(callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>): PromiseLike<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
@@ -888,7 +889,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
-    first<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput | null>;
+    first<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<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>.
@@ -919,7 +920,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput | TExtended>;
+    firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<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.
@@ -945,7 +946,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>): Promise<TOutput>;
+    firstOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<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.
@@ -971,7 +972,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
-    last<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput | null>;
+    last<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<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>.
@@ -1002,7 +1003,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput | TExtended>;
+    lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<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.
@@ -1028,7 +1029,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>): Promise<TOutput>;
+    lastOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<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.
@@ -1047,7 +1048,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    before(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<TInput | null>;
+    before(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<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.
@@ -1072,7 +1073,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    beforeOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<TInput | TExtended>;
+    beforeOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<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.
@@ -1092,7 +1093,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
-    beforeOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<TInput>;
+    beforeOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<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.
@@ -1111,7 +1112,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    after(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<TInput | null>;
+    after(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<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.
@@ -1136,7 +1137,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    afterOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<TInput | TExtended>;
+    afterOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<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.
@@ -1156,7 +1157,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
-    afterOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<TInput>;
+    afterOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<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.
@@ -1183,7 +1184,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>): Promise<TOutput>;
+    sole<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): PromiseLike<TOutput>;
     /**
      * The <i>nth</i> method creates a new collection consisting of every n-th item.
      * @example
@@ -1205,25 +1206,25 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    count(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<number>;
+    count(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
     /**
      * The <i>size</i> returns the size of the collection.
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    size(): Promise<number>;
+    size(): PromiseLike<number>;
     /**
      * The <i>isEmpty</i> returns true if the collection is empty.
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    isEmpty(): Promise<boolean>;
+    isEmpty(): PromiseLike<boolean>;
     /**
      * The <i>isNotEmpty</i> returns true if the collection is not empty.
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    isNotEmpty(): Promise<boolean>;
+    isNotEmpty(): PromiseLike<boolean>;
     /**
      * The <i>searchFirst</i> return the index of the first item that matches <i>predicateFn</i>.
      * @example
@@ -1235,7 +1236,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    searchFirst(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<number>;
+    searchFirst(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
     /**
      * The <i>searchLast</i> return the index of the last item that matches <i>predicateFn</i>.
      * @example
@@ -1247,21 +1248,21 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    searchLast(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): Promise<number>;
+    searchLast(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): PromiseLike<number>;
     /**
      * The <i>forEach</i> method iterates through all items in the collection.
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>): Promise<void>;
+    forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>): PromiseLike<void>;
     /**
      * The <i>toArray</i> method converts the collection to a new array.
      * @throws {CollectionError} {@link CollectionError}
      * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
-    toArray(): Promise<TInput[]>;
+    toArray(): PromiseLike<TInput[]>;
     /**
-     * The delay method will delay collection such that each value is returned after the specified number of seconds.
+     * 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:
      * @example
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -1272,10 +1273,21 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * const collection = new AsyncIterableCollection(apiIterator);
      * await collection.delay(1000).forEach(user => console.log(user))
      */
-    delay(timeInMs: number): IAsyncCollection<TInput>;
-    abort(signal: AbortSignal): IAsyncCollection<TInput>;
+    delay(time: TimeSpan): IAsyncCollection<TInput>;
     /**
-     * The timeout method returns a new collection that will iterate values until the specified time.
+     * The <i>abort</i> method will abort iteration of the collection by passing <i>{@link AbortSignal}</i>.
+     * @example
+     * import { AsyncIterableCollection } from "@daiso-tech/core";;
+     *
+     * // An iterator that will fetch all users from a specific api
+     * class ApiIterator implements AsyncIterable<IUser> { ... }
+     * const apiIterator = new ApiIterator();
+     * const collection = new AsyncIterableCollection(apiIterator);
+     * await collection.delay(1000).forEach(user => console.log(user))
+     */
+    takeUntilAbort(abortSignal: AbortSignal, shouldThrow?: boolean): IAsyncCollection<TInput>;
+    /**
+     * The <I>timeout</i> method returns a new collection that will iterate values until the specified time.
      * After that time, the collection will then stop iterating:
      * @example
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -1293,5 +1305,5 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      *  .timeout(1000)
      *  .forEach(nbr => console.log(nbr))
      */
-    timeout(timeInMs: number): IAsyncCollection<TInput>;
+    takeUntilTimeout(timeInMs: TimeSpan, shouldThrow?: boolean): IAsyncCollection<TInput>;
 };

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

@@ -1,7 +1,6 @@
 /**
  * @module Storage
  */
-import type { GetOrAddResult } from "../../_shared/types";
 /**
  * @throws {StorageError} {@link StorageError}
  * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
@@ -9,64 +8,46 @@ import type { GetOrAddResult } from "../../_shared/types";
  * @group Contracts
  */
 export type IStorageAdapter<TType> = {
-    /**
-     * Returns true for the keys that are found otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
-     */
-    existsMany?<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
     /**
      * Returns the value for the keys that are found otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TValues | null>>;
     /**
      * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    putMany?<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
-    /**
-     * If the key is found the value be returned and key will be removed otherwise null will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
-     */
-    getAndRemove?<TValue extends TType>(key: string): Promise<TValue | null>;
-    /**
-     * If the key is found the value be returned otherwise valueToAdd will be added and returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
-     */
-    getOrAdd?<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: TExtended): Promise<GetOrAddResult<TValue | TExtended>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Will increment the existing key with value if found otherwise nonthing occurs. Returns true if key exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
-    increment?(key: string, value: number): Promise<boolean>;
+    increment(key: string, value: number): PromiseLike<boolean>;
     /**
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    clear(prefix: string): Promise<void>;
+    clear(prefix: string): PromiseLike<void>;
 };

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

@@ -16,133 +16,133 @@ export type IStorage<TType = unknown> = {
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    exists(key: string): Promise<boolean>;
+    exists(key: string): PromiseLike<boolean>;
     /**
      * Returns true for the keys that are found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    existsMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Returns true when key is not found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missing(key: string): Promise<boolean>;
+    missing(key: string): PromiseLike<boolean>;
     /**
      * Returns true for the keys that are not found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missingMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    missingMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Returns the value when key is found otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    get<TValue extends TType>(key: string): Promise<TValue | null>;
+    get<TValue extends TType>(key: string): PromiseLike<TValue | null>;
     /**
      * Returns the value for the keys that are found otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TValues | null>>;
     /**
      * Returns the value when key is found otherwise defaultValue will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOr<TValue extends TType, TExtended extends TType>(key: string, defaultValue: AsyncLazyable<TExtended>): Promise<TValue | TExtended>;
+    getOr<TValue extends TType, TExtended extends TType>(key: string, defaultValue: AsyncLazyable<TExtended>): PromiseLike<TValue | TExtended>;
     /**
      * Returns the value for the keys that are found otherwise defaultValue will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrMany<TValues extends TType, TExtended extends TType, TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TExtended>>): Promise<Record<TKeys, TValues | TExtended>>;
+    getOrMany<TValues extends TType, TExtended extends TType, TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TExtended>>): PromiseLike<Record<TKeys, TValues | TExtended>>;
     /**
      * Returns the value when key is found otherwise an error will be thrown.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {KeyNotFoundStorageError} {@link KeyNotFoundStorageError}
      */
-    getOrFail<TValue extends TType>(key: string): Promise<TValue>;
+    getOrFail<TValue extends TType>(key: string): PromiseLike<TValue>;
     /**
      * Adds a key when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    add<TValue extends TType>(key: string, value: StorageValue<TValue>): Promise<boolean>;
+    add<TValue extends TType>(key: string, value: StorageValue<TValue>): PromiseLike<boolean>;
     /**
      * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, StorageValue<TValues>>): Promise<Record<TKeys, boolean>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, StorageValue<TValues>>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Updates a keys that exists. Returns true when key otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    update<TValue extends TType>(key: string, value: TValue): Promise<boolean>;
+    update<TValue extends TType>(key: string, value: TValue): PromiseLike<boolean>;
     /**
      * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * If the key is found it will replaced. If the key is not found it will just be added. True is returned if the key is found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    put<TValue extends TType>(key: string, value: StorageValue<TValue>): Promise<boolean>;
+    put<TValue extends TType>(key: string, value: StorageValue<TValue>): PromiseLike<boolean>;
     /**
      * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, StorageValue<TValues>>): Promise<Record<TKeys, boolean>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, StorageValue<TValues>>): PromiseLike<Record<TKeys, boolean>>;
     /**
      * Removes the key when found. Returns true if the key is found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    remove(key: string): Promise<boolean>;
+    remove(key: string): PromiseLike<boolean>;
     /**
      * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
      * If the key is found the value be returned and key will be removed otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
+    getAndRemove<TValue extends TType>(key: string): PromiseLike<TValue | null>;
     /**
      * If the key is found the value be returned otherwise valueToAdd will be added and returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TExtended>>>): Promise<TValue | TExtended>;
+    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TExtended>>>): PromiseLike<TValue | TExtended>;
     /**
      * Will increment the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
-    increment(key: string, value?: number): Promise<boolean>;
+    increment(key: string, value?: number): PromiseLike<boolean>;
     /**
      * Will decrement the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
-    decrement(key: string, value?: number): Promise<boolean>;
+    decrement(key: string, value?: number): PromiseLike<boolean>;
     /**
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    clear(): Promise<void>;
+    clear(): PromiseLike<void>;
 };

package/dist/types/storage/memory-storage-adapter/memory-storage-adapter.d.ts

@@ -8,6 +8,8 @@ import { type IStorageAdapter } from "../../contracts/storage/storage-adapter.co
 export declare class MemoryStorageAdapter<TType> implements IStorageAdapter<TType> {
     private readonly map;
     constructor(map?: Map<string, TType>);
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
     getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
     addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
     updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;

package/dist/types/storage/mongodb-storage-adapter/mongodb-storage-adapter.d.ts

@@ -2,7 +2,6 @@
  * @module Storage
  */
 import { type ISerializer } from "../../contracts/serializer/_module";
-import type { GetOrAddResult } from "../../_shared/types";
 import { type IInitizable } from "../../_shared/types";
 import { type IStorageAdapter } from "../../contracts/storage/_module";
 import { type Collection, ObjectId } from "mongodb";
@@ -39,8 +38,6 @@ export declare class MongodbStorageAdapter<TType> implements IStorageAdapter<TTy
     putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
     private removeOne;
     removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
-    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
-    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: TExtended): Promise<GetOrAddResult<TValue | TExtended>>;
     increment(key: string, value: number): Promise<boolean>;
     clear(prefix: string): Promise<void>;
 }