import { type Flat, type Mapping, type Predicate } from './iterables.js';
/**
 * {@label Iter}
 * Chain iterable operations, each acting on the output of the previous step
 * @example When the action is per item, the result is accessible as *iterable*
 * ```
 * chain([0,1,2])
 *      .filter(i => i)
 *      .map(i => i**2)
 *      .iterable
 * // => [1,4]
 * ```
 * @example When the action returns an element (as in first, next, reduce etc) the  the result is accessible as *value*
 * ```
 * chain([0,1,2]).filter(i => i).first().value
 * // => 1
 * ```
 * @example Iterable is always accessible, as a single element iterable
 * ```
 * chain([0,1,2]).filter(i => i).first().iterable
 * // => [1]
 * ```
 * @example <b>Note</b> if the action returned undefined, iterable will be empty
 * ```
 * chain([]).first().iterable // => []
 * chain([]).first().value // => undefined
 * ```
 * @param value - initial iterable
 * @returns Chainable action on iterable
 */
export declare function chain<T>(value: Iterable<T>): IterableChain<T>;
/**
 * {@label Iter}
 * Chain iterable operations, each acting on the output of the previous step
 * @example When the action is per item, the result is accessible as *iterable*
 * ```
 * chain([0,1,2])
 *      .filter(i => i)
 *      .map(i => i**2)
 *      .iterable
 * // => [1,4]
 * ```
 * @example When the action returns an element (as in first, next, reduce etc) the  the result is accessible as *value*
 * ```
 * chain("hello").map(i => i.split("")).first().value
 * // => "h"
 * ```
 * @example Iterable is always accessible, as a single element iterable
 * ```
 * chain([0,1,2]).filter(i => i).first().iterable
 * // => [1]
 * ```
 * @example <b>Note</b> if the action returned undefined, iterable will be empty
 * ```
 * chain([]).first().iterable // => []
 * chain([]).first().value // => undefined
 * ```
 * @param value - initial value
 * @returns Chainable action on iterable
 */
export declare function chain<T, V extends NotIterable<T>>(value: V): ValueChain<V>;
export type IterableChain<T> = Chain<T> & {
    value: Iterable<T>;
};
export type ValueChain<T> = Chain<T> & {
    value: T;
};
export type NotIterable<T> = T extends Iterable<unknown> ? never : T;
export type Iter<T> = T extends Iterable<infer E> ? Iterable<E> : Iterable<T>;
export type Chain<T> = {
    last: () => ValueChain<T>;
    first: () => ValueChain<T>;
    isEmpty: () => ValueChain<boolean>;
    size: () => ValueChain<number>;
    at: (index: number) => ValueChain<T>;
    next: () => ValueChain<T>;
    prev: () => ValueChain<T>;
    unique: () => IterableChain<T>;
    map: <S>(m: Mapping<T, S>) => IterableChain<S>;
    flatMap: <S>(m: Mapping<T, S>) => IterableChain<Flat<S>>;
    filter: (p: Predicate<T>) => IterableChain<T>;
    concat: (...iterables: Iterable<T>[]) => IterableChain<T>;
    forEach: (fn: Mapping<T, unknown>) => IterableChain<T>;
    find: (p: Predicate<T>) => ValueChain<T>;
    includes: (element: T) => ValueChain<boolean>;
    some: (p: Predicate<T>) => ValueChain<boolean>;
    sort: (p: Predicate<T, number>) => IterableChain<T>;
    every: (p: Predicate<T>) => ValueChain<boolean>;
    flat: () => IterableChain<Flat<T>>;
    join: () => ValueChain<string>;
    skip: (count: number) => IterableChain<T>;
    reduce: <A>(reducer: (acc: A, item: T) => A, initial: A) => ValueChain<A>;
    iterable: Iterable<T>;
    get array(): T[];
};
//# sourceMappingURL=chain.d.ts.map