@daiso-tech/core 0.12.0 → 0.13.0

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

@@ -1,15 +1,16 @@
 /**
  * @module Collection
  */
-import type { Comparator, Predicate, ForEach, Map, Modifier, Tap, Transform, Reduce, CrossJoinResult } from "../../collection/contracts/_shared";
-import type { Lazyable, RecordItem } from "../../_shared/types";
+import type { Comparator, Predicate, ForEach, Map, Modifier, Tap, Transform, Reduce, CrossJoinResult, EnsureMap, EnsureRecord } from "../../collection/contracts/_module";
+import type { Lazyable } from "../../_shared/types";
 export type Collapse<TValue> = TValue extends Array<infer TItem> | Iterable<infer TItem> | ICollection<infer TItem> ? TItem : TValue;
 /**
  * The <i>ICollection</i> contract offers a fluent and efficient approach to working with {@link Iterable} objects.
  * <i>ICollection</i> is immutable.
  * @group Contracts
+ * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
  */
-export type ICollection<TInput> = Iterable<TInput> & {
+export type ICollection<TInput = unknown> = Iterable<TInput> & {
     /**
      * The <i>toIterator</i> method converts the collection to a new iterator.
      */
@@ -17,7 +18,7 @@ export type ICollection<TInput> = Iterable<TInput> & {
     /**
      * The <i>entries</i> returns an ICollection of key, value pairs for every entry in the collection.
      */
-    entries(): ICollection<RecordItem<number, TInput>>;
+    entries(): ICollection<[number, TInput]>;
     /**
      * The <i>keys</i> method returns an ICollection of keys in the collection.
      */
@@ -194,7 +195,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
     get(index: number): 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 ICollection<TInput> = Iterable<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.
      * If the collection is empty an error will also be thrown.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { ListCollection } from "@daiso-tech/core";;
@@ -233,14 +235,13 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.sum();
      * // 6
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     sum(): 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.
      * If the collection is empty an error will also be thrown.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { ListCollection } from "@daiso-tech/core";;
@@ -249,14 +250,13 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.average();
      * // 2
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     average(): 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.
      * If the collection is empty an error will also be thrown.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { ListCollection } from "@daiso-tech/core";;
@@ -265,14 +265,13 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.median();
      * // 2
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     median(): 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.
      * If the collection is empty an error will also be thrown.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { ListCollection } from "@daiso-tech/core";;
@@ -281,14 +280,13 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.min();
      * // 1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     min(): 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.
      * If the collection is empty an error will also be thrown.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { ListCollection } from "@daiso-tech/core";;
@@ -297,14 +295,12 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.max();
      * // 3
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {TypeCollectionError} {@link TypeCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     max(): 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>.
      * If the collection is empty an error will also be thrown.
+     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
      * import { ListCollection } from "@daiso-tech/core";;
@@ -313,8 +309,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.percentage(value => value === 1);
      * // 33.333
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      */
     percentage(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
     /**
@@ -327,7 +321,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.some(item => item === 1);
      * // true
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     some<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;
     /**
@@ -340,7 +333,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.every(item => item < 6);
      * // true
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     every<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;
     /**
@@ -675,7 +667,7 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * // ]
      * ```
      */
-    groupBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, ICollection<TInput>>>;
+    groupBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<[TOutput, ICollection<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.
@@ -708,7 +700,7 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * // ]
      * ```
      */
-    countBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, number>>;
+    countBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<[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.
@@ -1002,7 +994,7 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * // [["Chair", 100], ["Desk", 200]]
      * ```
      */
-    zip<TExtended>(iterable: Iterable<TExtended>): ICollection<RecordItem<TInput, TExtended>>;
+    zip<TExtended>(iterable: Iterable<TExtended>): ICollection<[TInput, TExtended]>;
     /**
      * The <i>sort</i> method sorts the collection. You can provide a <i>comparator</i> function.
      * @example
@@ -1076,7 +1068,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.first(item => item > 10);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
     first<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | null;
@@ -1115,12 +1106,12 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.firstOr(() => -1, item => item > 10);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): 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 { ListCollection } from "@daiso-tech/core";;
@@ -1145,8 +1136,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.firstOrFail(item => item > 10);
      * // throws an error
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     firstOrFail<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
     /**
@@ -1176,7 +1165,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.last(item => item > 10);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      * // 3
      */
     last<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | null;
@@ -1215,12 +1203,12 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.lastOr(() => -1, item => item > 10);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): 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 { ListCollection } from "@daiso-tech/core";;
@@ -1245,8 +1233,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.lastOrFail(item => item > 10);
      * // throws an error
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     lastOrFail<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
     /**
@@ -1268,7 +1254,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.before(item => item === 1);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     before(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | null;
     /**
@@ -1298,12 +1283,12 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.beforeOr(() => -1, item => item === 1);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     beforeOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn: Predicate<TInput, ICollection<TInput>>): 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 { ListCollection } from "@daiso-tech/core";;
@@ -1320,8 +1305,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.beforeOrFail(item => item === 1);
      * // error is thrown
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     beforeOrFail(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput;
     /**
@@ -1343,7 +1326,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.after(item => item === 4);
      * // null
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     after(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | null;
     /**
@@ -1373,12 +1355,12 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.afterOr(() => -1, item => item === 4);
      * // -1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     afterOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn: Predicate<TInput, ICollection<TInput>>): 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 { ListCollection } from "@daiso-tech/core";;
@@ -1395,13 +1377,13 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.afterOrFail(item => item === 4);
      * // error is thrown
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
-     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      */
     afterOrFail(predicateFn: Predicate<TInput, ICollection<TInput>>): 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 { ListCollection } from "@daiso-tech/core";;
@@ -1426,9 +1408,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * 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: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
     /**
@@ -1453,22 +1432,18 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.count(value => value % 2 === 0);
      * // 3
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     count(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
     /**
      * The <i>size</i> returns the size of the collection.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     size(): number;
     /**
      * The <i>isEmpty</i> returns true if the collection is empty.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     isEmpty(): boolean;
     /**
      * The <i>isNotEmpty</i> returns true if the collection is not empty.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     isNotEmpty(): boolean;
     /**
@@ -1481,7 +1456,6 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.searchFirst(item => item === "b");
      * // 1
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     searchFirst(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
     /**
@@ -1494,17 +1468,24 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * collection.searchLast(item => item === "b");
      * // 2
      * ```
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     searchLast(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
     /**
      * The <i>forEach</i> method iterates through all items in the collection.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
      */
     forEach(callback: ForEach<TInput, ICollection<TInput>>): void;
     /**
-     * The <i>toArray</i> method converts the collection to a new array.
-     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
+     * The <i>toArray</i> method converts the collection to a new <i>{@link Array}</i>.
      */
     toArray(): TInput[];
+    /**
+     * The <i>toRecord</i> method converts the collection to a new <i>{@link Record}</i>.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     */
+    toRecord(): EnsureRecord<TInput>;
+    /**
+     * The <i>toMap</i> method converts the collection to a new <i>{@link Map}</i>.
+     * @throws {TypeCollectionError} {@link TypeCollectionError}
+     */
+    toMap(): EnsureMap<TInput>;
 };

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

@@ -0,0 +1,39 @@
+/**
+ * @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);
+}

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

@@ -2,13 +2,12 @@
  * @module Collection
  */
 import { type AsyncMap, type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type RecordItem } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class AsyncCountByIterable<TInput, TOutput = TInput> implements AsyncIterable<RecordItem<TOutput, number>> {
+export declare class AsyncCountByIterable<TInput, TOutput = TInput> implements AsyncIterable<[TOutput, number]> {
     private collection;
     private callback;
     constructor(collection: IAsyncCollection<TInput>, callback?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>);
-    [Symbol.asyncIterator](): AsyncIterator<RecordItem<TOutput, number>>;
+    [Symbol.asyncIterator](): AsyncIterator<[TOutput, number]>;
 }

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

@@ -2,12 +2,11 @@
  * @module Collection
  */
 import { type AsyncIterableValue } from "../../../../_shared/types";
-import { type RecordItem } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class AsyncEntriesIterable<TInput> implements AsyncIterable<RecordItem<number, TInput>> {
+export declare class AsyncEntriesIterable<TInput> implements AsyncIterable<[number, TInput]> {
     private iterable;
     constructor(iterable: AsyncIterableValue<TInput>);
-    [Symbol.asyncIterator](): AsyncIterator<RecordItem<number, TInput>>;
+    [Symbol.asyncIterator](): AsyncIterator<[number, TInput]>;
 }

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

@@ -2,14 +2,17 @@
  * @module Collection
  */
 import { type AsyncMap, type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type AsyncIterableValue, type RecordItem } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class AsyncGroupByIterable<TInput, TOutput = TInput> implements AsyncIterable<RecordItem<TOutput, IAsyncCollection<TInput>>> {
+export declare class AsyncGroupByIterable<TInput, TOutput = TInput> implements AsyncIterable<[TOutput, IAsyncCollection<TInput>]> {
     private collection;
     private selectFn;
     private makeCollection;
     constructor(collection: IAsyncCollection<TInput>, selectFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput> | undefined, makeCollection: <TInput>(iterable: AsyncIterableValue<TInput>) => IAsyncCollection<TInput>);
-    [Symbol.asyncIterator](): AsyncIterator<RecordItem<TOutput, IAsyncCollection<TInput>>>;
+    [Symbol.asyncIterator](): AsyncIterator<[
+        TOutput,
+        IAsyncCollection<TInput>
+    ]>;
 }

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

@@ -5,7 +5,7 @@ import { type AsyncPredicate, type AsyncMap, type IAsyncCollection } from "../..
 /**
  * @internal
  */
-export declare class AsyncUpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements AsyncIterable<TInput | TFilterOutput | TMapOutput> {
+export declare class AsyncChangeIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements AsyncIterable<TInput | TFilterOutput | TMapOutput> {
     private collection;
     private predicateFn;
     private mapFn;

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

@@ -2,13 +2,12 @@
  * @module Collection
  */
 import { type AsyncIterableValue } from "../../../../_shared/types";
-import { type RecordItem } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class AsyncZipIterable<TInput, TExtended> implements AsyncIterable<RecordItem<TInput, TExtended>> {
+export declare class AsyncZipIterable<TInput, TExtended> implements AsyncIterable<[TInput, TExtended]> {
     private iterableA;
     private iterableB;
     constructor(iterableA: AsyncIterableValue<TInput>, iterableB: AsyncIterableValue<TExtended>);
-    [Symbol.asyncIterator](): AsyncIterator<RecordItem<TInput, TExtended>>;
+    [Symbol.asyncIterator](): AsyncIterator<[TInput, TExtended]>;
 }

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

@@ -1,9 +1,9 @@
 /**
  * @module Collection
  */
+import type { EnsureMap, EnsureRecord } from "../../../collection/contracts/_module";
 import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type AsyncReduce, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type AsyncIterableValue, type AsyncLazyable } from "../../../_shared/types";
-import { type RecordItem } from "../../../_shared/types";
 import type { TimeSpan } from "../../../utilities/_module";
 import { LazyPromise } from "../../../utilities/_module";
 /**
@@ -13,7 +13,7 @@ import { LazyPromise } from "../../../utilities/_module";
  * @group Adapters
  */
 export declare class AsyncIterableCollection<TInput> implements IAsyncCollection<TInput> {
-    private iterable;
+    private readonly iterable;
     private static DEFAULT_CHUNK_SIZE;
     private static makeCollection;
     /**
@@ -22,7 +22,7 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     constructor(iterable?: AsyncIterableValue<TInput>);
     [Symbol.asyncIterator](): AsyncIterator<TInput>;
     toIterator(): AsyncIterator<TInput, void>;
-    entries(): IAsyncCollection<RecordItem<number, TInput>>;
+    entries(): IAsyncCollection<[number, TInput]>;
     keys(): IAsyncCollection<number>;
     values(): IAsyncCollection<TInput>;
     filter<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TOutput>;
@@ -64,8 +64,8 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     split(chunkAmount: number): IAsyncCollection<IAsyncCollection<TInput>>;
     partition(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): IAsyncCollection<IAsyncCollection<TInput>>;
     sliding(chunkSize: number, step?: number): IAsyncCollection<IAsyncCollection<TInput>>;
-    groupBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<RecordItem<TOutput, IAsyncCollection<TInput>>>;
-    countBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<RecordItem<TOutput, number>>;
+    groupBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<[TOutput, IAsyncCollection<TInput>]>;
+    countBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<[TOutput, number]>;
     unique<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
     difference<TOutput = TInput>(iterable: AsyncIterableValue<TInput>, selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
     repeat(amount: number): IAsyncCollection<TInput>;
@@ -77,7 +77,7 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     insertBefore<TExtended = TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     insertAfter<TExtended = TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     crossJoin<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<CrossJoinResult<TInput, TExtended>>;
-    zip<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<RecordItem<TInput, TExtended>>;
+    zip<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<[TInput, TExtended]>;
     sort(comparator?: Comparator<TInput>): IAsyncCollection<TInput>;
     reverse(chunkSize?: number): IAsyncCollection<TInput>;
     shuffle(mathRandom?: () => number): IAsyncCollection<TInput>;
@@ -106,4 +106,6 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     searchLast(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>): LazyPromise<void>;
     toArray(): LazyPromise<TInput[]>;
+    toRecord(): LazyPromise<EnsureRecord<TInput>>;
+    toMap(): LazyPromise<EnsureMap<TInput>>;
 }

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

@@ -2,13 +2,12 @@
  * @module Collection
  */
 import { type ICollection, type Map } from "../../../../collection/contracts/_module";
-import { type RecordItem } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class CountByIterable<TInput, TOutput = TInput> implements Iterable<RecordItem<TOutput, number>> {
+export declare class CountByIterable<TInput, TOutput = TInput> implements Iterable<[TOutput, number]> {
     private collection;
     private selectFn;
     constructor(collection: ICollection<TInput>, selectFn?: Map<TInput, ICollection<TInput>, TOutput>);
-    [Symbol.iterator](): Iterator<RecordItem<TOutput, number>>;
+    [Symbol.iterator](): Iterator<[TOutput, number]>;
 }

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

@@ -1,12 +1,11 @@
 /**
  * @module Collection
  */
-import { type RecordItem } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class EntriesIterable<TInput> implements Iterable<RecordItem<number, TInput>> {
+export declare class EntriesIterable<TInput> implements Iterable<[number, TInput]> {
     private iterable;
     constructor(iterable: Iterable<TInput>);
-    [Symbol.iterator](): Iterator<RecordItem<number, TInput>>;
+    [Symbol.iterator](): Iterator<[number, TInput]>;
 }

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

@@ -2,14 +2,13 @@
  * @module Collection
  */
 import { type ICollection, type Map } from "../../../../collection/contracts/_module";
-import { type RecordItem } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class GroupByIterable<TInput, TOutput = TInput> implements Iterable<RecordItem<TOutput, ICollection<TInput>>> {
+export declare class GroupByIterable<TInput, TOutput = TInput> implements Iterable<[TOutput, ICollection<TInput>]> {
     private collection;
     private selectFn;
     private makeCollection;
     constructor(collection: ICollection<TInput>, selectFn: Map<TInput, ICollection<TInput>, TOutput> | undefined, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
-    [Symbol.iterator](): Iterator<RecordItem<TOutput, ICollection<TInput>>>;
+    [Symbol.iterator](): Iterator<[TOutput, ICollection<TInput>]>;
 }

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

@@ -5,7 +5,7 @@ import { type Predicate, type ICollection, type Map } from "../../../../collecti
 /**
  * @internal
  */
-export declare class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<TInput | TFilterOutput | TMapOutput> {
+export declare class ChangeIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<TInput | TFilterOutput | TMapOutput> {
     private collection;
     private predicateFn;
     private mapFn;

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

@@ -1,13 +1,12 @@
 /**
  * @module Collection
  */
-import { type RecordItem } from "../../../../_shared/types";
 /**
  * @internal
  */
-export declare class ZipIterable<TInput, TExtended> implements Iterable<RecordItem<TInput, TExtended>> {
+export declare class ZipIterable<TInput, TExtended> implements Iterable<[TInput, TExtended]> {
     private iterableA;
     private iterableB;
     constructor(iterableA: Iterable<TInput>, iterableB: Iterable<TExtended>);
-    [Symbol.iterator](): Iterator<RecordItem<TInput, TExtended>>;
+    [Symbol.iterator](): Iterator<[TInput, TExtended]>;
 }