/**
 * This file contains the Iterable algebraic data type. Iterable is a lazy,
 * synchronous, and native structure defined by ecmascript. Generally, one
 * interacts with the Iterator structure directly, but the Iterable type, being
 * more generic, is a better target for functional. Any data structure that
 * implements Iterable (ie. Array, Map, Set, etc) can use the iterable methods
 * contained here if neeeded.
 *
 * Something to keep in mind here is that Iterables can have nasty edge cases
 * that don't exist for non-lazy data structures. Specifically, an iterable can
 * generate a theoretically infinite number of values, making the draining of an
 * iterable potentially impossible (trying it will cause the runtime to hang).
 * Additionally, many iterables are constructed using generators, which cannot
 * be easily cloned. This makes the process of chaining iterables a resource
 * intensive operation. As always, use these combinators with care.
 *
 * @module Iterable
 * @since 2.0.0
 */
import "./_dnt.polyfills.js";
import type { Kind, Out } from "./kind.js";
import type { Applicable } from "./applicable.js";
import type { Combinable } from "./combinable.js";
import type { Either } from "./either.js";
import type { Filterable } from "./filterable.js";
import type { Flatmappable } from "./flatmappable.js";
import type { Foldable } from "./foldable.js";
import type { Initializable } from "./initializable.js";
import type { Mappable } from "./mappable.js";
import type { Option } from "./option.js";
import type { Pair } from "./pair.js";
import type { Predicate } from "./predicate.js";
import type { Refinement } from "./refinement.js";
import type { Showable } from "./showable.js";
import type { Wrappable } from "./wrappable.js";
/**
 * @since 2.0.0
 */
export interface KindIterable extends Kind {
    readonly kind: Iterable<Out<this, 0>>;
}
/**
 * @since 2.0.0
 */
export declare function iterable<A>(fa: () => Iterator<A>): Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function clone<A>(ta: Iterable<A>): Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function range(count?: number, start?: number, step?: number): Iterable<number>;
/**
 * @since 2.0.0
 */
export declare function wrap<A>(...a: A[]): Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function apply<A>(ua: Iterable<A>): <I>(ufai: Iterable<(a: A) => I>) => Iterable<I>;
/**
 * @since 2.0.0
 */
export declare function map<A, I>(fai: (a: A) => I): (ta: Iterable<A>) => Iterable<I>;
/**
 * @since 2.0.0
 */
export declare function flatmap<A, I>(fati: (a: A) => Iterable<I>): (ta: Iterable<A>) => Iterable<I>;
/**
 * @since 2.0.0
 */
export declare function forEach<A>(fa: (a: A) => void): (ta: Iterable<A>) => void;
/**
 * @since 2.0.0
 */
export declare function fold<A, O>(foldr: (accumulator: O, value: A) => O, initial: O): (ua: Iterable<A>) => O;
/**
 * @since 2.0.0
 */
export declare function scan<A, O>(foldr: (accumulator: O, value: A, index: number) => O, initial: O): (ta: Iterable<A>) => Iterable<O>;
/**
 * @since 2.0.0
 */
export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (ua: Iterable<A>) => Iterable<B>;
export declare function filter<A>(predicate: Predicate<A>): (ua: Iterable<A>) => Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function filterMap<A, I>(predicate: (a: A) => Option<I>): (ua: Iterable<A>) => Iterable<I>;
/**
 * @since 2.0.0
 */
export declare function partition<A, B extends A>(refinement: (a: A) => a is B): (ua: Iterable<A>) => Pair<Iterable<A>, Iterable<B>>;
export declare function partition<A>(predicate: (a: A) => boolean): (ua: Iterable<A>) => Pair<Iterable<A>, Iterable<A>>;
/**
 * @since 2.0.0
 */
export declare function partitionMap<A, I, J>(predicate: (a: A) => Either<J, I>): (ua: Iterable<A>) => Pair<Iterable<I>, Iterable<J>>;
/**
 * Collect all values of an iterable into an array. WARNING: If the iterable is
 * infinite then this will cause the program to hang indefinitely.
 *
 * @since 2.0.0
 */
export declare function collect<A>(ta: Iterable<A>): ReadonlyArray<A>;
/**
 * @since 2.0.0
 */
export declare function take(n: number): <A>(ta: Iterable<A>) => Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function takeUntil<A>(predicate: Predicate<A>): (ta: Iterable<A>) => Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function takeWhile<A>(predicate: Predicate<A>): (ta: Iterable<A>) => Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function repeat(n: number): <A>(ta: Iterable<A>) => Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function init<A>(): Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function combine<A>(second: Iterable<A>): (first: Iterable<A>) => Iterable<A>;
/**
 * @since 2.0.0
 */
export declare function getCombinable<A>(): Combinable<Iterable<A>>;
/**
 * @since 2.0.0
 */
export declare function getInitializable<A>(): Initializable<Iterable<A>>;
/**
 * @since 2.0.0
 */
export declare function getShowable<A>(S: Showable<A>): Showable<Iterable<A>>;
/**
 * @since 2.0.0
 */
export declare const ApplicableIterable: Applicable<KindIterable>;
/**
 * @since 2.0.0
 */
export declare const FlatmappableIterable: Flatmappable<KindIterable>;
/**
 * @since 2.0.0
 */
export declare const FilterableIterable: Filterable<KindIterable>;
/**
 * @since 2.0.0
 */
export declare const FoldableIterable: Foldable<KindIterable>;
/**
 * @since 2.0.0
 */
export declare const MappableIterable: Mappable<KindIterable>;
/**
 * @since 2.0.0
 */
export declare const WrappableIterable: Wrappable<KindIterable>;
/**
 * @since 2.0.0
 */
export declare const tap: <A>(fn: (value: A) => void) => <B = never, C = never, D = unknown, E = unknown>(ua: Iterable<A>) => Iterable<A>;
/**
 * @since 2.0.0
 */
export declare const bind: <N extends string, A, I, J = never, K = never, L = unknown, M = unknown>(name: Exclude<N, keyof A>, faui: (a: A) => Iterable<I>) => <B = never, C = never, D extends L = L>(ua: Iterable<A>) => Iterable<{ readonly [K_1 in N | keyof A]: K_1 extends keyof A ? A[K_1] : I; }>;
/**
 * @since 2.0.0
 */
export declare const bindTo: <N extends string>(name: N) => <A, B = never, C = never, D = unknown, E = unknown>(ua: Iterable<A>) => Iterable<{ readonly [K in N]: A; }>;