@daiso-tech/core 0.12.0 → 0.13.0

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

@@ -1,42 +1,6 @@
 /**
  * @module Collection
  */
-/**
- * @group Errors
- */
-export declare class CollectionError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class UnexpectedCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class ItemNotFoundCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class MultipleItemsFoundCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class TypeCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class EmptyCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
 export type Comparator<TItem> = (itemA: TItem, itemB: TItem) => number;
 export type Predicate_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => boolean;
 export type PredicateGuard<TInput, TCollection, TOutput extends TInput = TInput> = (item: TInput, index: number, collection: TCollection) => item is TOutput;
@@ -65,3 +29,5 @@ export type CrossJoinResult<TInput, TExtended> = TInput extends [
     infer R,
     ...infer L
 ] ? [R, ...L, TExtended] : [TInput, TExtended];
+export type EnsureRecord<TInput> = TInput extends [infer TKey, infer TValue] | readonly [infer TKey, infer TValue] ? TKey extends string | number | symbol ? Record<TKey, TValue> : never : never;
+export type EnsureMap<TInput> = TInput extends [infer TKey, infer TValue] | readonly [infer TKey, infer TValue] ? globalThis.Map<TKey, TValue> : never;

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

@@ -1,14 +1,15 @@
 /**
  * @module Collection
  */
-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 { AsyncReduce, CrossJoinResult, AsyncPredicate, AsyncForEach, AsyncMap, AsyncModifier, AsyncTap, AsyncTransform, Comparator, EnsureRecord, EnsureMap } from "../../collection/contracts/_module";
+import type { AsyncLazyable, AsyncIterableValue } from "../../_shared/types";
 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.
  * <i>IAsyncCollection</i> is immutable.
  * @group Contracts
+ * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
  */
 export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
     /**
@@ -18,7 +19,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
     /**
      * The <i>entries</i> returns an IAsyncCollection of key, value pairs for every entry in the collection.
      */
-    entries(): IAsyncCollection<RecordItem<number, TInput>>;
+    entries(): IAsyncCollection<[number, TInput]>;
     /**
      * The <i>keys</i> method returns an IAsyncCollection of keys in the collection.
      */
@@ -195,7 +196,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
     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}
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
@@ -225,6 +225,8 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
     page(page: number, pageSize: number): IAsyncCollection<TInput>;
     /**
      * The <i>sum</i> method returns the sum of all items in the collection. If the collection includes other than number items an error will be thrown.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -233,13 +235,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.sum();
      * // 6
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     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.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -248,13 +249,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.average();
      * // 2
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     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.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -263,13 +263,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.median();
      * // 2
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     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.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -278,13 +277,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.min();
      * // 1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     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.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -293,13 +291,11 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.max();
      * // 3
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     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>.
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -308,8 +304,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.percentage(value => value === 1);
      * // 33.333
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     percentage(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
@@ -322,7 +316,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.some(item => item === 1);
      * // true
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     some<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<boolean>;
     /**
@@ -335,7 +328,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.every(item => item < 6);
      * // true
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     every<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<boolean>;
     /**
@@ -669,7 +661,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * // ]
      * ```
      */
-    groupBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<RecordItem<TOutput, IAsyncCollection<TInput>>>;
+    groupBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<[TOutput, IAsyncCollection<TInput>]>;
     /**
      * The <i>countBy</i> method counts the occurrences of values in the collection by <i> selectFn </i>.
      * By default the equality check occurs on the item.
@@ -702,7 +694,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * // ]
      * ```
      */
-    countBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<RecordItem<TOutput, number>>;
+    countBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<[TOutput, number]>;
     /**
      * The <i>unique</i> method removes all duplicate values from the collection by <i> selectFn </i>.
      * By default the equality check occurs on the item.
@@ -996,7 +988,7 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * // [["Chair", 100], ["Desk", 200]]
      * ```
      */
