@statedelta-libs/operators 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,2353 @@
+/**
+ * Returns its argument unchanged.
+ *
+ * The identity function is useful as a default transformation,
+ * placeholder in pipelines, or when a function is required but
+ * no transformation is needed.
+ *
+ * @param x - The value to return
+ * @returns The same value
+ *
+ * @example
+ * ```ts
+ * identity(5);              // 5
+ * identity({ a: 1 });       // { a: 1 }
+ * identity([1, 2, 3]);      // [1, 2, 3]
+ *
+ * // Useful as default in pipelines
+ * const transform = condition ? someTransform : identity;
+ * pipe(data, transform, process);
+ *
+ * // Useful as filter predicate (keeps truthy values)
+ * [1, 0, 2, null, 3].filter(identity); // [1, 2, 3]
+ * ```
+ */
+declare function identity<T>(x: T): T;
+
+/**
+ * Creates a function that always returns the same value.
+ *
+ * Useful for providing constant values in places that expect functions,
+ * like in `cond`, `ifElse`, or as default transformations.
+ *
+ * @param x - The value to always return
+ * @returns A function that ignores its arguments and returns x
+ *
+ * @example
+ * ```ts
+ * const alwaysFive = always(5);
+ * alwaysFive();        // 5
+ * alwaysFive(100);     // 5
+ * alwaysFive('any');   // 5
+ *
+ * // Useful in conditionals
+ * const getDiscount = cond([
+ *   [propEq('tier', 'gold'), always(0.3)],
+ *   [propEq('tier', 'silver'), always(0.2)],
+ *   [T, always(0)]  // default
+ * ]);
+ *
+ * // Useful in ifElse
+ * const discount = ifElse(
+ *   propEq('vip', true),
+ *   always(0.2),
+ *   always(0)
+ * );
+ * ```
+ */
+declare function always<T>(x: T): () => T;
+
+/**
+ * Constant functions that return true or false.
+ *
+ * These are useful as default predicates in conditional functions
+ * like `cond`, `filter`, or as terminal cases in pattern matching.
+ */
+/**
+ * A function that always returns true.
+ *
+ * Useful as a default case or catch-all predicate.
+ *
+ * @returns Always true
+ *
+ * @example
+ * ```ts
+ * T();  // true
+ *
+ * // Default case in cond
+ * const classify = cond([
+ *   [propEq('type', 'admin'), always('full')],
+ *   [propEq('type', 'user'), always('limited')],
+ *   [T, always('none')]  // default case - always matches
+ * ]);
+ *
+ * // Always include
+ * filter(T, [1, 2, 3]);  // [1, 2, 3]
+ * ```
+ */
+declare function T$1(): true;
+/**
+ * A function that always returns false.
+ *
+ * Useful as a never-matching predicate or to explicitly exclude.
+ *
+ * @returns Always false
+ *
+ * @example
+ * ```ts
+ * F();  // false
+ *
+ * // Never match
+ * filter(F, [1, 2, 3]);  // []
+ *
+ * // Explicit disable
+ * const shouldProcess = isEnabled ? checkCondition : F;
+ * ```
+ */
+declare function F(): false;
+
+/**
+ * Executes a side-effect function and returns the original value.
+ *
+ * `tap` is invaluable for debugging pipelines, logging intermediate
+ * values, or performing side-effects without breaking the data flow.
+ * The side-effect function's return value is ignored.
+ *
+ * @param fn - The side-effect function to execute
+ * @param x - The value to pass through
+ * @returns The original value x, unchanged
+ *
+ * @example
+ * ```ts
+ * // Debugging a pipeline
+ * pipe(
+ *   [1, 2, 3, 4, 5],
+ *   filter(x => x > 2),
+ *   tap(console.log),        // logs: [3, 4, 5]
+ *   map(x => x * 2),
+ *   tap(console.log),        // logs: [6, 8, 10]
+ *   sum
+ * );  // 24
+ *
+ * // Curried usage
+ * const log = tap(console.log);
+ * log('hello');  // logs 'hello', returns 'hello'
+ *
+ * // Side-effects in transformations
+ * const users = pipe(
+ *   fetchUsers(),
+ *   tap(users => analytics.track('users_fetched', { count: users.length })),
+ *   filter(user => user.active)
+ * );
+ * ```
+ */
+interface TapFn {
+    <T>(fn: (x: T) => void, x: T): T;
+    <T>(fn: (x: T) => void): (x: T) => T;
+}
+declare const tap: TapFn;
+
+/**
+ * @statedelta-libs/operators - Type Definitions
+ *
+ * Core type definitions for the functional operators library.
+ */
+/**
+ * Unique symbol used to identify placeholder values in curried functions.
+ * Allows "skipping" arguments when partially applying functions.
+ */
+declare const PLACEHOLDER: unique symbol;
+/**
+ * The Placeholder type represents the `__` value used in curried functions.
+ */
+type Placeholder = typeof PLACEHOLDER & {
+    readonly __: unique symbol;
+};
+/**
+ * Generic function type with any number of arguments.
+ */
+type Fn<Args extends unknown[] = unknown[], R = unknown> = (...args: Args) => R;
+/**
+ * Unary function - takes exactly one argument.
+ */
+type UnaryFn<A, R> = (a: A) => R;
+/**
+ * Generic unary function type that accepts any function.
+ * Uses `any` following Ramda's approach - TypeScript cannot precisely
+ * infer types for arbitrary function composition.
+ */
+type AnyUnaryFn = (arg: any) => any;
+/**
+ * Binary function - takes exactly two arguments.
+ */
+type BinaryFn<A, B, R> = (a: A, b: B) => R;
+/**
+ * Ternary function - takes exactly three arguments.
+ */
+type TernaryFn<A, B, C, R> = (a: A, b: B, c: C) => R;
+/**
+ * Variadic function - takes any number of arguments.
+ */
+type VariadicFn<R = unknown> = (...args: unknown[]) => R;
+/**
+ * Curried unary function.
+ * Can be called with no args (returns itself) or one arg (returns result).
+ */
+interface Curry1<A, R> {
+    (): Curry1<A, R>;
+    (a: A): R;
+}
+/**
+ * Curried binary function with placeholder support.
+ */
+interface Curry2<A, B, R> {
+    (): Curry2<A, B, R>;
+    (a: A): Curry1<B, R>;
+    (a: Placeholder): Curry2<A, B, R>;
+    (a: A, b: B): R;
+    (a: A, b: Placeholder): Curry1<B, R>;
+    (a: Placeholder, b: B): Curry1<A, R>;
+    (a: Placeholder, b: Placeholder): Curry2<A, B, R>;
+}
+/**
+ * Curried ternary function with placeholder support.
+ */
+interface Curry3<A, B, C, R> {
+    (): Curry3<A, B, C, R>;
+    (a: A): Curry2<B, C, R>;
+    (a: Placeholder): Curry3<A, B, C, R>;
+    (a: A, b: B): Curry1<C, R>;
+    (a: A, b: Placeholder): Curry2<B, C, R>;
+    (a: Placeholder, b: B): Curry2<A, C, R>;
+    (a: A, b: B, c: C): R;
+    (a: A, b: B, c: Placeholder): Curry1<C, R>;
+    (a: A, b: Placeholder, c: C): Curry1<B, R>;
+    (a: Placeholder, b: B, c: C): Curry1<A, R>;
+    (a: A, b: Placeholder, c: Placeholder): Curry2<B, C, R>;
+    (a: Placeholder, b: B, c: Placeholder): Curry2<A, C, R>;
+    (a: Placeholder, b: Placeholder, c: C): Curry2<A, B, R>;
+    (a: Placeholder, b: Placeholder, c: Placeholder): Curry3<A, B, C, R>;
+}
+/**
+ * Curried quaternary function with placeholder support.
+ */
+interface Curry4<A, B, C, D, R> {
+    (): Curry4<A, B, C, D, R>;
+    (a: A): Curry3<B, C, D, R>;
+    (a: Placeholder): Curry4<A, B, C, D, R>;
+    (a: A, b: B): Curry2<C, D, R>;
+    (a: A, b: Placeholder): Curry3<B, C, D, R>;
+    (a: Placeholder, b: B): Curry3<A, C, D, R>;
+    (a: A, b: B, c: C): Curry1<D, R>;
+    (a: A, b: B, c: Placeholder): Curry2<C, D, R>;
+    (a: A, b: Placeholder, c: C): Curry2<B, D, R>;
+    (a: Placeholder, b: B, c: C): Curry2<A, D, R>;
+    (a: A, b: B, c: C, d: D): R;
+    (a: A, b: B, c: C, d: Placeholder): Curry1<D, R>;
+    (a: A, b: B, c: Placeholder, d: D): Curry1<C, R>;
+    (a: A, b: Placeholder, c: C, d: D): Curry1<B, R>;
+    (a: Placeholder, b: B, c: C, d: D): Curry1<A, R>;
+    (a: A, b: Placeholder, c: Placeholder, d: D): Curry2<B, C, R>;
+    (a: Placeholder, b: B, c: Placeholder, d: D): Curry2<A, C, R>;
+    (a: Placeholder, b: Placeholder, c: C, d: D): Curry2<A, B, R>;
+    (a: A, b: B, c: Placeholder, d: Placeholder): Curry2<C, D, R>;
+    (a: A, b: Placeholder, c: C, d: Placeholder): Curry2<B, D, R>;
+    (a: Placeholder, b: B, c: C, d: Placeholder): Curry2<A, D, R>;
+    (a: Placeholder, b: Placeholder, c: Placeholder, d: D): Curry3<A, B, C, R>;
+    (a: Placeholder, b: Placeholder, c: C, d: Placeholder): Curry3<A, B, D, R>;
+    (a: Placeholder, b: B, c: Placeholder, d: Placeholder): Curry3<A, C, D, R>;
+    (a: A, b: Placeholder, c: Placeholder, d: Placeholder): Curry3<B, C, D, R>;
+}
+/**
+ * Extract the first element type of a tuple.
+ */
+type Head<T extends unknown[]> = T extends [infer H, ...unknown[]] ? H : never;
+/**
+ * Extract all but the first element of a tuple.
+ */
+type Tail<T extends unknown[]> = T extends [unknown, ...infer R] ? R : never;
+/**
+ * Extract the last element type of a tuple.
+ */
+type Last<T extends unknown[]> = T extends [...unknown[], infer L] ? L : never;
+/**
+ * Pipe function overloads for type inference.
+ */
+interface PipeFn {
+    <A>(a: A): A;
+    <A, B>(a: A, ab: UnaryFn<A, B>): B;
+    <A, B, C>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>): C;
+    <A, B, C, D>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>): D;
+    <A, B, C, D, E>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>): E;
+    <A, B, C, D, E, F>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>): F;
+    <A, B, C, D, E, F, G>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>): G;
+    <A, B, C, D, E, F, G, H>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>): H;
+    <A, B, C, D, E, F, G, H, I>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>): I;
+    <A, B, C, D, E, F, G, H, I, J>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>, ij: UnaryFn<I, J>): J;
+    (a: unknown, ...fns: AnyUnaryFn[]): unknown;
+}
+/**
+ * Pipe builder that returns a composed function.
+ */
+interface PipeBuilderFn {
+    (): <T>(x: T) => T;
+    <A, B>(ab: UnaryFn<A, B>): UnaryFn<A, B>;
+    <A, B, C>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>): UnaryFn<A, C>;
+    <A, B, C, D>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>): UnaryFn<A, D>;
+    <A, B, C, D, E>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>): UnaryFn<A, E>;
+    <A, B, C, D, E, F>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>): UnaryFn<A, F>;
+    <A, B, C, D, E, F, G>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>): UnaryFn<A, G>;
+    <A, B, C, D, E, F, G, H>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>): UnaryFn<A, H>;
+    <A, B, C, D, E, F, G, H, I>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>): UnaryFn<A, I>;
+    <A, B, C, D, E, F, G, H, I, J>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>, ij: UnaryFn<I, J>): UnaryFn<A, J>;
+    (...fns: AnyUnaryFn[]): AnyUnaryFn;
+}
+/**
+ * Compose builder that returns a composed function (right to left).
+ */
+interface ComposeBuilderFn {
+    (): <T>(x: T) => T;
+    <A, B>(ab: UnaryFn<A, B>): UnaryFn<A, B>;
+    <A, B, C>(bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, C>;
+    <A, B, C, D>(cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, D>;
+    <A, B, C, D, E>(de: UnaryFn<D, E>, cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, E>;
+    <A, B, C, D, E, F>(ef: UnaryFn<E, F>, de: UnaryFn<D, E>, cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, F>;
+    <A, B, C, D, E, F, G>(fg: UnaryFn<F, G>, ef: UnaryFn<E, F>, de: UnaryFn<D, E>, cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, G>;
+    <A, B, C, D, E, F, G, H>(gh: UnaryFn<G, H>, fg: UnaryFn<F, G>, ef: UnaryFn<E, F>, de: UnaryFn<D, E>, cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, H>;
+    <A, B, C, D, E, F, G, H, I>(hi: UnaryFn<H, I>, gh: UnaryFn<G, H>, fg: UnaryFn<F, G>, ef: UnaryFn<E, F>, de: UnaryFn<D, E>, cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, I>;
+    <A, B, C, D, E, F, G, H, I, J>(ij: UnaryFn<I, J>, hi: UnaryFn<H, I>, gh: UnaryFn<G, H>, fg: UnaryFn<F, G>, ef: UnaryFn<E, F>, de: UnaryFn<D, E>, cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>): UnaryFn<A, J>;
+    (...fns: AnyUnaryFn[]): AnyUnaryFn;
+}
+/**
+ * Makes a type nullable (T | null | undefined).
+ */
+type Nullable<T> = T | null | undefined;
+/**
+ * Extracts the return type of a function.
+ */
+type ReturnOf<F> = F extends (...args: unknown[]) => infer R ? R : never;
+/**
+ * Extracts the parameter types of a function as a tuple.
+ */
+type ParamsOf<F> = F extends (...args: infer P) => unknown ? P : never;
+/**
+ * Deep readonly type.
+ */
+type DeepReadonly<T> = T extends (...args: unknown[]) => unknown ? T : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+/**
+ * Predicate function - returns boolean.
+ */
+type Predicate<T> = (value: T, index: number, array: readonly T[]) => boolean;
+/**
+ * Mapper function - transforms value.
+ */
+type Mapper<T, U> = (value: T, index: number, array: readonly T[]) => U;
+/**
+ * Reducer function - accumulates value.
+ */
+type Reducer<T, U> = (accumulator: U, value: T, index: number, array: readonly T[]) => U;
+/**
+ * Comparator function - compares two values.
+ */
+type Comparator<T> = (a: T, b: T) => number;
+
+/**
+ * Transforms a function into a curried version.
+ *
+ * A curried function can be called with fewer arguments than it expects.
+ * It returns a new function that takes the remaining arguments.
+ * Supports placeholder (`__`) for skipping arguments.
+ *
+ * @param fn - The function to curry
+ * @returns A curried version of the function
+ *
+ * @example
+ * ```ts
+ * // Basic currying
+ * const add3 = curry((a: number, b: number, c: number) => a + b + c);
+ *
+ * add3(1, 2, 3);     // 6
+ * add3(1)(2)(3);     // 6
+ * add3(1, 2)(3);     // 6
+ * add3(1)(2, 3);     // 6
+ *
+ * // With placeholder
+ * const addTenToMiddle = add3(__, 10, __);
+ * addTenToMiddle(1, 2);  // 13  (1 + 10 + 2)
+ *
+ * // Practical example
+ * const greet = curry((greeting: string, name: string) => `${greeting}, ${name}!`);
+ * const sayHello = greet('Hello');
+ * sayHello('World');  // 'Hello, World!'
+ * ```
+ */
+
+/**
+ * Curries a function, using optimized implementations for common arities.
+ *
+ * @param fn - The function to curry
+ * @returns A curried version of the function
+ */
+declare function curry<A, R>(fn: (a: A) => R): Curry1<A, R>;
+declare function curry<A, B, R>(fn: (a: A, b: B) => R): Curry2<A, B, R>;
+declare function curry<A, B, C, R>(fn: (a: A, b: B, c: C) => R): Curry3<A, B, C, R>;
+declare function curry<A, B, C, D, R>(fn: (a: A, b: B, c: C, d: D) => R): Curry4<A, B, C, D, R>;
+
+/**
+ * Curries a function with a specified arity.
+ *
+ * Unlike `curry`, which uses `fn.length` to determine arity,
+ * `curryN` allows explicit control. This is useful for:
+ * - Functions with default parameters (where `length` is misleading)
+ * - Variadic functions that should be curried to a specific arity
+ * - Functions with rest parameters
+ *
+ * @param arity - The number of arguments to curry
+ * @param fn - The function to curry
+ * @returns A curried version of the function
+ *
+ * @example
+ * ```ts
+ * // Function with default parameter
+ * const greet = (greeting: string, name: string, punctuation = '!') =>
+ *   `${greeting}, ${name}${punctuation}`;
+ *
+ * // greet.length is 2 (doesn't count default param)
+ * // But we want to curry all 3 parameters
+ * const curriedGreet = curryN(3, greet);
+ *
+ * curriedGreet('Hello')('World')('?');  // 'Hello, World?'
+ * curriedGreet('Hello', 'World', '?');  // 'Hello, World?'
+ *
+ * // Variadic function curried to specific arity
+ * const sum = (...nums: number[]) => nums.reduce((a, b) => a + b, 0);
+ * const sum3 = curryN(3, sum);
+ *
+ * sum3(1)(2)(3);  // 6
+ * sum3(1, 2)(3);  // 6
+ * ```
+ */
+
+/**
+ * Curries a function with explicit arity control.
+ */
+declare function curryN<R>(arity: 0, fn: () => R): () => R;
+declare function curryN<A, R>(arity: 1, fn: (a: A) => R): Curry1<A, R>;
+declare function curryN<A, B, R>(arity: 2, fn: (a: A, b: B) => R): Curry2<A, B, R>;
+declare function curryN<A, B, C, R>(arity: 3, fn: (a: A, b: B, c: C) => R): Curry3<A, B, C, R>;
+declare function curryN<A, B, C, D, R>(arity: 4, fn: (a: A, b: B, c: C, d: D) => R): Curry4<A, B, C, D, R>;
+declare function curryN<R>(arity: number, fn: (...args: any[]) => R): (...args: any[]) => any;
+
+/**
+ * Partially applies a function by fixing some arguments.
+ *
+ * Unlike currying (which waits for one argument at a time),
+ * partial application immediately fixes multiple arguments.
+ * Supports placeholder (`__`) for skipping arguments.
+ *
+ * @param fn - The function to partially apply
+ * @param args - The arguments to fix (can include placeholders)
+ * @returns A function waiting for the remaining arguments
+ *
+ * @example
+ * ```ts
+ * const greet = (greeting: string, name: string, punctuation: string) =>
+ *   `${greeting}, ${name}${punctuation}`;
+ *
+ * // Fix first argument
+ * const sayHello = partial(greet, ['Hello']);
+ * sayHello('World', '!');  // 'Hello, World!'
+ *
+ * // Fix multiple arguments
+ * const helloWorld = partial(greet, ['Hello', 'World']);
+ * helloWorld('!');  // 'Hello, World!'
+ *
+ * // With placeholders
+ * const askName = partial(greet, [__, __, '?']);
+ * askName('Hey', 'You');  // 'Hey, You?'
+ *
+ * const greetWorld = partial(greet, [__, 'World', '!']);
+ * greetWorld('Hi');  // 'Hi, World!'
+ * ```
+ */
+
+/**
+ * Partially applies a function with the given arguments.
+ */
+declare function partial<T extends (...args: never[]) => unknown>(fn: T, args: readonly (unknown | Placeholder)[]): (...remainingArgs: unknown[]) => ReturnType<T>;
+/**
+ * Like partial, but applies arguments from the right.
+ *
+ * @param fn - The function to partially apply
+ * @param args - The arguments to fix from the right
+ * @returns A function waiting for the remaining arguments
+ *
+ * @example
+ * ```ts
+ * const greet = (greeting: string, name: string, punctuation: string) =>
+ *   `${greeting}, ${name}${punctuation}`;
+ *
+ * // Fix last argument
+ * const exclaim = partialRight(greet, ['!']);
+ * exclaim('Hello', 'World');  // 'Hello, World!'
+ *
+ * // Fix last two arguments
+ * const greetWorldExclaim = partialRight(greet, ['World', '!']);
+ * greetWorldExclaim('Hello');  // 'Hello, World!'
+ * ```
+ */
+declare function partialRight<T extends (...args: never[]) => unknown>(fn: T, args: readonly unknown[]): (...remainingArgs: unknown[]) => ReturnType<T>;
+
+/**
+ * Performs left-to-right function composition.
+ *
+ * `pipe` takes a value and a sequence of functions, applying each
+ * function to the result of the previous one. This creates a clear,
+ * readable data transformation pipeline.
+ *
+ * For creating reusable composed functions, see `pipeWith` or use
+ * `pipe` with a leading function.
+ *
+ * @example
+ * ```ts
+ * // Direct application
+ * pipe(
+ *   5,
+ *   x => x + 1,      // 6
+ *   x => x * 2,      // 12
+ *   x => `Result: ${x}`  // 'Result: 12'
+ * );
+ *
+ * // With array operations
+ * pipe(
+ *   [1, 2, 3, 4, 5],
+ *   arr => arr.filter(x => x > 2),
+ *   arr => arr.map(x => x * 2),
+ *   arr => arr.reduce((a, b) => a + b, 0)
+ * );  // 24
+ *
+ * // Building pipelines
+ * const process = (data: number[]) => pipe(
+ *   data,
+ *   filter(x => x > 0),
+ *   map(x => x * 2),
+ *   sum
+ * );
+ * ```
+ */
+
+/**
+ * Applies a sequence of functions to a value, left-to-right.
+ */
+declare const pipe: PipeFn;
+/**
+ * Creates a composed function from left-to-right.
+ *
+ * Unlike `pipe` which immediately applies to a value, `pipeBuilder`
+ * returns a reusable function.
+ *
+ * @example
+ * ```ts
+ * const process = pipeBuilder(
+ *   (x: number) => x + 1,
+ *   x => x * 2,
+ *   x => `Result: ${x}`
+ * );
+ *
+ * process(5);  // 'Result: 12'
+ * process(10); // 'Result: 22'
+ * ```
+ */
+declare const pipeBuilder: PipeBuilderFn;
+
+/**
+ * Performs right-to-left function composition.
+ *
+ * `compose` creates a function that applies its arguments from right
+ * to left. This matches mathematical function composition notation:
+ * compose(f, g, h)(x) === f(g(h(x)))
+ *
+ * Most developers find `pipe` (left-to-right) more intuitive for
+ * data processing pipelines, but `compose` is useful when you want
+ * to match mathematical notation or build functions "inside out".
+ *
+ * @example
+ * ```ts
+ * // Mathematical notation: (f ∘ g ∘ h)(x) = f(g(h(x)))
+ * const process = compose(
+ *   (x: number) => `Result: ${x}`,  // applied 3rd
+ *   (x: number) => x * 2,            // applied 2nd
+ *   (x: number) => x + 1             // applied 1st
+ * );
+ *
+ * process(5);  // 'Result: 12'
+ *
+ * // Equivalent to:
+ * // step1 = 5 + 1 = 6
+ * // step2 = 6 * 2 = 12
+ * // step3 = 'Result: 12'
+ *
+ * // Practical example
+ * const getFullName = compose(
+ *   (s: string) => s.trim(),
+ *   (parts: string[]) => parts.join(' '),
+ *   (user: { first: string; last: string }) => [user.first, user.last]
+ * );
+ *
+ * getFullName({ first: 'John', last: 'Doe' });  // 'John Doe'
+ * ```
+ */
+
+/**
+ * Creates a composed function from right-to-left.
+ */
+declare const compose: ComposeBuilderFn;
+
+/**
+ * Performs left-to-right function composition with a transformer.
+ *
+ * `pipeWith` is like `pipe`, but applies a transformer function between
+ * each step. This is useful for:
+ * - Logging/debugging pipelines
+ * - Handling async operations (Promise resolution)
+ * - Validation between steps
+ * - Performance monitoring
+ *
+ * The transformer receives the next function and the current value,
+ * and should return the result to pass to the next step.
+ *
+ * @param transformer - Function called between each step: (fn, value) => result
+ * @param fns - The functions to compose
+ * @returns A composed function
+ *
+ * @example
+ * ```ts
+ * // Logging transformer
+ * const loggedPipe = pipeWith(
+ *   (fn, val) => {
+ *     console.log('Input:', val);
+ *     const result = fn(val);
+ *     console.log('Output:', result);
+ *     return result;
+ *   },
+ *   [
+ *     (x: number) => x + 1,
+ *     (x: number) => x * 2,
+ *     (x: number) => x.toString()
+ *   ]
+ * );
+ *
+ * loggedPipe(5);
+ * // Input: 5
+ * // Output: 6
+ * // Input: 6
+ * // Output: 12
+ * // Input: 12
+ * // Output: '12'
+ * // Returns: '12'
+ *
+ * // Async transformer (resolves promises between steps)
+ * const asyncPipe = pipeWith(
+ *   async (fn, val) => fn(await val),
+ *   [
+ *     async (x: number) => x + 1,
+ *     async (x: number) => x * 2,
+ *     (x: number) => x.toString()
+ *   ]
+ * );
+ *
+ * await asyncPipe(Promise.resolve(5));  // '12'
+ *
+ * // Validation transformer
+ * const validatedPipe = pipeWith(
+ *   (fn, val) => {
+ *     if (val == null) throw new Error('Null value in pipeline');
+ *     return fn(val);
+ *   },
+ *   [
+ *     (x: { name: string }) => x.name,
+ *     (name: string) => name.toUpperCase()
+ *   ]
+ * );
+ * ```
+ */
+
+/**
+ * Transformer function type for pipeWith.
+ * Uses `any` following Ramda's approach for practical usability.
+ */
+type PipeTransformer = (fn: AnyUnaryFn, value: any) => any;
+/**
+ * Creates a composed function with a transformer between each step.
+ */
+declare function pipeWith<T, R>(transformer: PipeTransformer, fns: readonly AnyUnaryFn[]): (value: T) => R;
+/**
+ * Creates a composed function that handles async operations.
+ *
+ * Each function in the pipeline can return a Promise. The pipeline
+ * will await each result before passing to the next function.
+ *
+ * @param fns - The functions to compose (can return Promises)
+ * @returns An async composed function
+ *
+ * @example
+ * ```ts
+ * const fetchAndProcess = pipeAsync(
+ *   (id: string) => fetch(`/api/user/${id}`),
+ *   (res: Response) => res.json(),
+ *   (user: User) => user.name,
+ *   (name: string) => name.toUpperCase()
+ * );
+ *
+ * await fetchAndProcess('123');  // 'JOHN DOE'
+ * ```
+ */
+declare function pipeAsync<T, R>(...fns: readonly AnyUnaryFn[]): (value: T) => Promise<R>;
+/**
+ * Creates a composed function from right-to-left that handles async.
+ *
+ * @param fns - The functions to compose (can return Promises)
+ * @returns An async composed function
+ */
+declare function composeAsync<T, R>(...fns: readonly AnyUnaryFn[]): (value: T) => Promise<R>;
+
+/**
+ * Reader operators - Pipe/Compose for functions with context
+ * @module core/reader
+ *
+ * Reader pattern allows passing context implicitly through a pipeline.
+ * Instead of `a -> b`, functions are `a -> (ctx -> b)`.
+ */
+type ReaderFn<A, B, Ctx> = (a: A) => (ctx: Ctx) => B;
+/**
+ * Pipes functions that return readers (Kleisli composition, left-to-right).
+ * Each function receives the result of the previous and the shared context.
+ *
+ * @example
+ * const withUser = (data) => (ctx) => ({ ...data, user: ctx.user })
+ * const withRole = (data) => (ctx) => ({ ...data, role: ctx.role })
+ *
+ * const process = pipeK(withUser, withRole)
+ * process({})({ user: 'alice', role: 'admin' })
+ * // { user: 'alice', role: 'admin' }
+ */
+declare function pipeK<A, B, Ctx>(fn1: ReaderFn<A, B, Ctx>): (a: A) => (ctx: Ctx) => B;
+declare function pipeK<A, B, C, Ctx>(fn1: ReaderFn<A, B, Ctx>, fn2: ReaderFn<B, C, Ctx>): (a: A) => (ctx: Ctx) => C;
+declare function pipeK<A, B, C, D, Ctx>(fn1: ReaderFn<A, B, Ctx>, fn2: ReaderFn<B, C, Ctx>, fn3: ReaderFn<C, D, Ctx>): (a: A) => (ctx: Ctx) => D;
+declare function pipeK<A, B, C, D, E, Ctx>(fn1: ReaderFn<A, B, Ctx>, fn2: ReaderFn<B, C, Ctx>, fn3: ReaderFn<C, D, Ctx>, fn4: ReaderFn<D, E, Ctx>): (a: A) => (ctx: Ctx) => E;
+declare function pipeK<A, B, C, D, E, F, Ctx>(fn1: ReaderFn<A, B, Ctx>, fn2: ReaderFn<B, C, Ctx>, fn3: ReaderFn<C, D, Ctx>, fn4: ReaderFn<D, E, Ctx>, fn5: ReaderFn<E, F, Ctx>): (a: A) => (ctx: Ctx) => F;
+/**
+ * Composes functions that return readers (Kleisli composition, right-to-left).
+ * Each function receives the result of the next and the shared context.
+ *
+ * @example
+ * const withUser = (data) => (ctx) => ({ ...data, user: ctx.user })
+ * const withRole = (data) => (ctx) => ({ ...data, role: ctx.role })
+ *
+ * const process = composeK(withRole, withUser)  // right-to-left
+ * process({})({ user: 'alice', role: 'admin' })
+ * // { user: 'alice', role: 'admin' }
+ */
+declare function composeK<A, B, Ctx>(fn1: ReaderFn<A, B, Ctx>): (a: A) => (ctx: Ctx) => B;
+declare function composeK<A, B, C, Ctx>(fn2: ReaderFn<B, C, Ctx>, fn1: ReaderFn<A, B, Ctx>): (a: A) => (ctx: Ctx) => C;
+declare function composeK<A, B, C, D, Ctx>(fn3: ReaderFn<C, D, Ctx>, fn2: ReaderFn<B, C, Ctx>, fn1: ReaderFn<A, B, Ctx>): (a: A) => (ctx: Ctx) => D;
+declare function composeK<A, B, C, D, E, Ctx>(fn4: ReaderFn<D, E, Ctx>, fn3: ReaderFn<C, D, Ctx>, fn2: ReaderFn<B, C, Ctx>, fn1: ReaderFn<A, B, Ctx>): (a: A) => (ctx: Ctx) => E;
+declare function composeK<A, B, C, D, E, F, Ctx>(fn5: ReaderFn<E, F, Ctx>, fn4: ReaderFn<D, E, Ctx>, fn3: ReaderFn<C, D, Ctx>, fn2: ReaderFn<B, C, Ctx>, fn1: ReaderFn<A, B, Ctx>): (a: A) => (ctx: Ctx) => F;
+
+/**
+ * Creates local bindings for use in a body expression.
+ *
+ * `letIn` allows defining intermediate values that can depend on each other,
+ * then using them in a final expression. Similar to `let...in` from functional
+ * languages like Haskell or Clojure's `let`.
+ *
+ * The bindings are evaluated in order, so later bindings can reference
+ * earlier ones through the accumulated context.
+ *
+ * @param bindings - Object where keys are binding names and values are functions
+ *                   that receive the accumulated context and return the binding value
+ * @param body - Function that receives the final context (data + all bindings)
+ *               and returns the result
+ * @param data - The input data
+ * @returns The result of the body function
+ *
+ * @example
+ * ```ts
+ * // Basic usage - calculate average
+ * const data = { items: [10, 20, 30, 40] };
+ *
+ * letIn(
+ *   {
+ *     total: ctx => sum(ctx.items),
+ *     count: ctx => length(ctx.items)
+ *   },
+ *   ctx => divide(ctx.total, ctx.count),
+ *   data
+ * );
+ * // 25
+ *
+ * // Curried - create reusable function
+ * const calcAverage = letIn(
+ *   {
+ *     total: pipe(prop('items'), sum),
+ *     count: pipe(prop('items'), length)
+ *   },
+ *   ctx => divide(ctx.total, ctx.count)
+ * );
+ *
+ * calcAverage({ items: [1, 2, 3] });  // 2
+ *
+ * // Dependent bindings - each can use previous
+ * letIn(
+ *   {
+ *     items: ctx => ctx.cart.items,
+ *     prices: ctx => pluck('price', ctx.items),
+ *     total: ctx => sum(ctx.prices),
+ *     count: ctx => length(ctx.prices),
+ *     average: ctx => divide(ctx.total, ctx.count)
+ *   },
+ *   ctx => ctx.average,
+ *   { cart: { items: [{ price: 10 }, { price: 20 }] } }
+ * );
+ * // 15
+ *
+ * // In a pipe
+ * pipe(
+ *   data,
+ *   letIn(
+ *     { doubled: ctx => map(multiply(2), ctx.values) },
+ *     ctx => sum(ctx.doubled)
+ *   )
+ * );
+ * ```
+ */
+type BindingFn = (ctx: any) => unknown;
+type Bindings = Record<string, BindingFn>;
+type BodyFn<R> = (ctx: any) => R;
+declare function letIn<R>(bindings: Bindings, body: BodyFn<R>, data: object): R;
+declare function letIn<R>(bindings: Bindings, body: BodyFn<R>): (data: object) => R;
+declare function letIn(bindings: Bindings): {
+    <R>(body: BodyFn<R>, data: object): R;
+    <R>(body: BodyFn<R>): (data: object) => R;
+};
+
+/**
+ * @internal
+ * Placeholder symbol for curried function arguments.
+ *
+ * The placeholder allows "skipping" arguments when partially applying
+ * curried functions, enabling flexible argument ordering.
+ *
+ * @example
+ * ```ts
+ * import { __, subtract } from '@statedelta-libs/operators';
+ *
+ * const subtractFrom10 = subtract(__, 10); // (a) => a - 10
+ * subtractFrom10(15); // 5
+ * ```
+ */
+
+/**
+ * The placeholder object used in curried functions.
+ * Marked with a unique symbol and a branded type for type safety.
+ */
+declare const placeholder: Placeholder;
+/**
+ * Checks if a value is the placeholder.
+ *
+ * @param value - The value to check
+ * @returns True if the value is the placeholder
+ */
+declare function isPlaceholder(value: unknown): value is Placeholder;
+
+/**
+ * Map operator - transforms each element of an array.
+ *
+ * @module
+ */
+/**
+ * Applies a function to each element of an array and returns a new array
+ * with the results.
+ *
+ * This is a curried version of Array.prototype.map.
+ *
+ * @param fn - The function to apply to each element
+ * @param arr - The array to map over
+ * @returns A new array with the mapped values
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * map(x => x * 2, [1, 2, 3]);  // [2, 4, 6]
+ *
+ * // Curried usage
+ * const double = map((x: number) => x * 2);
+ * double([1, 2, 3]);  // [2, 4, 6]
+ *
+ * // With index
+ * map((x, i) => `${i}: ${x}`, ['a', 'b', 'c']);  // ['0: a', '1: b', '2: c']
+ * ```
+ */
+declare const map: {
+    <T, U>(fn: (value: T, index: number, array: readonly T[]) => U, arr: readonly T[]): U[];
+    <T, U>(fn: (value: T, index: number, array: readonly T[]) => U): (arr: readonly T[]) => U[];
+};
+
+/**
+ * Filter and reject operators - filter elements of an array.
+ *
+ * @module
+ */
+/**
+ * Returns a new array containing only elements that satisfy the predicate.
+ *
+ * This is a curried version of Array.prototype.filter.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to filter
+ * @returns A new array with elements that pass the predicate
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * filter(x => x > 2, [1, 2, 3, 4, 5]);  // [3, 4, 5]
+ *
+ * // Curried usage
+ * const positives = filter((x: number) => x > 0);
+ * positives([-1, 2, -3, 4]);  // [2, 4]
+ *
+ * // With type guard
+ * filter((x): x is number => typeof x === 'number', [1, 'a', 2, 'b']);  // [1, 2]
+ * ```
+ */
+declare const filter: {
+    <T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S, arr: readonly T[]): S[];
+    <T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T[];
+    <T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S): (arr: readonly T[]) => S[];
+    <T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
+};
+/**
+ * Returns a new array containing only elements that do NOT satisfy the predicate.
+ * This is the complement of `filter`.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to filter
+ * @returns A new array with elements that fail the predicate
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * reject(x => x > 2, [1, 2, 3, 4, 5]);  // [1, 2]
+ *
+ * // Curried usage
+ * const nonPositives = reject((x: number) => x > 0);
+ * nonPositives([-1, 2, -3, 4]);  // [-1, -3]
+ * ```
+ */
+declare const reject: {
+    <T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T[];
+    <T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
+};
+
+/**
+ * Reduce operators - fold an array into a single value.
+ *
+ * @module
+ */
+/**
+ * Reduces an array to a single value by applying a function to each element
+ * from left to right.
+ *
+ * This is a curried version of Array.prototype.reduce.
+ *
+ * @param fn - The reducer function (accumulator, value, index, array) => newAccumulator
+ * @param init - The initial accumulator value
+ * @param arr - The array to reduce
+ * @returns The final accumulated value
+ *
+ * @example
+ * ```ts
+ * // Sum
+ * reduce((acc, x) => acc + x, 0, [1, 2, 3, 4]);  // 10
+ *
+ * // Curried usage
+ * const sum = reduce((acc: number, x: number) => acc + x, 0);
+ * sum([1, 2, 3, 4]);  // 10
+ *
+ * // Build object
+ * reduce(
+ *   (acc, x) => ({ ...acc, [x.id]: x }),
+ *   {},
+ *   [{ id: 'a', val: 1 }, { id: 'b', val: 2 }]
+ * );
+ * // { a: { id: 'a', val: 1 }, b: { id: 'b', val: 2 } }
+ * ```
+ */
+declare const reduce: {
+    <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U, arr: readonly T[]): U;
+    <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U): (arr: readonly T[]) => U;
+    <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U): {
+        (init: U, arr: readonly T[]): U;
+        (init: U): (arr: readonly T[]) => U;
+    };
+};
+/**
+ * Reduces an array to a single value by applying a function to each element
+ * from right to left.
+ *
+ * This is a curried version of Array.prototype.reduceRight.
+ *
+ * @param fn - The reducer function (accumulator, value, index, array) => newAccumulator
+ * @param init - The initial accumulator value
+ * @param arr - The array to reduce
+ * @returns The final accumulated value
+ *
+ * @example
+ * ```ts
+ * // Right to left concatenation
+ * reduceRight((acc, x) => acc + x, '', ['a', 'b', 'c']);  // 'cba'
+ *
+ * // Curried usage
+ * const reverseConcat = reduceRight((acc: string, x: string) => acc + x, '');
+ * reverseConcat(['a', 'b', 'c']);  // 'cba'
+ * ```
+ */
+declare const reduceRight: {
+    <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U, arr: readonly T[]): U;
+    <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U): (arr: readonly T[]) => U;
+    <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U): {
+        (init: U, arr: readonly T[]): U;
+        (init: U): (arr: readonly T[]) => U;
+    };
+};
+
+/**
+ * Slice operators - extract portions of arrays.
+ *
+ * @module
+ */
+/**
+ * Returns the first element of an array, or undefined if empty.
+ *
+ * @param arr - The array
+ * @returns The first element or undefined
+ *
+ * @example
+ * ```ts
+ * head([1, 2, 3]);  // 1
+ * head([]);          // undefined
+ * head('abc');       // 'a'
+ * ```
+ */
+declare function head<T>(arr: readonly T[]): T | undefined;
+declare function head(str: string): string;
+/**
+ * Returns all elements except the first.
+ *
+ * @param arr - The array
+ * @returns A new array without the first element
+ *
+ * @example
+ * ```ts
+ * tail([1, 2, 3]);  // [2, 3]
+ * tail([1]);         // []
+ * tail([]);          // []
+ * ```
+ */
+declare function tail<T>(arr: readonly T[]): T[];
+/**
+ * Returns the last element of an array, or undefined if empty.
+ *
+ * @param arr - The array
+ * @returns The last element or undefined
+ *
+ * @example
+ * ```ts
+ * last([1, 2, 3]);  // 3
+ * last([]);          // undefined
+ * last('abc');       // 'c'
+ * ```
+ */
+declare function last<T>(arr: readonly T[]): T | undefined;
+declare function last(str: string): string;
+/**
+ * Returns all elements except the last.
+ *
+ * @param arr - The array
+ * @returns A new array without the last element
+ *
+ * @example
+ * ```ts
+ * init([1, 2, 3]);  // [1, 2]
+ * init([1]);         // []
+ * init([]);          // []
+ * ```
+ */
+declare function init<T>(arr: readonly T[]): T[];
+/**
+ * Returns the element at the specified index.
+ * Supports negative indices (from end).
+ *
+ * @param n - The index (can be negative)
+ * @param arr - The array
+ * @returns The element at index or undefined
+ *
+ * @example
+ * ```ts
+ * nth(2, [1, 2, 3, 4]);   // 3
+ * nth(-1, [1, 2, 3, 4]);  // 4
+ * nth(10, [1, 2, 3]);     // undefined
+ *
+ * // Curried
+ * const second = nth(1);
+ * second([1, 2, 3]);      // 2
+ * ```
+ */
+declare function nth<T>(n: number, arr: readonly T[]): T | undefined;
+declare function nth(n: number): <T>(arr: readonly T[]) => T | undefined;
+/**
+ * Returns the first n elements of an array.
+ *
+ * @param n - The number of elements to take
+ * @param arr - The array
+ * @returns A new array with the first n elements
+ *
+ * @example
+ * ```ts
+ * take(3, [1, 2, 3, 4, 5]);  // [1, 2, 3]
+ * take(10, [1, 2]);           // [1, 2]
+ * take(0, [1, 2, 3]);         // []
+ *
+ * // Curried
+ * const take3 = take(3);
+ * take3([1, 2, 3, 4, 5]);     // [1, 2, 3]
+ * ```
+ */
+declare function take<T>(n: number, arr: readonly T[]): T[];
+declare function take(n: number): <T>(arr: readonly T[]) => T[];
+/**
+ * Returns the last n elements of an array.
+ *
+ * @param n - The number of elements to take
+ * @param arr - The array
+ * @returns A new array with the last n elements
+ *
+ * @example
+ * ```ts
+ * takeLast(3, [1, 2, 3, 4, 5]);  // [3, 4, 5]
+ * takeLast(10, [1, 2]);           // [1, 2]
+ * takeLast(0, [1, 2, 3]);         // []
+ *
+ * // Curried
+ * const takeLast2 = takeLast(2);
+ * takeLast2([1, 2, 3, 4, 5]);     // [4, 5]
+ * ```
+ */
+declare function takeLast<T>(n: number, arr: readonly T[]): T[];
+declare function takeLast(n: number): <T>(arr: readonly T[]) => T[];
+/**
+ * Returns elements from the start while the predicate returns true.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array
+ * @returns A new array with elements taken while predicate is true
+ *
+ * @example
+ * ```ts
+ * takeWhile(x => x < 4, [1, 2, 3, 4, 5, 1]);  // [1, 2, 3]
+ *
+ * // Curried
+ * const takePositive = takeWhile((x: number) => x > 0);
+ * takePositive([1, 2, -1, 3]);  // [1, 2]
+ * ```
+ */
+declare function takeWhile<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T[];
+declare function takeWhile<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
+/**
+ * Returns all elements after the first n elements.
+ *
+ * @param n - The number of elements to drop
+ * @param arr - The array
+ * @returns A new array without the first n elements
+ *
+ * @example
+ * ```ts
+ * drop(3, [1, 2, 3, 4, 5]);  // [4, 5]
+ * drop(10, [1, 2]);           // []
+ * drop(0, [1, 2, 3]);         // [1, 2, 3]
+ *
+ * // Curried
+ * const drop2 = drop(2);
+ * drop2([1, 2, 3, 4, 5]);     // [3, 4, 5]
+ * ```
+ */
+declare function drop<T>(n: number, arr: readonly T[]): T[];
+declare function drop(n: number): <T>(arr: readonly T[]) => T[];
+/**
+ * Returns all elements except the last n elements.
+ *
+ * @param n - The number of elements to drop from the end
+ * @param arr - The array
+ * @returns A new array without the last n elements
+ *
+ * @example
+ * ```ts
+ * dropLast(3, [1, 2, 3, 4, 5]);  // [1, 2]
+ * dropLast(10, [1, 2]);           // []
+ * dropLast(0, [1, 2, 3]);         // [1, 2, 3]
+ *
+ * // Curried
+ * const dropLast2 = dropLast(2);
+ * dropLast2([1, 2, 3, 4, 5]);     // [1, 2, 3]
+ * ```
+ */
+declare function dropLast<T>(n: number, arr: readonly T[]): T[];
+declare function dropLast(n: number): <T>(arr: readonly T[]) => T[];
+/**
+ * Drops elements from the start while the predicate returns true.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array
+ * @returns A new array with elements dropped while predicate was true
+ *
+ * @example
+ * ```ts
+ * dropWhile(x => x < 4, [1, 2, 3, 4, 5, 1]);  // [4, 5, 1]
+ *
+ * // Curried
+ * const dropNegative = dropWhile((x: number) => x < 0);
+ * dropNegative([-2, -1, 0, 1, 2]);  // [0, 1, 2]
+ * ```
+ */
+declare function dropWhile<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T[];
+declare function dropWhile<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
+/**
+ * Returns a portion of an array from start index to end index (exclusive).
+ * Supports negative indices.
+ *
+ * @param start - The start index (inclusive)
+ * @param end - The end index (exclusive)
+ * @param arr - The array
+ * @returns A new array with the sliced portion
+ *
+ * @example
+ * ```ts
+ * slice(1, 4, [0, 1, 2, 3, 4, 5]);  // [1, 2, 3]
+ * slice(-3, -1, [0, 1, 2, 3, 4]);    // [2, 3]
+ *
+ * // Curried
+ * const middle = slice(1, -1);
+ * middle([0, 1, 2, 3, 4]);           // [1, 2, 3]
+ * ```
+ */
+declare function slice<T>(start: number, end: number, arr: readonly T[]): T[];
+declare function slice(start: number, end: number): <T>(arr: readonly T[]) => T[];
+declare function slice(start: number): {
+    <T>(end: number, arr: readonly T[]): T[];
+    (end: number): <T>(arr: readonly T[]) => T[];
+};
+
+/**
+ * Find operators - search for elements in arrays.
+ *
+ * @module
+ */
+/**
+ * Returns the first element that satisfies the predicate, or undefined.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to search
+ * @returns The first matching element or undefined
+ *
+ * @example
+ * ```ts
+ * find(x => x > 2, [1, 2, 3, 4]);  // 3
+ * find(x => x > 10, [1, 2, 3]);     // undefined
+ *
+ * // Curried
+ * const findEven = find((x: number) => x % 2 === 0);
+ * findEven([1, 3, 4, 5]);           // 4
+ * ```
+ */
+declare function find<T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S, arr: readonly T[]): S | undefined;
+declare function find<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T | undefined;
+declare function find<T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S): (arr: readonly T[]) => S | undefined;
+declare function find<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T | undefined;
+/**
+ * Returns the index of the first element that satisfies the predicate, or -1.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to search
+ * @returns The index of the first match or -1
+ *
+ * @example
+ * ```ts
+ * findIndex(x => x > 2, [1, 2, 3, 4]);  // 2
+ * findIndex(x => x > 10, [1, 2, 3]);     // -1
+ *
+ * // Curried
+ * const findEvenIdx = findIndex((x: number) => x % 2 === 0);
+ * findEvenIdx([1, 3, 4, 5]);             // 2
+ * ```
+ */
+declare function findIndex<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): number;
+declare function findIndex<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => number;
+/**
+ * Returns the last element that satisfies the predicate, or undefined.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to search
+ * @returns The last matching element or undefined
+ *
+ * @example
+ * ```ts
+ * findLast(x => x % 2 === 0, [1, 2, 3, 4, 5]);  // 4
+ * findLast(x => x > 10, [1, 2, 3]);              // undefined
+ *
+ * // Curried
+ * const findLastEven = findLast((x: number) => x % 2 === 0);
+ * findLastEven([1, 2, 3, 4, 5]);                 // 4
+ * ```
+ */
+declare function findLast<T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S, arr: readonly T[]): S | undefined;
+declare function findLast<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T | undefined;
+declare function findLast<T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S): (arr: readonly T[]) => S | undefined;
+declare function findLast<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T | undefined;
+/**
+ * Returns the index of the first occurrence of a value, or -1.
+ * Uses strict equality (===).
+ *
+ * @param value - The value to find
+ * @param arr - The array to search
+ * @returns The index of the value or -1
+ *
+ * @example
+ * ```ts
+ * indexOf(3, [1, 2, 3, 4, 3]);  // 2
+ * indexOf(10, [1, 2, 3]);        // -1
+ *
+ * // Curried
+ * const findThree = indexOf(3);
+ * findThree([1, 2, 3, 4]);       // 2
+ * ```
+ */
+declare function indexOf<T>(value: T, arr: readonly T[]): number;
+declare function indexOf<T>(value: T): (arr: readonly T[]) => number;
+/**
+ * Returns true if the array contains the specified value.
+ * Uses strict equality (===).
+ *
+ * @param value - The value to find
+ * @param arr - The array to search
+ * @returns True if the value is found
+ *
+ * @example
+ * ```ts
+ * includes(3, [1, 2, 3, 4]);  // true
+ * includes(10, [1, 2, 3]);    // false
+ *
+ * // Curried
+ * const hasThree = includes(3);
+ * hasThree([1, 2, 3, 4]);     // true
+ * hasThree([1, 2, 4]);        // false
+ * ```
+ */
+declare function includes<T>(value: T, arr: readonly T[]): boolean;
+declare function includes<T>(value: T): (arr: readonly T[]) => boolean;
+
+/**
+ * Transform operators - advanced array transformations.
+ *
+ * @module
+ */
+/**
+ * Flattens a nested array by one level.
+ *
+ * @param arr - The array to flatten
+ * @returns A new flattened array
+ *
+ * @example
+ * ```ts
+ * flatten([[1, 2], [3, 4], [5]]);  // [1, 2, 3, 4, 5]
+ * flatten([[1, [2]], [3]]);         // [1, [2], 3] (only one level)
+ * flatten([]);                       // []
+ * ```
+ */
+declare function flatten<T>(arr: readonly (T | readonly T[])[]): T[];
+/**
+ * Alias for flatten. Removes one level of nesting.
+ *
+ * @param arr - The array to unnest
+ * @returns A new flattened array
+ *
+ * @example
+ * ```ts
+ * unnest([[1, 2], [3, 4]]);  // [1, 2, 3, 4]
+ * ```
+ */
+declare const unnest: typeof flatten;
+/**
+ * Maps a function over a list and concatenates the results (flatMap).
+ *
+ * @param fn - The function to apply
+ * @param arr - The array to map over
+ * @returns A new flattened array of results
+ *
+ * @example
+ * ```ts
+ * chain(x => [x, x * 2], [1, 2, 3]);  // [1, 2, 2, 4, 3, 6]
+ *
+ * // Curried
+ * const duplicate = chain((x: number) => [x, x]);
+ * duplicate([1, 2, 3]);  // [1, 1, 2, 2, 3, 3]
+ * ```
+ */
+declare function chain<T, U>(fn: (value: T, index: number, array: readonly T[]) => readonly U[], arr: readonly T[]): U[];
+declare function chain<T, U>(fn: (value: T, index: number, array: readonly T[]) => readonly U[]): (arr: readonly T[]) => U[];
+/**
+ * Returns a new array with duplicate values removed.
+ * Uses strict equality (===).
+ *
+ * @param arr - The array to deduplicate
+ * @returns A new array with unique values
+ *
+ * @example
+ * ```ts
+ * uniq([1, 2, 1, 3, 2, 4]);  // [1, 2, 3, 4]
+ * uniq(['a', 'b', 'a']);      // ['a', 'b']
+ * ```
+ */
+declare function uniq<T>(arr: readonly T[]): T[];
+/**
+ * Returns a new array with duplicate values removed based on a key function.
+ *
+ * @param fn - Function to generate the key for comparison
+ * @param arr - The array to deduplicate
+ * @returns A new array with unique values by key
+ *
+ * @example
+ * ```ts
+ * uniqBy(Math.abs, [1, -1, 2, -2, 3]);  // [1, 2, 3]
+ *
+ * // With objects
+ * uniqBy(x => x.id, [{id: 1}, {id: 2}, {id: 1}]);  // [{id: 1}, {id: 2}]
+ *
+ * // Curried
+ * const uniqById = uniqBy((x: {id: number}) => x.id);
+ * ```
+ */
+declare function uniqBy<T, K>(fn: (value: T) => K, arr: readonly T[]): T[];
+declare function uniqBy<T, K>(fn: (value: T) => K): (arr: readonly T[]) => T[];
+/**
+ * Returns a sorted copy of an array using a comparator function.
+ *
+ * @param comparator - Function (a, b) => number for comparison
+ * @param arr - The array to sort
+ * @returns A new sorted array
+ *
+ * @example
+ * ```ts
+ * sort((a, b) => a - b, [3, 1, 4, 1, 5]);  // [1, 1, 3, 4, 5]
+ * sort((a, b) => b - a, [3, 1, 4, 1, 5]);  // [5, 4, 3, 1, 1]
+ *
+ * // Curried
+ * const sortAsc = sort((a: number, b: number) => a - b);
+ * sortAsc([3, 1, 2]);  // [1, 2, 3]
+ * ```
+ */
+declare function sort<T>(comparator: (a: T, b: T) => number, arr: readonly T[]): T[];
+declare function sort<T>(comparator: (a: T, b: T) => number): (arr: readonly T[]) => T[];
+/**
+ * Returns a sorted copy of an array using a function to extract the sort key.
+ *
+ * @param fn - Function to extract the sort key
+ * @param arr - The array to sort
+ * @returns A new sorted array
+ *
+ * @example
+ * ```ts
+ * sortBy(x => x.age, [{name: 'Bob', age: 30}, {name: 'Alice', age: 25}]);
+ * // [{name: 'Alice', age: 25}, {name: 'Bob', age: 30}]
+ *
+ * sortBy(x => x.length, ['aaa', 'a', 'aa']);  // ['a', 'aa', 'aaa']
+ *
+ * // Curried
+ * const sortByAge = sortBy((x: {age: number}) => x.age);
+ * ```
+ */
+declare function sortBy<T, U extends number | string>(fn: (value: T) => U, arr: readonly T[]): T[];
+declare function sortBy<T, U extends number | string>(fn: (value: T) => U): (arr: readonly T[]) => T[];
+/**
+ * Returns a new array with elements in reverse order.
+ *
+ * @param arr - The array to reverse
+ * @returns A new reversed array
+ *
+ * @example
+ * ```ts
+ * reverse([1, 2, 3]);  // [3, 2, 1]
+ * reverse('abc');       // ['c', 'b', 'a']
+ * ```
+ */
+declare function reverse<T>(arr: readonly T[]): T[];
+/**
+ * Groups array elements by a key function.
+ *
+ * @param fn - Function to generate the grouping key
+ * @param arr - The array to group
+ * @returns An object with keys and grouped arrays
+ *
+ * @example
+ * ```ts
+ * groupBy(x => x.type, [
+ *   {type: 'a', val: 1},
+ *   {type: 'b', val: 2},
+ *   {type: 'a', val: 3}
+ * ]);
+ * // { a: [{type:'a',val:1}, {type:'a',val:3}], b: [{type:'b',val:2}] }
+ *
+ * groupBy(x => x % 2 === 0 ? 'even' : 'odd', [1, 2, 3, 4, 5]);
+ * // { odd: [1, 3, 5], even: [2, 4] }
+ *
+ * // Curried
+ * const groupByType = groupBy((x: {type: string}) => x.type);
+ * ```
+ */
+declare function groupBy<T, K extends string | number>(fn: (value: T) => K, arr: readonly T[]): Record<K, T[]>;
+declare function groupBy<T, K extends string | number>(fn: (value: T) => K): (arr: readonly T[]) => Record<K, T[]>;
+
+/**
+ * Combine operators - combine and merge arrays.
+ *
+ * @module
+ */
+/**
+ * Concatenates two arrays.
+ *
+ * @param arr1 - The first array
+ * @param arr2 - The second array
+ * @returns A new concatenated array
+ *
+ * @example
+ * ```ts
+ * concat([1, 2], [3, 4]);  // [1, 2, 3, 4]
+ * concat([], [1, 2]);       // [1, 2]
+ *
+ * // Curried
+ * const prependAB = concat(['a', 'b']);
+ * prependAB(['c', 'd']);    // ['a', 'b', 'c', 'd']
+ * ```
+ */
+declare function concat<T>(arr1: readonly T[], arr2: readonly T[]): T[];
+declare function concat<T>(arr1: readonly T[]): (arr2: readonly T[]) => T[];
+/**
+ * Adds an element to the end of an array.
+ *
+ * @param value - The value to append
+ * @param arr - The array
+ * @returns A new array with the value appended
+ *
+ * @example
+ * ```ts
+ * append(4, [1, 2, 3]);  // [1, 2, 3, 4]
+ * append('d', ['a', 'b', 'c']);  // ['a', 'b', 'c', 'd']
+ *
+ * // Curried
+ * const addZero = append(0);
+ * addZero([1, 2, 3]);  // [1, 2, 3, 0]
+ * ```
+ */
+declare function append<T>(value: T, arr: readonly T[]): T[];
+declare function append<T>(value: T): (arr: readonly T[]) => T[];
+/**
+ * Adds an element to the beginning of an array.
+ *
+ * @param value - The value to prepend
+ * @param arr - The array
+ * @returns A new array with the value prepended
+ *
+ * @example
+ * ```ts
+ * prepend(0, [1, 2, 3]);  // [0, 1, 2, 3]
+ * prepend('a', ['b', 'c']);  // ['a', 'b', 'c']
+ *
+ * // Curried
+ * const addZero = prepend(0);
+ * addZero([1, 2, 3]);  // [0, 1, 2, 3]
+ * ```
+ */
+declare function prepend<T>(value: T, arr: readonly T[]): T[];
+declare function prepend<T>(value: T): (arr: readonly T[]) => T[];
+/**
+ * Creates pairs from two arrays.
+ *
+ * @param arr1 - The first array
+ * @param arr2 - The second array
+ * @returns An array of pairs
+ *
+ * @example
+ * ```ts
+ * zip([1, 2, 3], ['a', 'b', 'c']);  // [[1, 'a'], [2, 'b'], [3, 'c']]
+ * zip([1, 2], ['a', 'b', 'c']);      // [[1, 'a'], [2, 'b']] (truncates to shorter)
+ *
+ * // Curried
+ * const zipWithNumbers = zip([1, 2, 3]);
+ * zipWithNumbers(['a', 'b', 'c']);  // [[1, 'a'], [2, 'b'], [3, 'c']]
+ * ```
+ */
+declare function zip<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][];
+declare function zip<T>(arr1: readonly T[]): <U>(arr2: readonly U[]) => [T, U][];
+/**
+ * Combines two arrays using a function.
+ *
+ * @param fn - The combining function
+ * @param arr1 - The first array
+ * @param arr2 - The second array
+ * @returns An array of combined values
+ *
+ * @example
+ * ```ts
+ * zipWith((a, b) => a + b, [1, 2, 3], [10, 20, 30]);  // [11, 22, 33]
+ * zipWith((a, b) => a * b, [1, 2], [3, 4]);            // [3, 8]
+ *
+ * // Curried
+ * const addPairs = zipWith((a: number, b: number) => a + b);
+ * addPairs([1, 2, 3], [10, 20, 30]);  // [11, 22, 33]
+ * ```
+ */
+declare function zipWith<T, U, R>(fn: (a: T, b: U) => R, arr1: readonly T[], arr2: readonly U[]): R[];
+declare function zipWith<T, U, R>(fn: (a: T, b: U) => R, arr1: readonly T[]): (arr2: readonly U[]) => R[];
+declare function zipWith<T, U, R>(fn: (a: T, b: U) => R): {
+    (arr1: readonly T[], arr2: readonly U[]): R[];
+    (arr1: readonly T[]): (arr2: readonly U[]) => R[];
+};
+/**
+ * Creates an object from arrays of keys and values.
+ *
+ * @param keys - The array of keys
+ * @param values - The array of values
+ * @returns An object mapping keys to values
+ *
+ * @example
+ * ```ts
+ * zipObj(['a', 'b', 'c'], [1, 2, 3]);  // { a: 1, b: 2, c: 3 }
+ * zipObj(['x', 'y'], [10, 20, 30]);     // { x: 10, y: 20 } (truncates)
+ *
+ * // Curried
+ * const createObj = zipObj(['name', 'age']);
+ * createObj(['Alice', 30]);  // { name: 'Alice', age: 30 }
+ * ```
+ */
+declare function zipObj<K extends string | number, V>(keys: readonly K[], values: readonly V[]): Record<K, V>;
+declare function zipObj<K extends string | number>(keys: readonly K[]): <V>(values: readonly V[]) => Record<K, V>;
+
+/**
+ * Predicate operators - test arrays against conditions.
+ *
+ * @module
+ */
+/**
+ * Returns true if at least one element satisfies the predicate.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to test
+ * @returns True if any element passes the predicate
+ *
+ * @example
+ * ```ts
+ * some(x => x > 3, [1, 2, 3, 4, 5]);  // true
+ * some(x => x > 10, [1, 2, 3]);        // false
+ * some(x => x > 0, []);                // false (empty array)
+ *
+ * // Curried
+ * const hasNegative = some((x: number) => x < 0);
+ * hasNegative([1, -2, 3]);  // true
+ * hasNegative([1, 2, 3]);   // false
+ * ```
+ */
+declare function some<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): boolean;
+declare function some<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => boolean;
+/**
+ * Returns true if all elements satisfy the predicate.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to test
+ * @returns True if all elements pass the predicate
+ *
+ * @example
+ * ```ts
+ * every(x => x > 0, [1, 2, 3]);  // true
+ * every(x => x > 0, [1, -2, 3]); // false
+ * every(x => x > 0, []);          // true (vacuous truth)
+ *
+ * // Curried
+ * const allPositive = every((x: number) => x > 0);
+ * allPositive([1, 2, 3]);  // true
+ * allPositive([1, -2, 3]); // false
+ * ```
+ */
+declare function every<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): boolean;
+declare function every<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => boolean;
+/**
+ * Returns true if no elements satisfy the predicate.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to test
+ * @returns True if no elements pass the predicate
+ *
+ * @example
+ * ```ts
+ * none(x => x < 0, [1, 2, 3]);  // true
+ * none(x => x < 0, [1, -2, 3]); // false
+ * none(x => x > 0, []);          // true (empty array)
+ *
+ * // Curried
+ * const noNegatives = none((x: number) => x < 0);
+ * noNegatives([1, 2, 3]);  // true
+ * noNegatives([1, -2, 3]); // false
+ * ```
+ */
+declare function none<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): boolean;
+declare function none<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => boolean;
+
+/**
+ * Aggregate operators - compute values from arrays.
+ *
+ * @module
+ */
+/**
+ * Returns the length of an array or string.
+ *
+ * @param arr - The array or string
+ * @returns The length
+ *
+ * @example
+ * ```ts
+ * length([1, 2, 3]);  // 3
+ * length('hello');     // 5
+ * length([]);          // 0
+ * ```
+ */
+declare function length(arr: readonly unknown[] | string): number;
+/**
+ * Returns the sum of all numbers in an array.
+ *
+ * @param arr - The array of numbers
+ * @returns The sum
+ *
+ * @example
+ * ```ts
+ * sum([1, 2, 3, 4]);  // 10
+ * sum([]);             // 0
+ * sum([5]);            // 5
+ * ```
+ */
+declare function sum(arr: readonly number[]): number;
+/**
+ * Returns the product of all numbers in an array.
+ *
+ * @param arr - The array of numbers
+ * @returns The product
+ *
+ * @example
+ * ```ts
+ * product([1, 2, 3, 4]);  // 24
+ * product([]);             // 1 (identity for multiplication)
+ * product([5]);            // 5
+ * ```
+ */
+declare function product(arr: readonly number[]): number;
+/**
+ * Returns the arithmetic mean (average) of an array of numbers.
+ *
+ * @param arr - The array of numbers
+ * @returns The mean, or NaN for empty arrays
+ *
+ * @example
+ * ```ts
+ * mean([1, 2, 3, 4, 5]);  // 3
+ * mean([10, 20]);          // 15
+ * mean([]);                // NaN
+ * ```
+ */
+declare function mean(arr: readonly number[]): number;
+/**
+ * Returns the median of an array of numbers.
+ * For even-length arrays, returns the average of the two middle values.
+ *
+ * @param arr - The array of numbers
+ * @returns The median, or NaN for empty arrays
+ *
+ * @example
+ * ```ts
+ * median([1, 2, 3, 4, 5]);  // 3
+ * median([1, 2, 3, 4]);      // 2.5
+ * median([7, 1, 3]);         // 3
+ * median([]);                // NaN
+ * ```
+ */
+declare function median(arr: readonly number[]): number;
+/**
+ * Returns the minimum value in an array.
+ *
+ * @param arr - The array of numbers
+ * @returns The minimum value, or Infinity for empty arrays
+ *
+ * @example
+ * ```ts
+ * min([3, 1, 4, 1, 5]);  // 1
+ * min([-1, -5, -2]);      // -5
+ * min([]);                // Infinity
+ * ```
+ */
+declare function min(arr: readonly number[]): number;
+/**
+ * Returns the maximum value in an array.
+ *
+ * @param arr - The array of numbers
+ * @returns The maximum value, or -Infinity for empty arrays
+ *
+ * @example
+ * ```ts
+ * max([3, 1, 4, 1, 5]);  // 5
+ * max([-1, -5, -2]);      // -1
+ * max([]);                // -Infinity
+ * ```
+ */
+declare function max(arr: readonly number[]): number;
+/**
+ * Counts elements by a key function.
+ *
+ * @param fn - Function to generate the counting key
+ * @param arr - The array to count
+ * @returns An object with keys and their counts
+ *
+ * @example
+ * ```ts
+ * countBy(x => x.type, [
+ *   {type: 'a'}, {type: 'b'}, {type: 'a'}
+ * ]);
+ * // { a: 2, b: 1 }
+ *
+ * countBy(Math.floor, [1.1, 2.2, 2.8, 3.1]);
+ * // { '1': 1, '2': 2, '3': 1 }
+ *
+ * // Curried
+ * const countByLength = countBy((s: string) => s.length);
+ * countByLength(['a', 'bb', 'ccc', 'dd']);  // { '1': 1, '2': 2, '3': 1 }
+ * ```
+ */
+declare function countBy<T, K extends string | number>(fn: (value: T) => K, arr: readonly T[]): Record<K, number>;
+declare function countBy<T, K extends string | number>(fn: (value: T) => K): (arr: readonly T[]) => Record<K, number>;
+
+/**
+ * Partition operators - split and generate arrays.
+ *
+ * @module
+ */
+/**
+ * Generates an array of numbers from start (inclusive) to end (exclusive).
+ *
+ * @param start - The starting number (inclusive)
+ * @param end - The ending number (exclusive)
+ * @returns An array of numbers
+ *
+ * @example
+ * ```ts
+ * range(1, 5);   // [1, 2, 3, 4]
+ * range(0, 3);   // [0, 1, 2]
+ * range(5, 5);   // []
+ * range(3, 1);   // [] (start > end)
+ * ```
+ */
+declare function range(start: number, end: number): number[];
+declare function range(start: number): (end: number) => number[];
+/**
+ * Splits an array into two groups based on a predicate.
+ * Returns [passing, failing] arrays.
+ *
+ * @param pred - The predicate function
+ * @param arr - The array to partition
+ * @returns A tuple of [elements that pass, elements that fail]
+ *
+ * @example
+ * ```ts
+ * partition(x => x > 0, [-1, 2, -3, 4]);
+ * // [[2, 4], [-1, -3]]
+ *
+ * partition(x => x % 2 === 0, [1, 2, 3, 4, 5]);
+ * // [[2, 4], [1, 3, 5]]
+ *
+ * // Curried
+ * const splitBySign = partition((x: number) => x >= 0);
+ * splitBySign([-1, 2, -3, 4]);  // [[2, 4], [-1, -3]]
+ * ```
+ */
+declare function partition<T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): [T[], T[]];
+declare function partition<T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => [T[], T[]];
+/**
+ * Splits an array into chunks of a specified size.
+ *
+ * @param n - The chunk size
+ * @param arr - The array to split
+ * @returns An array of chunks
+ *
+ * @example
+ * ```ts
+ * splitEvery(2, [1, 2, 3, 4, 5]);  // [[1, 2], [3, 4], [5]]
+ * splitEvery(3, [1, 2, 3, 4, 5]);  // [[1, 2, 3], [4, 5]]
+ * splitEvery(5, [1, 2, 3]);         // [[1, 2, 3]]
+ *
+ * // Curried
+ * const pairs = splitEvery(2);
+ * pairs([1, 2, 3, 4]);  // [[1, 2], [3, 4]]
+ * ```
+ */
+declare function splitEvery<T>(n: number, arr: readonly T[]): T[][];
+declare function splitEvery(n: number): <T>(arr: readonly T[]) => T[][];
+/**
+ * Creates an object from an array, indexed by a key function.
+ * If multiple items have the same key, the last one wins.
+ *
+ * @param fn - Function to generate the key for each element
+ * @param arr - The array to index
+ * @returns An object mapping keys to elements
+ *
+ * @example
+ * ```ts
+ * indexBy(x => x.id, [
+ *   { id: 'a', val: 1 },
+ *   { id: 'b', val: 2 }
+ * ]);
+ * // { a: { id: 'a', val: 1 }, b: { id: 'b', val: 2 } }
+ *
+ * // Curried
+ * const byId = indexBy((x: {id: string}) => x.id);
+ * byId([{ id: 'x', name: 'Item X' }]);  // { x: { id: 'x', name: 'Item X' } }
+ * ```
+ */
+declare function indexBy<T, K extends string | number>(fn: (value: T) => K, arr: readonly T[]): Record<K, T>;
+declare function indexBy<T, K extends string | number>(fn: (value: T) => K): (arr: readonly T[]) => Record<K, T>;
+
+/**
+ * Object access operators
+ * @module object/access
+ */
+declare function prop<K extends string>(key: K): <T extends Record<K, unknown>>(obj: T) => T[K];
+declare function prop<T, K extends keyof T>(key: K, obj: T): T[K];
+declare function path<T = unknown>(keys: readonly (string | number)[]): (obj: unknown) => T | undefined;
+declare function path<T = unknown>(keys: readonly (string | number)[], obj: unknown): T | undefined;
+declare function propOr<D>(defaultValue: D): {
+    <K extends string>(key: K): <T extends Record<K, unknown>>(obj: T) => T[K] | D;
+    <K extends string, T extends Record<K, unknown>>(key: K, obj: T): T[K] | D;
+};
+declare function propOr<D, K extends string>(defaultValue: D, key: K): <T extends Record<K, unknown>>(obj: T) => T[K] | D;
+declare function propOr<D, K extends keyof T, T>(defaultValue: D, key: K, obj: T): T[K] | D;
+declare function pathOr<D>(defaultValue: D): {
+    (keys: readonly (string | number)[]): (obj: unknown) => unknown | D;
+    (keys: readonly (string | number)[], obj: unknown): unknown | D;
+};
+declare function pathOr<D>(defaultValue: D, keys: readonly (string | number)[]): (obj: unknown) => unknown | D;
+declare function pathOr<D>(defaultValue: D, keys: readonly (string | number)[], obj: unknown): unknown | D;
+declare function props<K extends string>(keys: readonly K[]): <T extends Record<K, unknown>>(obj: T) => T[K][];
+declare function props<T, K extends keyof T>(keys: readonly K[], obj: T): T[K][];
+declare function pluck<K extends string>(key: K): <T extends Record<K, unknown>>(arr: readonly T[]) => T[K][];
+declare function pluck<T, K extends keyof T>(key: K, arr: readonly T[]): T[K][];
+
+/**
+ * Object transform operators
+ * @module object/transform
+ */
+declare function assoc<K extends string>(key: K): {
+    <V>(val: V): <T extends Record<string, unknown>>(obj: T) => T & Record<K, V>;
+    <V, T extends Record<string, unknown>>(val: V, obj: T): T & Record<K, V>;
+};
+declare function assoc<K extends string, V>(key: K, val: V): <T extends Record<string, unknown>>(obj: T) => T & Record<K, V>;
+declare function assoc<K extends string, V, T extends Record<string, unknown>>(key: K, val: V, obj: T): T & Record<K, V>;
+declare function assocPath(keys: readonly (string | number)[]): {
+    <V>(val: V): (obj: unknown) => unknown;
+    <V>(val: V, obj: unknown): unknown;
+};
+declare function assocPath<V>(keys: readonly (string | number)[], val: V): (obj: unknown) => unknown;
+declare function assocPath<V>(keys: readonly (string | number)[], val: V, obj: unknown): unknown;
+declare function dissoc<K extends string>(key: K): <T extends Record<string, unknown>>(obj: T) => Omit<T, K>;
+declare function dissoc<K extends string, T extends Record<string, unknown>>(key: K, obj: T): Omit<T, K>;
+declare function dissocPath(keys: readonly (string | number)[]): (obj: unknown) => unknown;
+declare function dissocPath(keys: readonly (string | number)[], obj: unknown): unknown;
+declare function pick<K extends string>(keys: readonly K[]): <T extends Record<K, unknown>>(obj: T) => Pick<T, K>;
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(keys: readonly K[], obj: T): Pick<T, K>;
+declare function omit<K extends string>(keys: readonly K[]): <T extends Record<string, unknown>>(obj: T) => Omit<T, K>;
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(keys: readonly K[], obj: T): Omit<T, K>;
+declare function merge<T extends Record<string, unknown>>(left: T): <U extends Record<string, unknown>>(right: U) => T & U;
+declare function merge<T extends Record<string, unknown>, U extends Record<string, unknown>>(left: T, right: U): T & U;
+declare function mergeDeep<T extends Record<string, unknown>>(left: T): <U extends Record<string, unknown>>(right: U) => T & U;
+declare function mergeDeep<T extends Record<string, unknown>, U extends Record<string, unknown>>(left: T, right: U): T & U;
+type Evolver<T> = {
+    [K in keyof T]?: T[K] extends Record<string, unknown> ? Evolver<T[K]> | ((val: T[K]) => T[K]) : (val: T[K]) => T[K];
+};
+declare function evolve<T extends Record<string, unknown>>(spec: Evolver<T>): (obj: T) => T;
+declare function evolve<T extends Record<string, unknown>>(spec: Evolver<T>, obj: T): T;
+type SpecValue = ((...args: any[]) => any) | {
+    [key: string]: SpecValue;
+};
+declare function applySpec<R extends Record<string, any>>(spec: {
+    [K in keyof R]: SpecValue;
+}): (...args: unknown[]) => R;
+type ExtendSpec = Record<string, (obj: any) => unknown>;
+/**
+ * Extends an object with computed properties.
+ *
+ * Unlike `evolve` which transforms existing properties,
+ * `extend` adds NEW properties computed from the object.
+ *
+ * @example
+ * ```ts
+ * const user = { first: 'John', last: 'Doe', age: 25 };
+ *
+ * extend({
+ *   fullName: ctx => `${ctx.first} ${ctx.last}`,
+ *   isAdult: ctx => ctx.age >= 18
+ * }, user);
+ * // { first: 'John', last: 'Doe', age: 25, fullName: 'John Doe', isAdult: true }
+ *
+ * // Curried
+ * const withFullName = extend({
+ *   fullName: ctx => `${ctx.first} ${ctx.last}`
+ * });
+ * withFullName(user);
+ * ```
+ */
+declare function extend<S extends ExtendSpec>(spec: S): <T extends Record<string, unknown>>(obj: T) => T & {
+    [K in keyof S]: ReturnType<S[K]>;
+};
+declare function extend<T extends Record<string, unknown>, S extends ExtendSpec>(spec: S, obj: T): T & {
+    [K in keyof S]: ReturnType<S[K]>;
+};
+
+/**
+ * Object conversion operators
+ * @module object/conversion
+ */
+declare function keys<T extends Record<string, unknown>>(obj: T): (keyof T)[];
+declare function values<T extends Record<string, unknown>>(obj: T): T[keyof T][];
+declare function entries<T extends Record<string, unknown>>(obj: T): [keyof T, T[keyof T]][];
+declare function fromEntries<K extends string | number | symbol, V>(pairs: readonly (readonly [K, V])[]): Record<K, V>;
+
+/**
+ * Comparison operators
+ * @module logic/comparison
+ */
+declare function equals<T>(a: T): (b: T) => boolean;
+declare function equals<T>(a: T, b: T): boolean;
+declare function identical<T>(a: T): (b: T) => boolean;
+declare function identical<T>(a: T, b: T): boolean;
+declare function gt(a: number): (b: number) => boolean;
+declare function gt(a: number, b: number): boolean;
+declare function gte(a: number): (b: number) => boolean;
+declare function gte(a: number, b: number): boolean;
+declare function lt(a: number): (b: number) => boolean;
+declare function lt(a: number, b: number): boolean;
+declare function lte(a: number): (b: number) => boolean;
+declare function lte(a: number, b: number): boolean;
+
+/**
+ * Boolean logic operators
+ * @module logic/boolean
+ */
+type SimplePredicate$2<T> = (value: T) => boolean;
+declare function not(value: unknown): boolean;
+declare function and<T>(a: T): <U>(b: U) => T | U;
+declare function and<T, U>(a: T, b: U): T | U;
+declare function or<T>(a: T): <U>(b: U) => T | U;
+declare function or<T, U>(a: T, b: U): T | U;
+declare function both<T>(pred1: SimplePredicate$2<T>): (pred2: SimplePredicate$2<T>) => SimplePredicate$2<T>;
+declare function both<T>(pred1: SimplePredicate$2<T>, pred2: SimplePredicate$2<T>): SimplePredicate$2<T>;
+declare function either<T>(pred1: SimplePredicate$2<T>): (pred2: SimplePredicate$2<T>) => SimplePredicate$2<T>;
+declare function either<T>(pred1: SimplePredicate$2<T>, pred2: SimplePredicate$2<T>): SimplePredicate$2<T>;
+declare function complement<T>(pred: SimplePredicate$2<T>): SimplePredicate$2<T>;
+declare function allPass<T>(preds: readonly SimplePredicate$2<T>[]): SimplePredicate$2<T>;
+declare function anyPass<T>(preds: readonly SimplePredicate$2<T>[]): SimplePredicate$2<T>;
+
+/**
+ * Branching operators
+ * @module logic/branching
+ */
+type SimplePredicate$1<T> = (value: T) => boolean;
+declare function ifElse<T, R1, R2>(predicate: SimplePredicate$1<T>, onTrue: (value: T) => R1, onFalse: (value: T) => R2): (value: T) => R1 | R2;
+declare function when<T, R>(predicate: SimplePredicate$1<T>, transform: (value: T) => R): (value: T) => T | R;
+declare function unless<T, R>(predicate: SimplePredicate$1<T>, transform: (value: T) => R): (value: T) => T | R;
+type CondPair<T, R> = readonly [SimplePredicate$1<T>, (value: T) => R];
+declare function cond<T, R>(pairs: readonly CondPair<T, R>[]): (value: T) => R | undefined;
+declare function tryCatch<T, R, E>(tryer: (value: T) => R, catcher: (error: unknown, value: T) => E): (value: T) => R | E;
+
+/**
+ * Object predicate operators
+ * @module logic/predicates
+ */
+type SimplePredicate<T> = (value: T) => boolean;
+declare function propEq<K extends string>(key: K): {
+    <V>(value: V): (obj: Record<K, unknown>) => boolean;
+    <V>(value: V, obj: Record<K, unknown>): boolean;
+};
+declare function propEq<K extends string, V>(key: K, value: V): (obj: Record<K, unknown>) => boolean;
+declare function propEq<K extends string, V>(key: K, value: V, obj: Record<K, unknown>): boolean;
+declare function propSatisfies<T>(pred: SimplePredicate<T>): {
+    <K extends string>(key: K): (obj: Record<K, T>) => boolean;
+    <K extends string>(key: K, obj: Record<K, T>): boolean;
+};
+declare function propSatisfies<T, K extends string>(pred: SimplePredicate<T>, key: K): (obj: Record<K, T>) => boolean;
+declare function propSatisfies<T, K extends string>(pred: SimplePredicate<T>, key: K, obj: Record<K, T>): boolean;
+declare function pathEq(keys: readonly (string | number)[]): {
+    <V>(value: V): (obj: unknown) => boolean;
+    <V>(value: V, obj: unknown): boolean;
+};
+declare function pathEq<V>(keys: readonly (string | number)[], value: V): (obj: unknown) => boolean;
+declare function pathEq<V>(keys: readonly (string | number)[], value: V, obj: unknown): boolean;
+declare function pathSatisfies<T>(pred: SimplePredicate<T>): {
+    (keys: readonly (string | number)[]): (obj: unknown) => boolean;
+    (keys: readonly (string | number)[], obj: unknown): boolean;
+};
+declare function pathSatisfies<T>(pred: SimplePredicate<T>, keys: readonly (string | number)[]): (obj: unknown) => boolean;
+declare function pathSatisfies<T>(pred: SimplePredicate<T>, keys: readonly (string | number)[], obj: unknown): boolean;
+type WhereSpec<T> = {
+    [K in keyof T]?: SimplePredicate<T[K]>;
+};
+declare function where<T extends Record<string, unknown>>(spec: WhereSpec<T>): (obj: T) => boolean;
+declare function where<T extends Record<string, unknown>>(spec: WhereSpec<T>, obj: T): boolean;
+type WhereEqSpec<T> = {
+    [K in keyof T]?: T[K];
+};
+declare function whereEq<T extends Record<string, unknown>>(spec: WhereEqSpec<T>): (obj: T) => boolean;
+declare function whereEq<T extends Record<string, unknown>>(spec: WhereEqSpec<T>, obj: T): boolean;
+
+/**
+ * Type checking operators
+ * @module logic/typecheck
+ */
+type Constructor<T = unknown> = new (...args: any[]) => T;
+declare function is<T>(ctor: Constructor<T>): (value: unknown) => value is T;
+declare function is<T>(ctor: Constructor<T>, value: unknown): value is T;
+declare function isNil(value: unknown): value is null | undefined;
+declare function isNotNil<T>(value: T | null | undefined): value is T;
+declare function isEmpty(value: unknown): boolean;
+declare function isNotEmpty<T>(value: T): boolean;
+
+/**
+ * Nullish handling operators
+ * @module logic/nullish
+ */
+declare function defaultTo<D>(defaultValue: D): <T>(value: T | null | undefined) => T | D;
+declare function defaultTo<D, T>(defaultValue: D, value: T | null | undefined): T | D;
+declare function coalesce<T>(...values: readonly (T | null | undefined)[]): T | undefined;
+
+/**
+ * Math operators
+ * @module math
+ */
+declare function add(a: number): (b: number) => number;
+declare function add(a: number, b: number): number;
+declare function subtract(a: number): (b: number) => number;
+declare function subtract(a: number, b: number): number;
+declare function multiply(a: number): (b: number) => number;
+declare function multiply(a: number, b: number): number;
+declare function divide(a: number): (b: number) => number;
+declare function divide(a: number, b: number): number;
+declare function modulo(a: number): (b: number) => number;
+declare function modulo(a: number, b: number): number;
+declare function negate(n: number): number;
+declare function inc(n: number): number;
+declare function dec(n: number): number;
+declare function clamp(min: number, max: number): (value: number) => number;
+declare function clamp(min: number, max: number, value: number): number;
+declare function abs(n: number): number;
+declare function round(n: number): number;
+declare function floor(n: number): number;
+declare function ceil(n: number): number;
+declare function pow(exponent: number): (base: number) => number;
+declare function pow(exponent: number, base: number): number;
+
+/**
+ * String operators
+ * @module string
+ */
+declare function toUpper(str: string): string;
+declare function toLower(str: string): string;
+declare function trim(str: string): string;
+declare function split(separator: string | RegExp): (str: string) => string[];
+declare function split(separator: string | RegExp, str: string): string[];
+declare function join(separator: string): (arr: readonly string[]) => string;
+declare function join(separator: string, arr: readonly string[]): string;
+declare function replace(pattern: string | RegExp, replacement: string): (str: string) => string;
+declare function replace(pattern: string | RegExp, replacement: string, str: string): string;
+declare function startsWith(prefix: string): (str: string) => boolean;
+declare function startsWith(prefix: string, str: string): boolean;
+declare function endsWith(suffix: string): (str: string) => boolean;
+declare function endsWith(suffix: string, str: string): boolean;
+declare function test(pattern: RegExp): (str: string) => boolean;
+declare function test(pattern: RegExp, str: string): boolean;
+declare function match(pattern: RegExp): (str: string) => RegExpMatchArray | null;
+declare function match(pattern: RegExp, str: string): RegExpMatchArray | null;
+declare function substring(start: number, end?: number): (str: string) => string;
+declare function substring(start: number, end: number | undefined, str: string): string;
+declare function padStart(targetLength: number, padString?: string): (str: string) => string;
+declare function padStart(targetLength: number, padString: string | undefined, str: string): string;
+declare function padEnd(targetLength: number, padString?: string): (str: string) => string;
+declare function padEnd(targetLength: number, padString: string | undefined, str: string): string;
+declare function concatStr(a: string): (b: string) => string;
+declare function concatStr(a: string, b: string): string;
+
+/**
+ * Type coercion operators
+ * @module type
+ */
+declare function toString(value: unknown): string;
+declare function toNumber(value: unknown): number;
+declare function toBoolean(value: unknown): boolean;
+declare function toArray<T>(value: T | readonly T[] | Iterable<T>): T[];
+declare function toObject<T>(value: T): object;
+declare function type(value: unknown): string;
+
+/**
+ * Lens operators - Functional getters/setters for immutable data
+ * @module advanced/lens
+ */
+/**
+ * A Lens is a pair of functions: a getter and a setter
+ * - getter: (obj) => value - extracts a value from the structure
+ * - setter: (value, obj) => obj - returns a new structure with the value updated
+ */
+interface Lens<S, A> {
+    /** Get the focused value from the structure */
+    get: (obj: S) => A;
+    /** Set a new value, returning a new structure */
+    set: (val: A, obj: S) => S;
+}
+/**
+ * Creates a lens from a getter and setter function
+ */
+declare function lens<S, A>(getter: (obj: S) => A, setter: (val: A, obj: S) => S): Lens<S, A>;
+/**
+ * Creates a lens focused on a property of an object
+ */
+declare function lensProp<S extends object, K extends keyof S>(key: K): Lens<S, S[K]>;
+/**
+ * Creates a lens focused on a nested path in an object
+ */
+declare function lensPath<S = unknown, A = unknown>(keys: readonly (string | number)[]): Lens<S, A>;
+/**
+ * Creates a lens focused on an index in an array
+ */
+declare function lensIndex<A>(index: number): Lens<readonly A[], A>;
+/**
+ * Returns the value focused by the lens
+ */
+declare function view<S, A>(lens: Lens<S, A>): (obj: S) => A;
+declare function view<S, A>(lens: Lens<S, A>, obj: S): A;
+/**
+ * Sets the value focused by the lens, returning a new structure
+ */
+declare function set<S, A>(lens: Lens<S, A>): {
+    (val: A): (obj: S) => S;
+    (val: A, obj: S): S;
+};
+declare function set<S, A>(lens: Lens<S, A>, val: A): (obj: S) => S;
+declare function set<S, A>(lens: Lens<S, A>, val: A, obj: S): S;
+/**
+ * Applies a function to the value focused by the lens, returning a new structure
+ */
+declare function over<S, A>(lens: Lens<S, A>): {
+    (fn: (val: A) => A): (obj: S) => S;
+    (fn: (val: A) => A, obj: S): S;
+};
+declare function over<S, A>(lens: Lens<S, A>, fn: (val: A) => A): (obj: S) => S;
+declare function over<S, A>(lens: Lens<S, A>, fn: (val: A) => A, obj: S): S;
+
+/**
+ * Async operators - Asynchronous array operations
+ * @module advanced/async
+ */
+/**
+ * Maps over an array with an async function, executing in parallel
+ * All promises are started simultaneously and results are awaited together
+ */
+declare function mapAsync<T, U>(fn: (value: T, index: number) => Promise<U>): (arr: readonly T[]) => Promise<U[]>;
+declare function mapAsync<T, U>(fn: (value: T, index: number) => Promise<U>, arr: readonly T[]): Promise<U[]>;
+/**
+ * Maps over an array with an async function, executing sequentially
+ * Each promise must complete before the next one starts
+ */
+declare function mapSerial<T, U>(fn: (value: T, index: number) => Promise<U>): (arr: readonly T[]) => Promise<U[]>;
+declare function mapSerial<T, U>(fn: (value: T, index: number) => Promise<U>, arr: readonly T[]): Promise<U[]>;
+/**
+ * Filters an array with an async predicate, executing in parallel
+ */
+declare function filterAsync<T>(predicate: (value: T, index: number) => Promise<boolean>): (arr: readonly T[]) => Promise<T[]>;
+declare function filterAsync<T>(predicate: (value: T, index: number) => Promise<boolean>, arr: readonly T[]): Promise<T[]>;
+/**
+ * Reduces an array with an async reducer, executing sequentially
+ */
+declare function reduceAsync<T, U>(fn: (acc: U, value: T, index: number) => Promise<U>, initial: U): (arr: readonly T[]) => Promise<U>;
+declare function reduceAsync<T, U>(fn: (acc: U, value: T, index: number) => Promise<U>, initial: U, arr: readonly T[]): Promise<U>;
+
+/**
+ * Transducer operators - Composable algorithmic transformations
+ * @module advanced/transducer
+ *
+ * Transducers are composable higher-order reducers that can be used to
+ * transform data without creating intermediate collections.
+ */
+/**
+ * Transducer protocol symbols
+ */
+declare const TRANSDUCER_INIT = "@@transducer/init";
+declare const TRANSDUCER_STEP = "@@transducer/step";
+declare const TRANSDUCER_RESULT = "@@transducer/result";
+/**
+ * A Transformer implements the transducer protocol
+ */
+interface Transformer<Acc, Input> {
+    [TRANSDUCER_INIT]: () => Acc;
+    [TRANSDUCER_STEP]: (acc: Acc, input: Input) => Acc;
+    [TRANSDUCER_RESULT]: (acc: Acc) => Acc;
+}
+/**
+ * A Transducer transforms one transformer into another
+ */
+type Transducer<A, B> = <Acc>(xf: Transformer<Acc, B>) => Transformer<Acc, A>;
+/**
+ * Creates a mapping transducer
+ */
+declare function mapT<A, B>(fn: (val: A) => B): Transducer<A, B>;
+/**
+ * Creates a filtering transducer
+ */
+declare function filterT<A>(pred: (val: A) => boolean): Transducer<A, A>;
+/**
+ * Creates a take transducer that takes the first n items
+ */
+declare function takeT<A>(n: number): Transducer<A, A>;
+/**
+ * Creates a drop transducer that skips the first n items
+ */
+declare function dropT<A>(n: number): Transducer<A, A>;
+/**
+ * Composes transducers from left to right
+ */
+declare function composeT<A, B, C>(t1: Transducer<A, B>, t2: Transducer<B, C>): Transducer<A, C>;
+declare function composeT<A, B, C, D>(t1: Transducer<A, B>, t2: Transducer<B, C>, t3: Transducer<C, D>): Transducer<A, D>;
+declare function composeT<A, B, C, D, E>(t1: Transducer<A, B>, t2: Transducer<B, C>, t3: Transducer<C, D>, t4: Transducer<D, E>): Transducer<A, E>;
+/**
+ * Applies a transducer to a collection using a transformer
+ */
+declare function transduce<A, B, Acc>(transducer: Transducer<A, B>, transformer: Transformer<Acc, B>, initial: Acc, collection: readonly A[]): Acc;
+declare function transduce<A, B, Acc>(transducer: Transducer<A, B>, transformer: Transformer<Acc, B>, initial: Acc): (collection: readonly A[]) => Acc;
+/**
+ * Applies a transducer to a collection, outputting to an array
+ * Shorthand for transduce with array transformer
+ */
+declare function into<A, B>(transducer: Transducer<A, B>): (collection: readonly A[]) => B[];
+declare function into<A, B>(transducer: Transducer<A, B>, collection: readonly A[]): B[];
+
+export { type BinaryFn, type Comparator, type ComposeBuilderFn, type Curry1, type Curry2, type Curry3, type DeepReadonly, F, type Fn, type Head, type Last, type Lens, type Mapper, type Nullable, type ParamsOf, type PipeBuilderFn, type PipeFn, type PipeTransformer, type Placeholder, type Predicate, type Reducer, type ReturnOf, T$1 as T, TRANSDUCER_INIT, TRANSDUCER_RESULT, TRANSDUCER_STEP, type Tail, type TernaryFn, type Transducer, type Transformer, type UnaryFn, type VariadicFn, placeholder as __, abs, add, allPass, always, and, anyPass, append, applySpec, assoc, assocPath, both, ceil, chain, clamp, coalesce, complement, compose, composeAsync, composeK, composeT, concat, concatStr, cond, countBy, curry, curryN, dec, defaultTo, dissoc, dissocPath, divide, drop, dropLast, dropT, dropWhile, either, endsWith, entries, equals, every, evolve, extend, filter, filterAsync, filterT, find, findIndex, findLast, flatten, floor, fromEntries, groupBy, gt, gte, head, identical, identity, ifElse, inc, includes, indexBy, indexOf, init, into, is, isEmpty, isNil, isNotEmpty, isNotNil, isPlaceholder, join, keys, last, length, lens, lensIndex, lensPath, lensProp, letIn, lt, lte, map, mapAsync, mapSerial, mapT, match, max, mean, median, merge, mergeDeep, min, modulo, multiply, negate, none, not, nth, omit, or, over, padEnd, padStart, partial, partialRight, partition, path, pathEq, pathOr, pathSatisfies, pick, pipe, pipeAsync, pipeBuilder, pipeK, pipeWith, pluck, pow, prepend, product, prop, propEq, propOr, propSatisfies, props, range, reduce, reduceAsync, reduceRight, reject, replace, reverse, round, set, slice, some, sort, sortBy, split, splitEvery, startsWith, substring, subtract, sum, tail, take, takeLast, takeT, takeWhile, tap, test, toArray, toBoolean, toLower, toNumber, toObject, toString, toUpper, transduce, trim, tryCatch, type, uniq, uniqBy, unless, unnest, values, view, when, where, whereEq, zip, zipObj, zipWith };