/**
 * @module Collection
 */
import { type StandardSchemaV1 } from "@standard-schema/spec";
import { type Collapse, type Comparator, type PredicateInvocable, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type Reduce, type CrossJoinResult, type EnsureMap, type EnsureRecord, type SerializedCollection } from "../../../collection/contracts/_module.js";
import { type IterableValue, type Lazyable } from "../../../utilities/_module.js";
/**
 * All methods that return {@link ICollection | `ICollection`} are executed lazly, meaning the execution will occur iterating the items withthe `forEach` method or `for of` loop.
 *
 * IMPORT_PATH: `"@daiso-tech/core/collection"`
 * @group Implementations
 */
export declare class IterableCollection<TInput = unknown> implements ICollection<TInput> {
    /**
     * The `concat` static method is a convenient utility for easily concatenating multiple {@link Iterable | `Iterable`}.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * class MyIterable implements Iterable<number> {
     *   *[Symbol.iterator](): Iterator<number> {
     *     yield 1;
     *     yield 2;
     *     yield 3;
     *   }
     * }
     *
     * const collection = IterableCollection.concat([
     *   new MyIterable(),
     *   new Set([1, 2, 3]),
     *   new Map([["a", 1], ["b", 2]]),
     *   ["a", "b", "c"]
     * ]);
     * collection.toArray();
     * // [1, 2, 3, 1, 2, 3, ["a", 1], ["b", 2], "a", "b", "c"]
     * ```
     */
    static concat<TValue>(iterables: IterableValue<IterableValue<TValue>>): ICollection<TValue>;
    /**
     * The `difference` static method is used to compute the difference between two {@link Iterable | `Iterable`} instances. By default, the equality check is performed on each item.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = IterableCollection.difference(
     *   [1, 2, 2, 3, 4, 5],
     *   [2, 4, 6, 8]
     * );
     * collection.toArray();
     * // [1, 3, 5]
     * ```
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = IterableCollection.difference(
     *   [
     *     { name: "iPhone 6", brand: "Apple", type: "phone" },
     *     { name: "iPhone 5", brand: "Apple", type: "phone" },
     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
     *     { name: "Galaxy S6", brand: "Samsung", type: "phone" },
     *     { name: "Galaxy Gear", brand: "Samsung", type: "watch" },
     *   ],
     *   [
     *     { name: "Apple Watch", brand: "Apple", type: "watch" },
     *   ],
     *   (product) => product.type
     * );
     * collection.toArray();
     * // [
     * //   { name: "iPhone 6", brand: "Apple", type: "phone" },
     * //   { name: "iPhone 5", brand: "Apple", type: "phone" },
     * //   { name: "Galaxy S6", brand: "Samsung", type: "phone" },
     * // ]
     * ```
     */
    static difference<TValue, TSelect>(iterableA: IterableValue<TValue>, iterableB: IterableValue<TValue>, selectFn?: Map<TValue, ICollection<TValue>, TSelect>): ICollection<TValue>;
    /**
     * The `zip` static method merges together the values of `iterableA` with the values of the `iterableB` at their corresponding index.
     * The returned collection has size of the shortest collection.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = IterableCollection.zip(["Chair", "Desk"], [100, 200]);
     * collection.toArray();
     * // [["Chair", 100], ["Desk", 200]]
     * ```
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = IterableCollection.zip(["Chair", "Desk", "Couch"], [100, 200]);
     * collection.toArray();
     * // [["Chair", 100], ["Desk", 200]]
     * ```
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = IterableCollection.zip(["Chair", "Desk"], [100, 200, 300]);
     * collection.toArray();
     * // [["Chair", 100], ["Desk", 200]]
     * ```
     */
    static zip<TValueA, TValueB>(iterableA: IterableValue<TValueA>, iterableB: IterableValue<TValueB>): ICollection<[TValueA, TValueB]>;
    static deserialize<TInput_>(serializedValue: SerializedCollection<TInput_>): ICollection<TInput_>;
    private static DEFAULT_CHUNK_SIZE;
    private static makeCollection;
    private readonly iterable;
    /**
     * The `constructor` takes an {@link Iterable | `Iterable`}.
     *
     * Works with `Array`.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = new IterableCollection([1, 2, 3, 4]);
     * ```
     *
     * Works with `String`.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = new IterableCollection("ABCDE");
     * ```
     *
     * Works with `Set`.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = new IterableCollection(new Set([1, 2, 2 4]));
     * ```
     *
     * Works with `Map`.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * const collection = new IterableCollection(new Map([["a", 1], ["b", 2]]));
     * ```
     *
     * Works with any `Iterable`.
     * @example
     * ```ts
     * import { IterableCollection } from "@daiso-tech/core/collection";
     *
     * class MyIterable implements Iterable<number> {
     *   *[Symbol.iterator](): Iterator<number> {
     *     yield 1;
     *     yield 2;
     *     yield 3;
     *   }
     * }
     * const collection = new IterableCollection(new MyIterable());
     * ```
     */
    constructor(iterable: IterableValue<TInput>);
    serialize(): SerializedCollection<TInput>;
    [Symbol.iterator](): Iterator<TInput>;
    toIterator(): Iterator<TInput, void>;
    entries(): ICollection<[number, TInput]>;
    keys(): ICollection<number>;
    copy(): ICollection<TInput>;
    filter<TOutput extends TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): ICollection<TOutput>;
    validate<TOutput>(schema: StandardSchemaV1<TInput, TOutput>): ICollection<TOutput>;
    reject<TOutput extends TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): ICollection<Exclude<TInput, TOutput>>;
    map<TOutput>(mapFn: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TOutput>;
    reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>): TInput;
    reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>, initialValue: TInput): TInput;
    reduce<TOutput>(reduceFn: Reduce<TInput, ICollection<TInput>, TOutput>, initialValue: TOutput): TOutput;
    join(separator?: string): Extract<TInput, string>;
    collapse(): ICollection<Collapse<TInput>>;
    flatMap<TOutput>(mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>): ICollection<TOutput>;
    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<TInput | TFilterOutput | TMapOutput>;
    set(index: number, value: TInput | Map<TInput, ICollection<TInput>, TInput>): ICollection<TInput>;
    get(index: number): TInput | null;
    getOrFail(index: number): TInput;
    page(page: number, pageSize: number): ICollection<TInput>;
    sum(): Extract<TInput, number>;
    average(): Extract<TInput, number>;
    median(): Extract<TInput, number>;
    min(): Extract<TInput, number>;
    max(): Extract<TInput, number>;
    percentage(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): number;
    some<TOutput extends TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): boolean;
    every<TOutput extends TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): boolean;
    take(limit: number): ICollection<TInput>;
    takeUntil(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): ICollection<TInput>;
    takeWhile(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): ICollection<TInput>;
    skip(offset: number): ICollection<TInput>;
    skipUntil(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): ICollection<TInput>;
    skipWhile<TOutput extends TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
    when<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
    whenEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
    whenNot<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
    whenNotEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
    pipe<TOutput = TInput>(callback: Transform<ICollection<TInput>, TOutput>): TOutput;
    tap(callback: Tap<ICollection<TInput>>): ICollection<TInput>;
    chunk(chunkSize: number): ICollection<ICollection<TInput>>;
    chunkWhile(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): ICollection<ICollection<TInput>>;
    split(chunkAmount: number): ICollection<ICollection<TInput>>;
    partition(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): ICollection<ICollection<TInput>>;
    sliding(chunkSize: number, step?: number): ICollection<ICollection<TInput>>;
    groupBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<[TOutput, ICollection<TInput>]>;
    countBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<[TOutput, number]>;
    unique<TOutput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
    difference<TOutput = TInput>(iterable: IterableValue<TInput>, mapFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
    repeat(amount: number): ICollection<TInput>;
    padStart<TExtended = TInput>(maxLength: number, fillItems: IterableValue<TExtended>): ICollection<TInput | TExtended>;
    padEnd<TExtended = TInput>(maxLength: number, fillItems: IterableValue<TExtended>): ICollection<TInput | TExtended>;
    slice(start?: number, end?: number): ICollection<TInput>;
    prepend<TExtended = TInput>(iterable: IterableValue<TInput | TExtended>): ICollection<TInput | TExtended>;
    append<TExtended = TInput>(iterable: IterableValue<TInput | TExtended>): ICollection<TInput | TExtended>;
    insertBefore<TExtended = TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>, iterable: IterableValue<TInput | TExtended>): ICollection<TInput | TExtended>;
    insertAfter<TExtended = TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>, iterable: IterableValue<TInput | TExtended>): ICollection<TInput | TExtended>;
    crossJoin<TExtended>(iterable: IterableValue<TExtended>): ICollection<CrossJoinResult<TInput, TExtended>>;
    zip<TExtended>(iterable: IterableValue<TExtended>): ICollection<[TInput, TExtended]>;
    sort(comparator?: Comparator<TInput>): ICollection<TInput>;
    reverse(chunkSize?: number): ICollection<TInput>;
    shuffle(mathRandom?: () => number): ICollection<TInput>;
    private first_;
    first<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | null;
    firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
    firstOrFail<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput;
    private last_;
    last<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | null;
    lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
    lastOrFail<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput;
    private before_;
    before<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | null;
    beforeOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
    beforeOrFail<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput;
    private after_;
    after<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | null;
    afterOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
    afterOrFail<TOutput extends TInput>(predicateFn?: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput;
    sole<TOutput extends TInput>(predicateFn: PredicateInvocable<TInput, ICollection<TInput>, TOutput>): TOutput;
    nth(step: number): ICollection<TInput>;
    count(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): number;
    size(): number;
    isEmpty(): boolean;
    isNotEmpty(): boolean;
    searchFirst(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): number;
    searchLast(predicateFn: PredicateInvocable<TInput, ICollection<TInput>>): number;
    forEach(callback: ForEach<TInput, ICollection<TInput>>): void;
    toArray(): Array<TInput>;
    toRecord(): EnsureRecord<TInput>;
    toMap(): EnsureMap<TInput>;
}