-    zip<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<RecordItem<TInput, TExtended>>;
+    zip<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<[TInput, TExtended]>;
     /**
      * The <i>sort</i> method sorts the collection. You can provide a <i>comparator</i> function.
      * @example
@@ -1071,7 +1063,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.first(item => item > 10);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
     first<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | null>;
@@ -1110,12 +1101,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.firstOr(() => -1, item => item > 10);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     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.
+     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -1123,16 +1114,16 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * const collection = new AsyncIterableCollection([1, 2, 3, 4]);
      * await collection.firstOrFail();
      * // 1
-     * @example
      * ```
+     * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
      *
      * const collection = new AsyncIterableCollection([1, 2, 3, 4]);
      * await collection.firstOrFail(item => item > 2);
      * // 3
-     * @example
      * ```
+     * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
      *
@@ -1140,8 +1131,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.firstOrFail(item => item > 10);
      * // throws an error
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     firstOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
@@ -1171,7 +1160,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.last(item => item > 10);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
     last<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | null>;
@@ -1210,12 +1198,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.lastOr(() => -1, item => item > 10);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     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.
+     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -1240,8 +1228,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.lastOrFail(item => item > 10);
      * // throws an error
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     lastOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
@@ -1263,7 +1249,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.before(item => item === 1);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     before(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | null>;
     /**
@@ -1293,12 +1278,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.beforeOr(() => -1, item => item === 1);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     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.
+     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -1315,8 +1300,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.beforeOrFail(item => item === 1);
      * // error is thrown
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     beforeOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput>;
     /**
@@ -1338,7 +1321,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.after(item => item === 4);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     after(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | null>;
     /**
@@ -1359,8 +1341,8 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * const collection = new AsyncIterableCollection([1, 2, 3, 4]);
      * await collection.afterOr(-1, item => item === 4);
      * // -1
-     * @example
      * ```
+     * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
      *
@@ -1368,12 +1350,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.afterOr(() => -1, item => item === 4);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     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.
+     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -1390,13 +1372,13 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.afterOrFail(item => item === 4);
      * // error is thrown
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     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.
+     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
+     * @throws {MultipleItemsFoundCollectionError} {@link MultipleItemsFoundCollectionError}
      * @example
      * ```ts
      * import { AsyncIterableCollection } from "@daiso-tech/core";;
@@ -1421,9 +1403,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.sole(item => item === 4);
      * // error is thrown
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
-     * @throws {MultipleItemsFoundCollectionError} {@link MultipleItemsFoundCollectionError}
      */
     sole<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
@@ -1448,22 +1427,18 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.count(value => value % 2 === 0);
      * // 3
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     count(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
      * The <i>size</i> returns the size of the collection.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     size(): LazyPromise<number>;
     /**
      * The <i>isEmpty</i> returns true if the collection is empty.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     isEmpty(): LazyPromise<boolean>;
     /**
      * The <i>isNotEmpty</i> returns true if the collection is not empty.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     isNotEmpty(): LazyPromise<boolean>;
     /**
@@ -1476,7 +1451,6 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.searchFirst(item => item === "b");
      * // 1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     searchFirst(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
@@ -1489,19 +1463,12 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * await collection.searchLast(item => item === "b");
      * // 2
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     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>>): LazyPromise<void>;
-    /**
-     * The <i>toArray</i> method converts the collection to a new array.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     */
-    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:
@@ -1553,4 +1520,16 @@ export type IAsyncCollection<TInput> = AsyncIterable<TInput> & {
      * ```
      */
     takeUntilTimeout(timeInMs: TimeSpan, shouldThrow?: boolean): IAsyncCollection<TInput>;
+    /**
+     * The <i>toArray</i> method converts the collection to a new <i>{@link Array}</i>.
+     */
+    toArray(): LazyPromise<TInput[]>;
+    /**
+     * The <i>toRecord</i> method converts the collection to a new <i>{@link Record}</i>.
+     */
+    toRecord(): LazyPromise<EnsureRecord<TInput>>;
+    /**
+     * The <i>toMap</i> method converts the collection to a new <i>{@link Map}</i>.
+     */
+    toMap(): LazyPromise<EnsureMap<TInput>>;
 };