import { ItIt } from '../utils/types';
type It<T> = Iterable<T>;
type Opt<T> = T | undefined;
/**
 * @short
 * Yields tuples of several iterators in parallel, as if *zipping* values together.
 *
 * @categories
 * static
 *
 * @description
 * The first yielded value of all given iterables are yielded as a single tuple from the
 * resulting iterable. The same happens for the second, third, etc. This happens as long
 * as at least one iterable has values to yield. `undefined` will be used for missing
 * values.
 *
 * To ensure all iterables are of the same size (at runtime), use {@link ZipStrict}.
 *
 * @since
 * 0.0.1
 *
 * @parameter
 * ...iterables
 * Iterable[]
 * Iterables to zip together.
 *
 * @returns
 * IterableIterator<[...T]>
 *
 * @example
 * j.Zip(
 *   [1, 2, 3, 4],
 *   [a, b, c, d],
 * )
 * // => [[1, a], [2, b], [3, c], [4, d]]
 *
 * @example
 * j.Zip(
 *   [1, 2, 3],
 *   [a, b],
 *   [A, B, C, D],
 * )
 * // => [
 *   [        1,         a,         A],
 *   [        2,         b,         B],
 *   [        3, undefined,         C],
 *   [undefined, undefined,         D],
 * ]
 */
export declare function Zip<A>(itA: It<A>): ItIt<[Opt<A>]>;
export declare function Zip<A, B>(itA: It<A>, itB: It<B>): ItIt<[Opt<A>, Opt<B>]>;
export declare function Zip<A, B, C>(itA: It<A>, itB: It<B>, itC: It<C>): ItIt<[Opt<A>, Opt<B>, Opt<C>]>;
export declare function Zip<A, B, C, D>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>): ItIt<[Opt<A>, Opt<B>, Opt<C>, Opt<D>]>;
export declare function Zip<A, B, C, D, E>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>): ItIt<[Opt<A>, Opt<B>, Opt<C>, Opt<D>, Opt<E>]>;
export declare function Zip<A, B, C, D, E, F>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>): ItIt<[Opt<A>, Opt<B>, Opt<C>, Opt<D>, Opt<E>, Opt<F>]>;
export declare function Zip<A, B, C, D, E, F, G>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>): ItIt<[Opt<A>, Opt<B>, Opt<C>, Opt<D>, Opt<E>, Opt<F>, Opt<G>]>;
export declare function Zip<A, B, C, D, E, F, G, H>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>, itH: It<H>): ItIt<[Opt<A>, Opt<B>, Opt<C>, Opt<D>, Opt<E>, Opt<F>, Opt<G>, Opt<H>]>;
export declare function Zip<A, B, C, D, E, F, G, H, I>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>, itH: It<H>, itI: It<I>): ItIt<[Opt<A>, Opt<B>, Opt<C>, Opt<D>, Opt<E>, Opt<F>, Opt<G>, Opt<H>, Opt<I>]>;
export declare function Zip<A, B, C, D, E, F, G, H, I, J>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>, itH: It<H>, itI: It<I>, itJ: It<J>): ItIt<[Opt<A>, Opt<B>, Opt<C>, Opt<D>, Opt<E>, Opt<F>, Opt<G>, Opt<H>, Opt<I>, Opt<J>]>;
export declare function Zip(...iterables: Array<It<unknown>>): ItIt<Array<unknown>>;
export declare function ZipStrict<A>(itA: It<A>): ItIt<[A]>;
export declare function ZipStrict<A, B>(itA: It<A>, itB: It<B>): ItIt<[A, B]>;
export declare function ZipStrict<A, B, C>(itA: It<A>, itB: It<B>, itC: It<C>): ItIt<[A, B, C]>;
export declare function ZipStrict<A, B, C, D>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>): ItIt<[A, B, C, D]>;
export declare function ZipStrict<A, B, C, D, E>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>): ItIt<[A, B, C, D, E]>;
export declare function ZipStrict<A, B, C, D, E, F>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>): ItIt<[A, B, C, D, E, F]>;
export declare function ZipStrict<A, B, C, D, E, F, G>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>): ItIt<[A, B, C, D, E, F, G]>;
export declare function ZipStrict<A, B, C, D, E, F, G, H>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>, itH: It<H>): ItIt<[A, B, C, D, E, F, G, H]>;
export declare function ZipStrict<A, B, C, D, E, F, G, H, I>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>, itH: It<H>, itI: It<I>): ItIt<[A, B, C, D, E, F, G, H, I]>;
export declare function ZipStrict<A, B, C, D, E, F, G, H, I, J>(itA: It<A>, itB: It<B>, itC: It<C>, itD: It<D>, itE: It<E>, itF: It<F>, itG: It<G>, itH: It<H>, itI: It<I>, itJ: It<J>): ItIt<[A, B, C, D, E, F, G, H, I, J]>;
export declare function ZipStrict(...iterables: Array<It<unknown>>): ItIt<Array<unknown>>;
export {};