iterflow 0.2.2

package/dist/fn/index.d.ts

@@ -0,0 +1,1187 @@
+/**
+ * Type representing a function that transforms an iterable.
+ * Used for composing transformations in a type-safe way.
+ *
+ * @template T The input element type
+ * @template U The output element type
+ */
+type IterableTransformer<T, U> = (iterable: Iterable<T>) => IterableIterator<U>;
+/**
+ * Type representing a terminal operation that produces a final result.
+ *
+ * @template T The input element type
+ * @template R The result type
+ */
+type TerminalOperation<T, R> = (iterable: Iterable<T>) => R;
+/**
+ * Composes functions from left to right (Unix pipe style).
+ * Each function takes an iterable and returns an iterable, except the last
+ * function which can return any type.
+ *
+ * The pipe flows data from left to right:
+ * pipe(f, g, h)(x) === h(g(f(x)))
+ *
+ * @param fns - Functions to compose from left to right
+ * @returns A function that applies all transformations in sequence
+ * @example
+ * ```typescript
+ * import { pipe, map, filter, toArray } from 'iterflow/fn';
+ *
+ * const process = pipe(
+ *   map((x: number) => x * 2),
+ *   filter((x: number) => x > 5),
+ *   toArray
+ * );
+ *
+ * process([1, 2, 3, 4, 5]); // [6, 8, 10]
+ * ```
+ */
+declare function pipe<A, B>(fn1: (input: A) => B): (input: A) => B;
+declare function pipe<A, B, C>(fn1: (input: A) => B, fn2: (input: B) => C): (input: A) => C;
+declare function pipe<A, B, C, D>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D): (input: A) => D;
+declare function pipe<A, B, C, D, E>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E): (input: A) => E;
+declare function pipe<A, B, C, D, E, F>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F): (input: A) => F;
+declare function pipe<A, B, C, D, E, F, G>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F, fn6: (input: F) => G): (input: A) => G;
+declare function pipe<A, B, C, D, E, F, G, H>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F, fn6: (input: F) => G, fn7: (input: G) => H): (input: A) => H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F, fn6: (input: F) => G, fn7: (input: G) => H, fn8: (input: H) => I): (input: A) => I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F, fn6: (input: F) => G, fn7: (input: G) => H, fn8: (input: H) => I, fn9: (input: I) => J): (input: A) => J;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F, fn6: (input: F) => G, fn7: (input: G) => H, fn8: (input: H) => I, fn9: (input: I) => J, fn10: (input: J) => K): (input: A) => K;
+/**
+ * Composes functions from right to left (traditional mathematical composition).
+ * Each function takes an iterable and returns an iterable, except the last
+ * function which can return any type.
+ *
+ * The composition flows from right to left:
+ * compose(h, g, f)(x) === h(g(f(x)))
+ *
+ * @param fns - Functions to compose from right to left
+ * @returns A function that applies all transformations in sequence
+ * @example
+ * ```typescript
+ * import { compose, map, filter, toArray } from 'iterflow/fn';
+ *
+ * const process = compose(
+ *   toArray,
+ *   filter((x: number) => x > 5),
+ *   map((x: number) => x * 2)
+ * );
+ *
+ * process([1, 2, 3, 4, 5]); // [6, 8, 10]
+ * ```
+ */
+declare function compose<A, B>(fn1: (input: A) => B): (input: A) => B;
+declare function compose<A, B, C>(fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => C;
+declare function compose<A, B, C, D>(fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => D;
+declare function compose<A, B, C, D, E>(fn4: (input: D) => E, fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => E;
+declare function compose<A, B, C, D, E, F>(fn5: (input: E) => F, fn4: (input: D) => E, fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => F;
+declare function compose<A, B, C, D, E, F, G>(fn6: (input: F) => G, fn5: (input: E) => F, fn4: (input: D) => E, fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => G;
+declare function compose<A, B, C, D, E, F, G, H>(fn7: (input: G) => H, fn6: (input: F) => G, fn5: (input: E) => F, fn4: (input: D) => E, fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => H;
+declare function compose<A, B, C, D, E, F, G, H, I>(fn8: (input: H) => I, fn7: (input: G) => H, fn6: (input: F) => G, fn5: (input: E) => F, fn4: (input: D) => E, fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => I;
+declare function compose<A, B, C, D, E, F, G, H, I, J>(fn9: (input: I) => J, fn8: (input: H) => I, fn7: (input: G) => H, fn6: (input: F) => G, fn5: (input: E) => F, fn4: (input: D) => E, fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => J;
+declare function compose<A, B, C, D, E, F, G, H, I, J, K>(fn10: (input: J) => K, fn9: (input: I) => J, fn8: (input: H) => I, fn7: (input: G) => H, fn6: (input: F) => G, fn5: (input: E) => F, fn4: (input: D) => E, fn3: (input: C) => D, fn2: (input: B) => C, fn1: (input: A) => B): (input: A) => K;
+/**
+ * Helper function to create custom iterable operations that follow the
+ * iterflow functional API pattern.
+ *
+ * Creates a curried function that takes configuration parameters and returns
+ * a function that transforms an iterable. The transformation uses a generator
+ * function for lazy evaluation.
+ *
+ * @template TConfig The type of configuration parameters
+ * @template TInput The type of input elements
+ * @template TOutput The type of output elements
+ * @param name - Name of the operation (for debugging)
+ * @param generator - Generator function that performs the transformation
+ * @returns A curried function following the iterflow pattern
+ * @example
+ * ```typescript
+ * import { createOperation } from 'iterflow/fn';
+ *
+ * // Create a custom operation that multiplies by a factor
+ * const multiplyBy = createOperation(
+ *   'multiplyBy',
+ *   function* (iterable: Iterable<number>, factor: number) {
+ *     for (const value of iterable) {
+ *       yield value * factor;
+ *     }
+ *   }
+ * );
+ *
+ * // Use it in a pipeline
+ * const double = multiplyBy(2);
+ * Array.from(double([1, 2, 3])); // [2, 4, 6]
+ *
+ * // Create a custom filtering operation
+ * const between = createOperation(
+ *   'between',
+ *   function* (iterable: Iterable<number>, min: number, max: number) {
+ *     for (const value of iterable) {
+ *       if (value >= min && value <= max) {
+ *         yield value;
+ *       }
+ *     }
+ *   }
+ * );
+ *
+ * const between5And10 = between(5, 10);
+ * Array.from(between5And10([1, 6, 3, 8, 12, 4])); // [6, 8]
+ * ```
+ */
+declare function createOperation<TInput, TOutput>(name: string, generator: (iterable: Iterable<TInput>) => Generator<TOutput>): (iterable: Iterable<TInput>) => IterableIterator<TOutput>;
+declare function createOperation<TConfig, TInput, TOutput>(name: string, generator: (iterable: Iterable<TInput>, config: TConfig) => Generator<TOutput>): (config: TConfig) => (iterable: Iterable<TInput>) => IterableIterator<TOutput>;
+declare function createOperation<TConfig1, TConfig2, TInput, TOutput>(name: string, generator: (iterable: Iterable<TInput>, config1: TConfig1, config2: TConfig2) => Generator<TOutput>): (config1: TConfig1, config2: TConfig2) => (iterable: Iterable<TInput>) => IterableIterator<TOutput>;
+declare function createOperation<TConfig1, TConfig2, TConfig3, TInput, TOutput>(name: string, generator: (iterable: Iterable<TInput>, config1: TConfig1, config2: TConfig2, config3: TConfig3) => Generator<TOutput>): (config1: TConfig1, config2: TConfig2, config3: TConfig3) => (iterable: Iterable<TInput>) => IterableIterator<TOutput>;
+declare function createOperation<TInput, TOutput>(name: string, generator: (iterable: Iterable<TInput>, ...configs: any[]) => Generator<TOutput>): any;
+/**
+ * Type representing a transducer - a composable algorithmic transformation.
+ * Transducers are independent of the context of their input and output sources.
+ *
+ * @template TInput The input element type
+ * @template TOutput The output element type
+ */
+type Transducer<TInput, TOutput> = <TResult>(reducer: Reducer<TOutput, TResult>) => Reducer<TInput, TResult>;
+/**
+ * Type representing a reducer function that combines values into an accumulator.
+ *
+ * @template T The type of values being reduced
+ * @template TResult The type of the accumulator
+ */
+type Reducer<T, TResult> = (accumulator: TResult, value: T) => TResult;
+/**
+ * Creates a transducer from a map function.
+ * Transducers enable efficient composition of transformations without
+ * creating intermediate iterables.
+ *
+ * @template TInput The input element type
+ * @template TOutput The output element type
+ * @param fn - Function to transform each element
+ * @returns A transducer that applies the transformation
+ * @example
+ * ```typescript
+ * import { mapTransducer, transduce } from 'iterflow/fn';
+ *
+ * const xf = mapTransducer((x: number) => x * 2);
+ * const result = transduce(
+ *   xf,
+ *   (acc: number[], x: number) => [...acc, x],
+ *   [],
+ *   [1, 2, 3]
+ * );
+ * // [2, 4, 6]
+ * ```
+ */
+declare function mapTransducer<TInput, TOutput>(fn: (value: TInput) => TOutput): Transducer<TInput, TOutput>;
+/**
+ * Creates a transducer from a filter predicate.
+ * Transducers enable efficient composition of transformations without
+ * creating intermediate iterables.
+ *
+ * @template T The element type
+ * @param predicate - Function to test each element
+ * @returns A transducer that filters elements
+ * @example
+ * ```typescript
+ * import { filterTransducer, transduce } from 'iterflow/fn';
+ *
+ * const xf = filterTransducer((x: number) => x % 2 === 0);
+ * const result = transduce(
+ *   xf,
+ *   (acc: number[], x: number) => [...acc, x],
+ *   [],
+ *   [1, 2, 3, 4, 5]
+ * );
+ * // [2, 4]
+ * ```
+ */
+declare function filterTransducer<T>(predicate: (value: T) => boolean): Transducer<T, T>;
+/**
+ * Creates a transducer from a take operation.
+ * Transducers enable efficient composition of transformations without
+ * creating intermediate iterables.
+ *
+ * Note: This transducer requires special handling in transduce() to support
+ * early termination. Use the '@@transducer/reduced' protocol.
+ *
+ * @template T The element type
+ * @param n - Number of elements to take
+ * @returns A transducer that takes the first n elements
+ * @example
+ * ```typescript
+ * import { takeTransducer, transduce } from 'iterflow/fn';
+ *
+ * const xf = takeTransducer(3);
+ * const result = transduce(
+ *   xf,
+ *   (acc: number[], x: number) => [...acc, x],
+ *   [],
+ *   [1, 2, 3, 4, 5]
+ * );
+ * // [1, 2, 3]
+ * ```
+ */
+declare function takeTransducer<T>(n: number): Transducer<T, T>;
+/**
+ * Composes multiple transducers into a single transducer.
+ * Composition happens from right to left (like compose).
+ *
+ * @param transducers - Transducers to compose
+ * @returns A composed transducer
+ * @example
+ * ```typescript
+ * import { composeTransducers, mapTransducer, filterTransducer, transduce } from 'iterflow/fn';
+ *
+ * const xf = composeTransducers(
+ *   filterTransducer((x: number) => x > 2),
+ *   mapTransducer((x: number) => x * 2)
+ * );
+ *
+ * const result = transduce(
+ *   xf,
+ *   (acc: number[], x: number) => [...acc, x],
+ *   [],
+ *   [1, 2, 3, 4, 5]
+ * );
+ * // [6, 8, 10]
+ * ```
+ */
+declare function composeTransducers<A, B>(xf1: Transducer<A, B>): Transducer<A, B>;
+declare function composeTransducers<A, B, C>(xf2: Transducer<B, C>, xf1: Transducer<A, B>): Transducer<A, C>;
+declare function composeTransducers<A, B, C, D>(xf3: Transducer<C, D>, xf2: Transducer<B, C>, xf1: Transducer<A, B>): Transducer<A, D>;
+declare function composeTransducers<A, B, C, D, E>(xf4: Transducer<D, E>, xf3: Transducer<C, D>, xf2: Transducer<B, C>, xf1: Transducer<A, B>): Transducer<A, E>;
+/**
+ * Symbol used to mark a reduced value (for early termination in transducers).
+ */
+declare const REDUCED: unique symbol;
+/**
+ * Interface for a reduced value (supports early termination).
+ */
+interface Reduced<T> {
+    [REDUCED]: true;
+    value: T;
+}
+/**
+ * Marks a value as reduced (for early termination in transducers).
+ *
+ * @template T The value type
+ * @param value - The value to mark as reduced
+ * @returns A reduced value
+ */
+declare function reduced<T>(value: T): Reduced<T>;
+/**
+ * Checks if a value is reduced.
+ *
+ * @template T The value type
+ * @param value - The value to check
+ * @returns true if the value is reduced
+ */
+declare function isReduced<T>(value: any): value is Reduced<T>;
+/**
+ * Applies a transducer to an iterable and reduces it to a final value.
+ * This is the main entry point for using transducers.
+ *
+ * @template TInput The input element type
+ * @template TOutput The output element type (after transducer transformation)
+ * @template TResult The final result type
+ * @param transducer - The transducer to apply
+ * @param reducer - The reducer function to combine values
+ * @param initial - The initial accumulator value
+ * @param iterable - The iterable to process
+ * @returns The final reduced value
+ * @example
+ * ```typescript
+ * import { transduce, composeTransducers, mapTransducer, filterTransducer } from 'iterflow/fn';
+ *
+ * const xf = composeTransducers(
+ *   filterTransducer((x: number) => x % 2 === 0),
+ *   mapTransducer((x: number) => x * 2)
+ * );
+ *
+ * const sum = transduce(
+ *   xf,
+ *   (acc: number, x: number) => acc + x,
+ *   0,
+ *   [1, 2, 3, 4, 5]
+ * );
+ * // 12 (2*2 + 4*2)
+ *
+ * const toArray = transduce(
+ *   xf,
+ *   (acc: number[], x: number) => [...acc, x],
+ *   [],
+ *   [1, 2, 3, 4, 5]
+ * );
+ * // [4, 8]
+ * ```
+ */
+declare function transduce<TInput, TOutput, TResult>(transducer: Transducer<TInput, TOutput>, reducer: Reducer<TOutput, TResult>, initial: TResult, iterable: Iterable<TInput>): TResult;
+/**
+ * Converts a transducer into an iterable transformer.
+ * This allows transducers to be used in pipe() and compose() with other
+ * iterable operations.
+ *
+ * @template TInput The input element type
+ * @template TOutput The output element type
+ * @param transducer - The transducer to convert
+ * @returns An iterable transformer function
+ * @example
+ * ```typescript
+ * import { pipe, transducerToIterator, mapTransducer, filterTransducer, toArray } from 'iterflow/fn';
+ *
+ * const xf = composeTransducers(
+ *   filterTransducer((x: number) => x % 2 === 0),
+ *   mapTransducer((x: number) => x * 2)
+ * );
+ *
+ * const process = pipe(
+ *   transducerToIterator(xf),
+ *   toArray
+ * );
+ *
+ * process([1, 2, 3, 4, 5]); // [4, 8]
+ * ```
+ */
+declare function transducerToIterator<TInput, TOutput>(transducer: Transducer<TInput, TOutput>): (iterable: Iterable<TInput>) => IterableIterator<TOutput>;
+
+/**
+ * Calculates the sum of all numeric elements in an iterable.
+ *
+ * @param iterable - The iterable of numbers to sum
+ * @returns The sum of all elements
+ * @example
+ * ```typescript
+ * sum([1, 2, 3, 4, 5]); // 15
+ * ```
+ */
+declare function sum(iterable: Iterable<number>): number;
+/**
+ * Calculates the arithmetic mean (average) of all numeric elements.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The mean value, or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * mean([1, 2, 3, 4, 5]); // 3
+ * mean([]); // undefined
+ * ```
+ */
+declare function mean(iterable: Iterable<number>): number | undefined;
+/**
+ * Finds the minimum value among all numeric elements.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The minimum value, or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * min([3, 1, 4, 1, 5]); // 1
+ * min([]); // undefined
+ * ```
+ */
+declare function min(iterable: Iterable<number>): number | undefined;
+/**
+ * Finds the maximum value among all numeric elements.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The maximum value, or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * max([3, 1, 4, 1, 5]); // 5
+ * max([]); // undefined
+ * ```
+ */
+declare function max(iterable: Iterable<number>): number | undefined;
+/**
+ * Counts the total number of elements in an iterable.
+ *
+ * @template T The type of elements in the iterable
+ * @param iterable - The iterable to count
+ * @returns The total count of elements
+ * @example
+ * ```typescript
+ * count([1, 2, 3, 4, 5]); // 5
+ * count([]); // 0
+ * ```
+ */
+declare function count<T>(iterable: Iterable<T>): number;
+/**
+ * Calculates the median value of all numeric elements.
+ * The median is the middle value when elements are sorted.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The median value, or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * median([1, 2, 3, 4, 5]); // 3
+ * median([1, 2, 3, 4]); // 2.5
+ * median([]); // undefined
+ * ```
+ */
+declare function median(iterable: Iterable<number>): number | undefined;
+/**
+ * Calculates the variance of all numeric elements.
+ * Variance measures how far each number in the set is from the mean.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The variance, or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * variance([1, 2, 3, 4, 5]); // 2
+ * variance([]); // undefined
+ * ```
+ */
+declare function variance(iterable: Iterable<number>): number | undefined;
+/**
+ * Calculates the standard deviation of all numeric elements.
+ * Standard deviation is the square root of variance and measures dispersion.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The standard deviation, or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * stdDev([2, 4, 4, 4, 5, 5, 7, 9]); // ~2
+ * stdDev([]); // undefined
+ * ```
+ */
+declare function stdDev(iterable: Iterable<number>): number | undefined;
+/**
+ * Calculates the specified percentile of all numeric elements.
+ * Uses linear interpolation between closest ranks.
+ *
+ * @param iterable - The iterable of numbers
+ * @param p - The percentile to calculate (0-100)
+ * @returns The percentile value, or undefined if the iterable is empty
+ * @throws {Error} If p is not between 0 and 100
+ * @example
+ * ```typescript
+ * percentile([1, 2, 3, 4, 5], 50); // 3 (median)
+ * percentile([1, 2, 3, 4, 5], 75); // 4
+ * percentile([], 50); // undefined
+ * ```
+ */
+declare function percentile(iterable: Iterable<number>, p: number): number | undefined;
+/**
+ * Finds the most frequent value(s) in the dataset.
+ * Returns an array of all values that appear most frequently.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns An array of the most frequent value(s), or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * mode([1, 2, 2, 3, 3, 3]); // [3]
+ * mode([1, 1, 2, 2, 3]); // [1, 2] (bimodal)
+ * mode([]); // undefined
+ * ```
+ */
+declare function mode(iterable: Iterable<number>): number[] | undefined;
+/**
+ * Calculates the quartiles (Q1, Q2, Q3) of all numeric elements.
+ * Q1 is the 25th percentile, Q2 is the median (50th percentile), Q3 is the 75th percentile.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns An object with Q1, Q2, and Q3 values, or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * quartiles([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+ * // { Q1: 3, Q2: 5, Q3: 7 }
+ * quartiles([]); // undefined
+ * ```
+ */
+declare function quartiles(iterable: Iterable<number>): {
+    Q1: number;
+    Q2: number;
+    Q3: number;
+} | undefined;
+/**
+ * Calculates the span (range from minimum to maximum value) of all numeric elements.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The span (max - min), or undefined if the iterable is empty
+ * @example
+ * ```typescript
+ * span([1, 2, 3, 4, 5]); // 4
+ * span([10]); // 0
+ * span([]); // undefined
+ * ```
+ */
+declare function span(iterable: Iterable<number>): number | undefined;
+/**
+ * Calculates the product of all numeric elements.
+ *
+ * @param iterable - The iterable of numbers
+ * @returns The product of all elements, or 1 if the iterable is empty
+ * @example
+ * ```typescript
+ * product([1, 2, 3, 4, 5]); // 120
+ * product([2, 3, 4]); // 24
+ * product([]); // 1
+ * ```
+ */
+declare function product(iterable: Iterable<number>): number;
+/**
+ * Calculates the covariance between two numeric sequences.
+ * Covariance measures the joint variability of two random variables.
+ *
+ * @param iter1 - The first iterable of numbers
+ * @param iter2 - The second iterable of numbers
+ * @returns The covariance, or undefined if either sequence is empty or sequences have different lengths
+ * @example
+ * ```typescript
+ * covariance([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]); // 4
+ * covariance([], [1, 2, 3]); // undefined
+ * ```
+ */
+declare function covariance(iter1: Iterable<number>, iter2: Iterable<number>): number | undefined;
+/**
+ * Calculates the Pearson correlation coefficient between two numeric sequences.
+ * Correlation measures the strength and direction of the linear relationship between two variables.
+ * Values range from -1 (perfect negative correlation) to 1 (perfect positive correlation).
+ *
+ * @param iter1 - The first iterable of numbers
+ * @param iter2 - The second iterable of numbers
+ * @returns The correlation coefficient, or undefined if either sequence is empty or sequences have different lengths
+ * @example
+ * ```typescript
+ * correlation([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]); // 1 (perfect positive correlation)
+ * correlation([1, 2, 3], [3, 2, 1]); // -1 (perfect negative correlation)
+ * correlation([], [1, 2, 3]); // undefined
+ * ```
+ */
+declare function correlation(iter1: Iterable<number>, iter2: Iterable<number>): number | undefined;
+/**
+ * Creates a curried function that transforms each element using the provided function.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of input elements
+ * @template U The type of output elements
+ * @param fn - Function to transform each element
+ * @returns A function that transforms an iterable
+ * @example
+ * ```typescript
+ * const double = map((x: number) => x * 2);
+ * Array.from(double([1, 2, 3])); // [2, 4, 6]
+ * ```
+ */
+declare function map<T, U>(fn: (value: T) => U): (iterable: Iterable<T>) => IterableIterator<U>;
+/**
+ * Creates a curried function that filters elements based on a predicate.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that filters an iterable
+ * @example
+ * ```typescript
+ * const evens = filter((x: number) => x % 2 === 0);
+ * Array.from(evens([1, 2, 3, 4])); // [2, 4]
+ * ```
+ */
+declare function filter<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that takes only the first `limit` elements.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param limit - Maximum number of elements to take
+ * @returns A function that takes elements from an iterable
+ * @example
+ * ```typescript
+ * const takeThree = take(3);
+ * Array.from(takeThree([1, 2, 3, 4, 5])); // [1, 2, 3]
+ * ```
+ */
+declare function take<T>(limit: number): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that skips the first `count` elements.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param count - Number of elements to skip
+ * @returns A function that drops elements from an iterable
+ * @example
+ * ```typescript
+ * const dropTwo = drop(2);
+ * Array.from(dropTwo([1, 2, 3, 4, 5])); // [3, 4, 5]
+ * ```
+ */
+declare function drop<T>(count: number): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that maps each element to an iterable and flattens the results.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of input elements
+ * @template U The type of output elements
+ * @param fn - Function that maps each element to an iterable
+ * @returns A function that flat maps an iterable
+ * @example
+ * ```typescript
+ * const duplicateEach = flatMap((x: number) => [x, x * 2]);
+ * Array.from(duplicateEach([1, 2, 3])); // [1, 2, 2, 4, 3, 6]
+ * ```
+ */
+declare function flatMap<T, U>(fn: (value: T) => Iterable<U>): (iterable: Iterable<T>) => IterableIterator<U>;
+/**
+ * Creates a curried function that concatenates multiple iterables sequentially.
+ * Returns a function that takes any number of iterables and yields all elements in order.
+ *
+ * @template T The type of elements
+ * @returns A function that concatenates iterables
+ * @example
+ * ```typescript
+ * const concatAll = concat<number>();
+ * Array.from(concatAll([1, 2], [3, 4], [5, 6]));
+ * // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+declare function concat<T>(): (...iterables: Iterable<T>[]) => IterableIterator<T>;
+/**
+ * Creates a curried function that inserts a separator element between each item.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param separator - The element to insert between items
+ * @returns A function that intersperses an iterable
+ * @example
+ * ```typescript
+ * const addCommas = intersperse(',');
+ * Array.from(addCommas(['a', 'b', 'c']));
+ * // ['a', ',', 'b', ',', 'c']
+ * ```
+ */
+declare function intersperse<T>(separator: T): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that emits all intermediate accumulator values.
+ * Like reduce but yields each intermediate result.
+ *
+ * @template T The type of elements in the iterable
+ * @template U The type of the accumulated value
+ * @param fn - Function to combine the accumulator with each element
+ * @param initial - The initial value for the accumulator
+ * @returns A function that scans an iterable
+ * @example
+ * ```typescript
+ * const runningSum = scan((acc: number, x: number) => acc + x, 0);
+ * Array.from(runningSum([1, 2, 3, 4]));
+ * // [0, 1, 3, 6, 10]
+ * ```
+ */
+declare function scan<T, U>(fn: (accumulator: U, value: T) => U, initial: U): (iterable: Iterable<T>) => IterableIterator<U>;
+/**
+ * Creates a curried function that adds index as tuple with each element [index, value].
+ * Returns a function that creates tuples pairing each element with its zero-based index.
+ *
+ * @template T The type of elements
+ * @returns A function that enumerates an iterable
+ * @example
+ * ```typescript
+ * const enumerateItems = enumerate<string>();
+ * Array.from(enumerateItems(['a', 'b', 'c']));
+ * // [[0, 'a'], [1, 'b'], [2, 'c']]
+ * ```
+ */
+declare function enumerate<T>(): (iterable: Iterable<T>) => IterableIterator<[number, T]>;
+/**
+ * Creates a curried function that reverses the iterator order.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ * Warning: This operation buffers all elements in memory and may cause
+ * performance issues with large iterables.
+ *
+ * @template T The type of elements
+ * @returns A function that reverses an iterable
+ * @example
+ * ```typescript
+ * const reverseItems = reverse<number>();
+ * Array.from(reverseItems([1, 2, 3, 4, 5]));
+ * // [5, 4, 3, 2, 1]
+ * ```
+ */
+declare function reverse<T>(): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Sorts elements using default comparison.
+ * Numbers are sorted numerically, strings lexicographically.
+ * Note: This operation requires buffering all elements in memory.
+ *
+ * @param iterable - The iterable to sort
+ * @returns An iterable iterator with elements sorted
+ * @example
+ * ```typescript
+ * Array.from(sort([3, 1, 4, 1, 5]));
+ * // [1, 1, 3, 4, 5]
+ * Array.from(sort(['c', 'a', 'b']));
+ * // ['a', 'b', 'c']
+ * ```
+ */
+declare function sort(iterable: Iterable<number | string>): IterableIterator<number | string>;
+/**
+ * Creates a curried function that sorts elements using a custom comparison function.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ * Note: This operation requires buffering all elements in memory.
+ *
+ * @template T The type of elements
+ * @param compareFn - Function that compares two elements
+ * @returns A function that sorts an iterable
+ * @example
+ * ```typescript
+ * const sortAsc = sortBy((a: number, b: number) => a - b);
+ * Array.from(sortAsc([3, 1, 4, 1, 5]));
+ * // [1, 1, 3, 4, 5]
+ * const sortDesc = sortBy((a: number, b: number) => b - a);
+ * Array.from(sortDesc([3, 1, 4, 1, 5]));
+ * // [5, 4, 3, 1, 1]
+ * ```
+ */
+declare function sortBy<T>(compareFn: (a: T, b: T) => number): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that creates a sliding window of the specified size.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param size - The size of each window (must be at least 1)
+ * @returns A function that creates windows from an iterable
+ * @throws {Error} If size is less than 1
+ * @example
+ * ```typescript
+ * const windowThree = window(3);
+ * Array.from(windowThree([1, 2, 3, 4, 5]));
+ * // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
+ * ```
+ */
+declare function window<T>(size: number): (iterable: Iterable<T>) => IterableIterator<T[]>;
+/**
+ * Creates a curried function that splits elements into chunks of the specified size.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param size - The size of each chunk (must be at least 1)
+ * @returns A function that creates chunks from an iterable
+ * @throws {Error} If size is less than 1
+ * @example
+ * ```typescript
+ * const chunkTwo = chunk(2);
+ * Array.from(chunkTwo([1, 2, 3, 4, 5]));
+ * // [[1, 2], [3, 4], [5]]
+ * ```
+ */
+declare function chunk<T>(size: number): (iterable: Iterable<T>) => IterableIterator<T[]>;
+/**
+ * Creates pairs of consecutive elements from an iterable.
+ * Returns an iterable iterator of tuples.
+ *
+ * @template T The type of elements
+ * @param iterable - The iterable to create pairs from
+ * @returns An iterable iterator of tuples containing consecutive elements
+ * @example
+ * ```typescript
+ * Array.from(pairwise([1, 2, 3, 4]));
+ * // [[1, 2], [2, 3], [3, 4]]
+ * ```
+ */
+declare function pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]>;
+/**
+ * Creates a curried function that splits elements into two arrays based on a predicate.
+ * Returns a function that takes an iterable and returns a tuple of arrays.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that partitions an iterable
+ * @example
+ * ```typescript
+ * const partitionEvens = partition((x: number) => x % 2 === 0);
+ * partitionEvens([1, 2, 3, 4, 5]);
+ * // [[2, 4], [1, 3, 5]]
+ * ```
+ */
+declare function partition<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => [T[], T[]];
+/**
+ * Creates a curried function that groups elements by a key function into a Map.
+ * Returns a function that takes an iterable and returns a Map.
+ *
+ * @template T The type of elements
+ * @template K The type of the grouping key
+ * @param keyFn - Function to extract the grouping key from each element
+ * @returns A function that groups an iterable
+ * @example
+ * ```typescript
+ * const groupByLength = groupBy((s: string) => s.length);
+ * groupByLength(['alice', 'bob', 'charlie', 'dave']);
+ * // Map { 3 => ['bob'], 5 => ['alice'], 7 => ['charlie'], 4 => ['dave'] }
+ * ```
+ */
+declare function groupBy<T, K>(keyFn: (value: T) => K): (iterable: Iterable<T>) => Map<K, T[]>;
+/**
+ * Removes duplicate elements from an iterable, keeping only the first occurrence of each.
+ * Uses strict equality (===) to compare elements.
+ *
+ * @template T The type of elements
+ * @param iterable - The iterable to deduplicate
+ * @returns An iterable iterator with duplicate elements removed
+ * @example
+ * ```typescript
+ * Array.from(distinct([1, 2, 2, 3, 1, 4]));
+ * // [1, 2, 3, 4]
+ * ```
+ */
+declare function distinct<T>(iterable: Iterable<T>): IterableIterator<T>;
+/**
+ * Creates a curried function that removes duplicate elements based on a key function.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @template K The type of the key used for comparison
+ * @param keyFn - Function to extract the comparison key from each element
+ * @returns A function that deduplicates an iterable by key
+ * @example
+ * ```typescript
+ * const users = [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 1, name: 'Charlie'}];
+ * const distinctById = distinctBy((u: typeof users[0]) => u.id);
+ * Array.from(distinctById(users));
+ * // [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}]
+ * ```
+ */
+declare function distinctBy<T, K>(keyFn: (value: T) => K): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that executes a side-effect function on each element.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param fn - Function to execute for each element
+ * @returns A function that taps an iterable
+ * @example
+ * ```typescript
+ * const log = tap((x: number) => console.log('Processing:', x));
+ * Array.from(log([1, 2, 3])); // logs each value, returns [1, 2, 3]
+ * ```
+ */
+declare function tap<T>(fn: (value: T) => void): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that takes elements while the predicate returns true.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that takes elements while predicate is true
+ * @example
+ * ```typescript
+ * const takeLessThanFour = takeWhile((x: number) => x < 4);
+ * Array.from(takeLessThanFour([1, 2, 3, 4, 1, 2]));
+ * // [1, 2, 3]
+ * ```
+ */
+declare function takeWhile<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Creates a curried function that skips elements while the predicate returns true.
+ * Returns a function that takes an iterable and returns an iterable iterator.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that drops elements while predicate is true
+ * @example
+ * ```typescript
+ * const dropLessThanThree = dropWhile((x: number) => x < 3);
+ * Array.from(dropLessThanThree([1, 2, 3, 4, 1, 2]));
+ * // [3, 4, 1, 2]
+ * ```
+ */
+declare function dropWhile<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => IterableIterator<T>;
+/**
+ * Collects all elements from an iterable into an array.
+ *
+ * @template T The type of elements
+ * @param iterable - The iterable to convert to an array
+ * @returns An array containing all elements
+ * @example
+ * ```typescript
+ * toArray([1, 2, 3]); // [1, 2, 3]
+ * ```
+ */
+declare function toArray<T>(iterable: Iterable<T>): T[];
+/**
+ * Creates a curried function that reduces an iterable to a single value.
+ * Returns a function that takes an iterable and returns the reduced value.
+ *
+ * @template T The type of elements in the iterable
+ * @template U The type of the accumulated value
+ * @param fn - Function to combine the accumulator with each element
+ * @param initial - The initial value for the accumulator
+ * @returns A function that reduces an iterable
+ * @example
+ * ```typescript
+ * const sumAll = reduce((acc: number, x: number) => acc + x, 0);
+ * sumAll([1, 2, 3, 4]); // 10
+ * const concat = reduce((acc: string, x: string) => acc + x, '');
+ * concat(['a', 'b', 'c']); // 'abc'
+ * ```
+ */
+declare function reduce<T, U>(fn: (accumulator: U, value: T) => U, initial: U): (iterable: Iterable<T>) => U;
+/**
+ * Creates a curried function that finds the first element matching a predicate.
+ * Returns a function that takes an iterable and returns the first matching element or undefined.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that finds an element in an iterable
+ * @example
+ * ```typescript
+ * const findGreaterThanThree = find((x: number) => x > 3);
+ * findGreaterThanThree([1, 2, 3, 4, 5]); // 4
+ * findGreaterThanThree([1, 2, 3]); // undefined
+ * ```
+ */
+declare function find<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => T | undefined;
+/**
+ * Creates a curried function that finds the index of the first element matching a predicate.
+ * Returns a function that takes an iterable and returns the index or -1.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that finds an index in an iterable
+ * @example
+ * ```typescript
+ * const findIndexGreaterThanThree = findIndex((x: number) => x > 3);
+ * findIndexGreaterThanThree([1, 2, 3, 4, 5]); // 3
+ * findIndexGreaterThanThree([1, 2, 3]); // -1
+ * ```
+ */
+declare function findIndex<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => number;
+/**
+ * Creates a curried function that tests if any element matches a predicate.
+ * Returns a function that takes an iterable and returns a boolean.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that tests an iterable
+ * @example
+ * ```typescript
+ * const hasGreaterThanThree = some((x: number) => x > 3);
+ * hasGreaterThanThree([1, 2, 3, 4, 5]); // true
+ * hasGreaterThanThree([1, 2, 3]); // false
+ * ```
+ */
+declare function some<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => boolean;
+/**
+ * Creates a curried function that tests if all elements match a predicate.
+ * Returns a function that takes an iterable and returns a boolean.
+ *
+ * @template T The type of elements
+ * @param predicate - Function to test each element
+ * @returns A function that tests an iterable
+ * @example
+ * ```typescript
+ * const allEven = every((x: number) => x % 2 === 0);
+ * allEven([2, 4, 6]); // true
+ * allEven([1, 2, 3]); // false
+ * ```
+ */
+declare function every<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => boolean;
+/**
+ * Gets the first element from an iterable.
+ *
+ * @template T The type of elements
+ * @param iterable - The iterable to get the first element from
+ * @param defaultValue - Optional default value to return if iterable is empty
+ * @returns The first element, the default value, or undefined if empty and no default
+ * @example
+ * ```typescript
+ * first([1, 2, 3]); // 1
+ * first([]); // undefined
+ * first([], 0); // 0
+ * ```
+ */
+declare function first<T>(iterable: Iterable<T>, defaultValue?: T): T | undefined;
+/**
+ * Gets the last element from an iterable.
+ *
+ * @template T The type of elements
+ * @param iterable - The iterable to get the last element from
+ * @param defaultValue - Optional default value to return if iterable is empty
+ * @returns The last element, the default value, or undefined if empty and no default
+ * @example
+ * ```typescript
+ * last([1, 2, 3]); // 3
+ * last([]); // undefined
+ * last([], 0); // 0
+ * ```
+ */
+declare function last<T>(iterable: Iterable<T>, defaultValue?: T): T | undefined;
+/**
+ * Creates a curried function that gets the element at a specified index.
+ * Returns a function that takes an iterable and returns the element or undefined.
+ *
+ * @template T The type of elements
+ * @param index - Zero-based index of the element to retrieve
+ * @returns A function that gets an element from an iterable
+ * @example
+ * ```typescript
+ * const getSecond = nth(2);
+ * getSecond([1, 2, 3, 4, 5]); // 3
+ * getSecond([1, 2]); // undefined
+ * nth(-1)([1, 2, 3]); // undefined
+ * ```
+ */
+declare function nth<T>(index: number): (iterable: Iterable<T>) => T | undefined;
+/**
+ * Checks if an iterable is empty.
+ *
+ * @template T The type of elements
+ * @param iterable - The iterable to check
+ * @returns true if the iterable has no elements, false otherwise
+ * @example
+ * ```typescript
+ * isEmpty([]); // true
+ * isEmpty([1, 2, 3]); // false
+ * ```
+ */
+declare function isEmpty<T>(iterable: Iterable<T>): boolean;
+/**
+ * Creates a curried function that checks if an iterable includes a specific value.
+ * Uses strict equality (===) for comparison.
+ * Returns a function that takes an iterable and returns a boolean.
+ *
+ * @template T The type of elements
+ * @param searchValue - The value to search for
+ * @returns A function that checks if an iterable includes the value
+ * @example
+ * ```typescript
+ * const includesThree = includes(3);
+ * includesThree([1, 2, 3, 4, 5]); // true
+ * includesThree([1, 2, 4]); // false
+ * includes('b')(['a', 'b', 'c']); // true
+ * ```
+ */
+declare function includes<T>(searchValue: T): (iterable: Iterable<T>) => boolean;
+/**
+ * Combines two iterables into an iterator of tuples.
+ * Stops when the shorter iterable is exhausted.
+ *
+ * @template T The type of elements in the first iterable
+ * @template U The type of elements in the second iterable
+ * @param iter1 - The first iterable
+ * @param iter2 - The second iterable
+ * @returns An iterable iterator of tuples pairing elements from both iterables
+ * @example
+ * ```typescript
+ * Array.from(zip([1, 2, 3], ['a', 'b', 'c']));
+ * // [[1, 'a'], [2, 'b'], [3, 'c']]
+ * ```
+ */
+declare function zip<T, U>(iter1: Iterable<T>, iter2: Iterable<U>): IterableIterator<[T, U]>;
+/**
+ * Combines two iterables using a combining function.
+ * Stops when the shorter iterable is exhausted.
+ *
+ * @template T The type of elements in the first iterable
+ * @template U The type of elements in the second iterable
+ * @template R The type of the result
+ * @param iter1 - The first iterable
+ * @param iter2 - The second iterable
+ * @param fn - Function to combine elements from both iterables
+ * @returns An iterable iterator with combined results
+ * @example
+ * ```typescript
+ * Array.from(zipWith([1, 2, 3], [10, 20, 30], (a, b) => a + b));
+ * // [11, 22, 33]
+ * ```
+ */
+declare function zipWith<T, U, R>(iter1: Iterable<T>, iter2: Iterable<U>, fn: (a: T, b: U) => R): IterableIterator<R>;
+/**
+ * Generates a sequence of numbers.
+ * Supports three call signatures:
+ * - range(stop): generates [0, stop) with step 1
+ * - range(start, stop): generates [start, stop) with step 1
+ * - range(start, stop, step): generates [start, stop) with custom step
+ *
+ * @param stop - The end value (exclusive) when called with one argument
+ * @returns An iterable iterator of numbers
+ * @throws {Error} If step is zero
+ * @example
+ * ```typescript
+ * Array.from(range(5)); // [0, 1, 2, 3, 4]
+ * Array.from(range(2, 5)); // [2, 3, 4]
+ * Array.from(range(0, 10, 2)); // [0, 2, 4, 6, 8]
+ * Array.from(range(5, 0, -1)); // [5, 4, 3, 2, 1]
+ * ```
+ */
+declare function range(stop: number): IterableIterator<number>;
+/**
+ * Generates a sequence of numbers from start to stop (exclusive).
+ *
+ * @param start - The starting value (inclusive)
+ * @param stop - The end value (exclusive)
+ * @returns An iterable iterator of numbers
+ */
+declare function range(start: number, stop: number): IterableIterator<number>;
+/**
+ * Generates a sequence of numbers from start to stop (exclusive) with a custom step.
+ *
+ * @param start - The starting value (inclusive)
+ * @param stop - The end value (exclusive)
+ * @param step - The increment between values
+ * @returns An iterable iterator of numbers
+ */
+declare function range(start: number, stop: number, step: number): IterableIterator<number>;
+/**
+ * Repeats a value a specified number of times, or infinitely.
+ * If times is not specified, creates an infinite iterator.
+ *
+ * @template T The type of the value to repeat
+ * @param value - The value to repeat
+ * @param times - Optional number of times to repeat (infinite if omitted)
+ * @returns An iterable iterator repeating the value
+ * @example
+ * ```typescript
+ * Array.from(repeat('x', 3)); // ['x', 'x', 'x']
+ * Array.from(repeat(0, 5)); // [0, 0, 0, 0, 0]
+ * Array.from(take(3)(repeat(1))); // [1, 1, 1] (infinite, limited by take)
+ * ```
+ */
+declare function repeat<T>(value: T, times?: number): IterableIterator<T>;
+/**
+ * Alternates elements from multiple iterables in a round-robin fashion.
+ * Continues until all iterables are exhausted.
+ *
+ * @template T The type of elements in all iterables
+ * @param iterables - Variable number of iterables to interleave
+ * @returns An iterable iterator with elements from all iterables interleaved
+ * @example
+ * ```typescript
+ * Array.from(interleave([1, 2, 3], [4, 5, 6]));
+ * // [1, 4, 2, 5, 3, 6]
+ * Array.from(interleave([1, 2], [3, 4, 5], [6]));
+ * // [1, 3, 6, 2, 4, 5]
+ * ```
+ */
+declare function interleave<T>(...iterables: Iterable<T>[]): IterableIterator<T>;
+/**
+ * Merges multiple sorted iterables into a single sorted iterator.
+ * Assumes input iterables are already sorted in ascending order.
+ * Uses a custom comparator if provided, otherwise uses default < comparison.
+ *
+ * @template T The type of elements in all iterables
+ * @param iterables - Variable number of sorted iterables to merge
+ * @returns An iterable iterator with all elements merged in sorted order
+ * @example
+ * ```typescript
+ * Array.from(merge([1, 3, 5], [2, 4, 6]));
+ * // [1, 2, 3, 4, 5, 6]
+ * Array.from(merge([1, 5, 9], [2, 6, 10], [3, 7, 11]));
+ * // [1, 2, 3, 5, 6, 7, 9, 10, 11]
+ * ```
+ */
+declare function merge<T>(...iterables: Iterable<T>[]): IterableIterator<T>;
+declare function merge<T>(compareFn: (a: T, b: T) => number, ...iterables: Iterable<T>[]): IterableIterator<T>;
+/**
+ * Chains multiple iterables sequentially, one after another.
+ * Yields all elements from the first iterable, then all from the second, etc.
+ *
+ * @template T The type of elements in all iterables
+ * @param iterables - Variable number of iterables to chain
+ * @returns An iterable iterator with all elements chained sequentially
+ * @example
+ * ```typescript
+ * Array.from(chain([1, 2], [3, 4], [5, 6]));
+ * // [1, 2, 3, 4, 5, 6]
+ * Array.from(chain([1], [2, 3], [], [4, 5, 6]));
+ * // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+declare function chain<T>(...iterables: Iterable<T>[]): IterableIterator<T>;
+
+export { type IterableTransformer, type Reducer, type TerminalOperation, type Transducer, chain, chunk, compose, composeTransducers, concat, correlation, count, covariance, createOperation, distinct, distinctBy, drop, dropWhile, enumerate, every, filter, filterTransducer, find, findIndex, first, flatMap, groupBy, includes, interleave, intersperse, isEmpty, isReduced, last, map, mapTransducer, max, mean, median, merge, min, mode, nth, pairwise, partition, percentile, pipe, product, quartiles, range, reduce, reduced, repeat, reverse, scan, some, sort, sortBy, span, stdDev, sum, take, takeTransducer, takeWhile, tap, toArray, transduce, transducerToIterator, variance, window, zip, zipWith };