type ArrayContainer<T = unknown> = readonly T[];
type ArrayCallback<T, R, A = ArrayContainer<T>> = {
    (item: T, index: number, array: A): R;
};
type ArrayPredicate<T, A = ArrayContainer<T>> = ArrayCallback<T, boolean, A>;
type ArrayReducer<P, C, R = P, A extends ArrayContainer = ArrayContainer<C>> = (previousValue: P, currentValue: C, index: number, array: A) => R;

declare const adjust: {
    <T, U>(index: number, transform: (value: T) => U, array: ArrayContainer<T>): (T | U)[];
    <T, U>(index: number, transform: (value: T) => U): <T2 extends T>(array: ArrayContainer<T2>) => (T | U)[];
    <T, U>(index: number): {
        <T2 extends T, U2 extends U>(transform: (value: T2) => U2, array: ArrayContainer<T2>): (T2 | U2)[];
        <T2 extends T, U2_1 extends U>(transform: (value: T2) => U2_1): <T3 extends T2>(array: ArrayContainer<T3>) => (T3 | U2_1)[];
    };
};

/**
 * Checks if all elements in the array satisfy the given predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to check
 * @returns Returns true if all elements satisfy the predicate function, false otherwise
 * @example
 * const array = [1, 2, 3, 4, 5];
 * all(x => x > 0, array); // true
 * all(x => x > 3, array); // false
 * all(x => x > 0)(array); // true
 */
declare const all: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): boolean;
    <T1>(predicate: ArrayPredicate<T1>): <T2 extends T1>(array: ArrayContainer<T2>) => boolean;
};

type Predicate$2<T> = (value: T) => boolean;
type BinaryFunction<A, B, R> = (a: A, b: B) => R;
type Comparator<A, B = A, R = number> = BinaryFunction<A, B, R>;
type IsNever<T> = [T] extends [never] ? true : false;
type Prettify$1<T> = {
    [K in keyof T]: T[K];
} & {};

/**
 * Checks if a value satisfies all the given predicate functions
 *
 * @category Array
 * @param predicates - The array of predicate functions to test the value
 * @param value - The value to check
 * @returns Returns true if the value satisfies all predicates, false otherwise
 * @example
 * const predicates = [x => x > 0, x => x < 10];
 * allPass(predicates, 5); // true
 * allPass(predicates, 15); // false
 * allPass(predicates)(5); // true
 */
declare const allPass: {
    <T>(predicates: ArrayContainer<Predicate$2<T>>, value: T): boolean;
    <T1 extends ArrayContainer<Predicate$2<any>>>(predicates: T1): <U>(value: Parameters<T1[number]>[0] & U) => boolean;
};

type GenericFunction<Args extends readonly any[] = any[], R = any> = (...args: Args) => R;
type AnyFunction = GenericFunction<any[], any>;
type Awaitable<T = any> = T | Promise<T> | PromiseLike<T>;
type AwaitableFunction<Args extends readonly any[] = any[], Return = any> = GenericFunction<Args, Awaitable<Return>>;
type FirstFn<T extends readonly AnyFunction[]> = T extends [infer First, ...any[]] ? First : never;
type ConstantFunction<T> = (...anyArgs: unknown[]) => T;

declare function alwaysImpl<T>(value: T): ConstantFunction<T>;
/**
 * Returns a function that always returns the value that was passed as the argument.
 * This function is useful for creating constant functions.
 *
 * @category Function
 * @param value The value to always return
 * @returns A function that always returns the value
 * @example
 * const alwaysTrue = always(true);
 * alwaysTrue() // true
 * alwaysTrue('anything') // true
 */
declare const always: typeof alwaysImpl;

/**
 * Checks if any elements in the array satisfy the given predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to check
 * @returns Returns true if any elements satisfy the predicate function, false otherwise
 * @example
 * const array = [1, 2, 3, 4, 5];
 * any(x => x > 3, array); // true
 * any(x => x > 5, array); // false
 * any(x => x > 3)(array); // true
 */
declare const any: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): boolean;
    <T1>(predicate: ArrayPredicate<T1>): <T2 extends T1>(array: ArrayContainer<T2>) => boolean;
};

/**
 * Checks if a value satisfies any of the given predicate functions
 *
 * @category Array
 * @param predicates - The array of predicate functions to test the value
 * @param value - The value to check
 * @returns Returns true if the value satisfies any predicate, false otherwise
 * @example
 * const predicates = [x => x > 0, x => x < 10];
 * anyPass(predicates, 15); // true
 * anyPass(predicates, -5); // false
 * anyPass(predicates)(15); // true
 */
declare const anyPass: {
    <T>(predicates: ArrayContainer<Predicate$2<T>>, value: T): boolean;
    <T>(predicates: ArrayContainer<Predicate$2<T>>): <T2 extends T>(value: T2) => boolean;
};

/**
 * Applies an array of functions to an array of values
 *
 * @category Array
 * @param fns - Array of functions to apply
 * @param values - Array of values to apply the functions to
 * @returns Returns an array containing the results of applying each function to each value
 * @example
 * const fns = [x => x + 1, x => x * 2];
 * const values = [1, 2, 3];
 * ap(fns, values); // [2, 3, 4, 2, 4, 6]
 */
declare const ap: {
    <T, Fn extends AnyFunction>(fns: ArrayContainer<Fn>, values: ArrayContainer<T>): ReturnType<Fn>[];
    <Fn extends AnyFunction>(fns: ArrayContainer<Fn>): <T2 extends Parameters<Fn>[0]>(values: ArrayContainer<T2>) => ReturnType<Fn>[];
};

/**
 * Creates a new list of n-tuples (sliding windows) from the given array
 *
 * @category Array
 * @param size - The size of each sliding window
 * @param array - The array to create sliding windows from
 * @returns Returns an array of sliding windows
 * @example
 * const array = [1, 2, 3, 4, 5];
 * aperture(3, array); // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
 * aperture(2, array); // [[1, 2], [2, 3], [3, 4], [4, 5]]
 * aperture(3)(array); // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
 */
declare const aperture: {
    <T>(size: number, array: T): T[][];
    (size: number): {
        <T>(array: T): T[][];
    };
};

/**
 * Appends an item to the end of an array
 *
 * @category Array
 * @param item - The item to append
 * @param array - The array to append to
 * @returns Returns a new array with the item appended
 * @example
 * const array = [1, 2, 3];
 * append(4, array); // [1, 2, 3, 4]
 * append('a')([1, 2, 3]); // [1, 2, 3, 'a']
 */
declare const append: {
    <T, U>(item: U, array: ArrayContainer<T>): [...T[], U];
    <T, U>(item: U): <T2 extends ArrayContainer<T>>(array: T2) => [...T2, U];
};

/**
 * Splits an array into two arrays based on a boolean filter array
 *
 * @category Array
 * @param filter - The boolean filter array
 * @param array - The input array
 * @returns Returns a tuple of two arrays, where the first array contains elements where filter is true, and the second array contains elements where filter is false
 * @example
 * const array = [1, 2, 3, 4];
 * const filter = [true, false, true, false];
 * bifurcate(filter, array); // [[1, 3], [2, 4]]
 */
declare const bifurcate: {
    <T, F extends ArrayContainer<boolean>>(filter: F, array: ArrayContainer<T>): [T[], T[]];
    <T, F extends ArrayContainer<boolean>>(filter: F): <T2 extends T>(array: ArrayContainer<T2>) => [T2[], T2[]];
};

/**
 * Splits an array into chunks of the specified size
 *
 * @category Array
 * @param size - The size of each chunk
 * @param array - The array to split into chunks
 * @returns Returns an array of chunks
 * @example
 * const array = [1, 2, 3, 4, 5];
 * chunk(2, array); // [[1, 2], [3, 4], [5]]
 * chunk(3, array); // [[1, 2, 3], [4, 5]]
 * chunk(2)(array); // [[1, 2], [3, 4], [5]]
 */
declare const chunk: {
    <T>(size: number, array: ArrayContainer<T>): T[][];
    <T>(size: number): <T2 extends T>(array: ArrayContainer<T2>) => T2[][];
};

declare function cloneImpl<T extends Record<PropertyKey, unknown>>(obj: T): T;
/**
 * Creates a shallow copy of an object
 *
 * @category Object
 * @param obj - The object to clone
 * @returns Returns a new object with the same properties as the input object
 * @example
 * const obj = { name: 'John', age: 30 };
 * const cloned = clone(obj);
 * cloned === obj; // false
 * cloned.name === obj.name; // true
 */
declare const clone: typeof cloneImpl;

declare function complementImpl<T extends readonly any[], R>(fn: (...args: T) => R): (...args: T) => boolean;
/**
 * Returns a function that returns the logical complement of the result of the given function.
 * The given function must be a predicate function (returning a boolean value).
 *
 * @category Function
 * @param fn The predicate function to complement
 * @returns A new function that returns the logical complement of the result
 * @example
 * const isEven = (n: number) => n % 2 === 0;
 * const isOdd = complement(isEven);
 * isEven(2) // true
 * isOdd(2) // false
 */
declare const complement: typeof complementImpl;

declare function compose(): <T>(x: T) => T;
declare function compose<Args extends readonly any[], R1>(f1: (...args: Args) => R1): (...args: Args) => R1;
declare function compose<Args extends readonly any[], R1, R2>(f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R2;
declare function compose<Args extends readonly any[], R1, R2, R3>(f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R3;
declare function compose<Args extends readonly any[], R1, R2, R3, R4>(f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R4;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5>(f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R5;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6>(f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R6;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7>(f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R7;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8>(f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R8;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9>(f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R9;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R10;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R11;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R12;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R13;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(f14: (x: R13) => R14, f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R14;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(f15: (x: R14) => R15, f14: (x: R13) => R14, f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R15;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16>(f16: (x: R15) => R16, f15: (x: R14) => R15, f14: (x: R13) => R14, f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R16;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17>(f17: (x: R16) => R17, f16: (x: R15) => R16, f15: (x: R14) => R15, f14: (x: R13) => R14, f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R17;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18>(f18: (x: R17) => R18, f17: (x: R16) => R17, f16: (x: R15) => R16, f15: (x: R14) => R15, f14: (x: R13) => R14, f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R18;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19>(f19: (x: R18) => R19, f18: (x: R17) => R18, f17: (x: R16) => R17, f16: (x: R15) => R16, f15: (x: R14) => R15, f14: (x: R13) => R14, f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R19;
declare function compose<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20>(f20: (x: R19) => R20, f19: (x: R18) => R19, f18: (x: R17) => R18, f17: (x: R16) => R17, f16: (x: R15) => R16, f15: (x: R14) => R15, f14: (x: R13) => R14, f13: (x: R12) => R13, f12: (x: R11) => R12, f11: (x: R10) => R11, f10: (x: R9) => R10, f9: (x: R8) => R9, f8: (x: R7) => R8, f7: (x: R6) => R7, f6: (x: R5) => R6, f5: (x: R4) => R5, f4: (x: R3) => R4, f3: (x: R2) => R3, f2: (x: R1) => R2, f1: (...args: Args) => R1): (...args: Args) => R20;
declare function compose<Args extends readonly any[], Fns extends readonly AnyFunction[]>(...fns: Fns): (...args: Args) => ReturnType<FirstFn<Fns>>;

declare function composeAsync(): <T>(x: T) => Awaitable<T>;
declare function composeAsync<Args extends readonly any[], R1>(f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, Awaited<R1>>;
declare function composeAsync<Args extends readonly any[], R1, R2>(f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R2>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3>(f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R3>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4>(f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R4>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5>(f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R5>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6>(f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R6>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7>(f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R7>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8>(f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R8>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9>(f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R9>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R10>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R11>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R12>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R13>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(f14: AwaitableFunction<[Awaited<R13>], R14>, f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R14>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(f15: AwaitableFunction<[Awaited<R14>], R15>, f14: AwaitableFunction<[Awaited<R13>], R14>, f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R15>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16>(f16: AwaitableFunction<[Awaited<R15>], R16>, f15: AwaitableFunction<[Awaited<R14>], R15>, f14: AwaitableFunction<[Awaited<R13>], R14>, f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R16>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17>(f17: AwaitableFunction<[Awaited<R16>], R17>, f16: AwaitableFunction<[Awaited<R15>], R16>, f15: AwaitableFunction<[Awaited<R14>], R15>, f14: AwaitableFunction<[Awaited<R13>], R14>, f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R17>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18>(f18: AwaitableFunction<[Awaited<R17>], R18>, f17: AwaitableFunction<[Awaited<R16>], R17>, f16: AwaitableFunction<[Awaited<R15>], R16>, f15: AwaitableFunction<[Awaited<R14>], R15>, f14: AwaitableFunction<[Awaited<R13>], R14>, f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R18>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19>(f19: AwaitableFunction<[Awaited<R18>], R19>, f18: AwaitableFunction<[Awaited<R17>], R18>, f17: AwaitableFunction<[Awaited<R16>], R17>, f16: AwaitableFunction<[Awaited<R15>], R16>, f15: AwaitableFunction<[Awaited<R14>], R15>, f14: AwaitableFunction<[Awaited<R13>], R14>, f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R19>;
declare function composeAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20>(f20: AwaitableFunction<[Awaited<R19>], R20>, f19: AwaitableFunction<[Awaited<R18>], R19>, f18: AwaitableFunction<[Awaited<R17>], R18>, f17: AwaitableFunction<[Awaited<R16>], R17>, f16: AwaitableFunction<[Awaited<R15>], R16>, f15: AwaitableFunction<[Awaited<R14>], R15>, f14: AwaitableFunction<[Awaited<R13>], R14>, f13: AwaitableFunction<[Awaited<R12>], R13>, f12: AwaitableFunction<[Awaited<R11>], R12>, f11: AwaitableFunction<[Awaited<R10>], R11>, f10: AwaitableFunction<[Awaited<R9>], R10>, f9: AwaitableFunction<[Awaited<R8>], R9>, f8: AwaitableFunction<[Awaited<R7>], R8>, f7: AwaitableFunction<[Awaited<R6>], R7>, f6: AwaitableFunction<[Awaited<R5>], R6>, f5: AwaitableFunction<[Awaited<R4>], R5>, f4: AwaitableFunction<[Awaited<R3>], R4>, f3: AwaitableFunction<[Awaited<R2>], R3>, f2: AwaitableFunction<[Awaited<R1>], R2>, f1: AwaitableFunction<Args, R1>): AwaitableFunction<Args, R20>;
declare function composeAsync<Args extends readonly any[], Fns extends readonly AwaitableFunction[]>(...fns: Fns): AwaitableFunction<Args, ReturnType<FirstFn<Fns>>>;

/**
 * Concatenates two arrays
 *
 * @category Array
 * @param arrayB - The second array to concatenate
 * @param arrayA - The first array to concatenate
 * @returns Returns a new array containing elements from both arrays
 * @example
 * const array1 = [1, 2, 3];
 * const array2 = [4, 5, 6];
 * concat(array2, array1); // [1, 2, 3, 4, 5, 6]
 * concat(array2)(array1); // [1, 2, 3, 4, 5, 6]
 */
declare const concat: {
    <T, U>(arrayB: ArrayContainer<U>, arrayA: ArrayContainer<T>): (T | U)[];
    <U>(arrayB: ArrayContainer<U>): <T>(arrayA: ArrayContainer<T>) => (T | U)[];
};

/**
 * Counts the occurrences of elements in an array based on a key function
 *
 * @category Array
 * @param callbackFn - The function to generate keys for counting
 * @param array - The array to count elements from
 * @returns Returns an object with keys from callbackFn and their counts as values
 * @example
 * const array = [1, 2, 3, 4, 5];
 * countBy(x => x % 2 === 0 ? 'even' : 'odd', array); // { odd: 3, even: 2 }
 * countBy(x => x % 2 === 0 ? 'even' : 'odd')(array); // { odd: 3, even: 2 }
 */
declare const countBy: {
    <T, K extends PropertyKey>(callbackFn: ArrayCallback<T, K>, array: ArrayContainer<T>): Record<K, number>;
    <T, K extends PropertyKey>(callbackFn: ArrayCallback<T, K>): <T2 extends T>(array: ArrayContainer<T2>) => Record<K, number>;
};

declare function curry<T extends any[], R>(fn: (...args: T) => R): (...args: any[]) => any;

/**
 * Returns an array containing elements that exist in the first array but not in the second array
 *
 * @category Array
 * @param array1 - The first array to compare
 * @param array2 - The second array to compare against
 * @returns Returns a new array containing elements unique to the first array
 * @example
 * const array1 = [1, 2, 3, 4, 5];
 * const array2 = [2, 4, 6];
 * difference(array1, array2); // [1, 3, 5]
 * difference(array1)(array2); // [1, 3, 5]
 */
declare const difference: {
    <T, U>(arrayB: ArrayContainer<U>, arrayA: ArrayContainer<T>): T[];
    <U>(arrayB: ArrayContainer<U>): <T>(arrayA: ArrayContainer<T>) => T[];
};

/**
 * Creates an array of values from the first array that are not present in the second array,
 * using an iteratee function to determine equality
 *
 * @category Array
 * @param iteratee - The function invoked per element
 * @param array1 - The array to inspect
 * @param array2 - The array of values to exclude
 * @returns Returns the new array of filtered values
 * @example
 * const array1 = [{ x: 1 }, { x: 2 }];
 * const array2 = [{ x: 1 }];
 * differenceBy(item => item.x, array1, array2); // => [{ x: 2 }]
 */
declare const differenceBy: {
    <T, U, I>(iteratee: ArrayCallback<T | U, I>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): T[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>): <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>) => T2[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>): <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>) => <T3 extends T2>(array1: ArrayContainer<T3>) => T3[];
};

/**
 * Creates an array of values from the first array that are not present in the second array,
 * using a custom comparator function to determine equality
 *
 * @category Array
 * @param comparator - The function used to compare elements
 * @param array1 - The array to inspect
 * @param array2 - The array of values to exclude
 * @returns Returns the new array of filtered values
 * @example
 * const array1 = [{ x: 1, y: 2 }, { x: 2, y: 1 }];
 * const array2 = [{ x: 1, y: 2 }];
 * differenceWith((a, b) => a.x === b.x && a.y === b.y, array1, array2); // => [{ x: 2, y: 1 }]
 */
declare const differenceWith: {
    <T, U>(comparator: Comparator<T, U, boolean>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): T[];
    <T, U>(comparator: Comparator<T, U, boolean>, array2: ArrayContainer<U>): <T2 extends T>(array1: ArrayContainer<T2>) => T2[];
    <T, U>(comparator: Comparator<T, U, boolean>): {
        <U2 extends U, T2 extends T>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>): T2[];
        <U2 extends U>(array2: ArrayContainer<U2>): <T2_1 extends T>(array1: ArrayContainer<T2_1>) => T2_1[];
    };
};

/**
 * Drops the first n elements from an array
 *
 * @category Array
 * @param count - The number of elements to drop from the beginning
 * @param array - The input array
 * @returns A new array with the first n elements dropped
 * @example
 * const array = [1, 2, 3, 4, 5];
 * drop(2, array); // [3, 4, 5]
 * drop(0, array); // [1, 2, 3, 4, 5]
 * drop(2)(array); // [3, 4, 5]
 */
declare const drop: {
    <T>(count: number, array: ArrayContainer<T>): T[];
    (count: number): <T>(array: ArrayContainer<T>) => T[];
};

/**
 * Drops the specified number of elements from the end of an array
 *
 * @category Array
 * @param count - The number of elements to drop from the end
 * @param array - The input array
 * @returns A new array with the specified number of elements dropped from the end
 * @example
 * const array = [1, 2, 3, 4, 5];
 * dropLast(2, array); // [1, 2, 3]
 * dropLast(0, array); // [1, 2, 3, 4, 5]
 * dropLast(2)(array); // [1, 2, 3]
 */
declare const dropLast: {
    <T>(count: number, array: ArrayContainer<T>): T[];
    (count: number): <T>(array: ArrayContainer<T>) => T[];
};

/**
 * Drops elements from the end of an array while the predicate function returns true
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to process
 * @returns Returns a new array with elements dropped from the end while predicate returns true
 * @example
 * const array = [1, 2, 3, 4, 5];
 * dropLastWhile(x => x > 3, array); // [1, 2, 3]
 * dropLastWhile(x => x > 0, array); // []
 * dropLastWhile(x => x > 3)(array); // [1, 2, 3]
 */
declare const dropLastWhile: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T[];
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

declare function dropRepeatsImpl<T>(array: ArrayContainer<T>): T[];
/**
 * Removes consecutive duplicate elements from an array
 *
 * @category Array
 * @param array - The array to remove consecutive duplicates from
 * @returns Returns a new array with consecutive duplicates removed
 * @example
 * const array = [1, 1, 2, 2, 3, 3, 3, 4];
 * dropRepeats(array); // [1, 2, 3, 4]
 */
declare const dropRepeats: typeof dropRepeatsImpl;

/**
 * Removes consecutive duplicate elements from an array using a custom comparison function
 *
 * @category Array
 * @param comparator - The function to compare consecutive elements
 * @param array - The array to remove consecutive duplicates from
 * @returns Returns a new array with consecutive duplicates removed
 * @example
 * const array = [{ id: 1 }, { id: 1 }, { id: 2 }, { id: 2 }];
 * dropRepeatsWith((a, b) => a.id === b.id, array); // [{ id: 1 }, { id: 2 }]
 */
declare const dropRepeatsWith: {
    <T>(comparator: Comparator<T, T, boolean>, array: ArrayContainer<T>): T[];
    <T>(comparator: Comparator<T, T, boolean>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

/**
 * Drops elements from the beginning of an array while the predicate function returns true
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to process
 * @returns Returns a new array with elements dropped from the beginning while predicate returns true
 * @example
 * const array = [1, 2, 3, 4, 5];
 * dropWhile(x => x < 3, array); // [3, 4, 5]
 * dropWhile(x => x > 0, array); // []
 * dropWhile(x => x < 3)(array); // [3, 4, 5]
 */
declare const dropWhile: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T[];
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

/**
 * Returns false.
 * This function is useful as a default or placeholder function.
 *
 * @category Function
 * @returns false
 * @example
 * False() // false
 */
declare function False(..._: unknown[]): false;

/**
 * Filters elements in an array based on a predicate function
 *
 * @category Array
 * @param predicate - The function to test each element
 * @param array - The array to filter
 * @returns Returns a new array with elements that pass the test implemented by the predicate
 * @example
 * const array = [1, 2, 3, 4, 5];
 * filter(x => x % 2 === 0, array); // [2, 4]
 * filter(x => x > 3)(array); // [4, 5]
 */
declare const filter: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T[];
    <Fn extends ArrayPredicate<any>>(predicate: Fn): <T2 extends Parameters<Fn>[0]>(array: ArrayContainer<T2>) => T2[];
};

declare function flow(): <T>(x: T) => T;
declare function flow<A extends AnyFunction>(a: A): A;
declare function flow<Args extends readonly any[], R1, R2>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2): (...arg: Args) => R2;
declare function flow<Args extends readonly any[], R1, R2, R3>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3): (...arg: Args) => R3;
declare function flow<Args extends readonly any[], R1, R2, R3, R4>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4): (...arg: Args) => R4;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5): (...arg: Args) => R5;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6): (...arg: Args) => R6;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7): (...arg: Args) => R7;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8): (...arg: Args) => R8;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9): (...arg: Args) => R9;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10): (...arg: Args) => R10;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11): (...arg: Args) => R11;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12): (...arg: Args) => R12;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13): (...arg: Args) => R13;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14): (...arg: Args) => R14;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15): (...arg: Args) => R15;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16): (...arg: Args) => R16;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17): (...arg: Args) => R17;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17, f18: (arg: R17) => R18): (...arg: Args) => R18;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17, f18: (arg: R17) => R18, f19: (arg: R18) => R19): (...arg: Args) => R19;
declare function flow<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20>(f1: (...arg: Args) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17, f18: (arg: R17) => R18, f19: (arg: R18) => R19, f20: (arg: R19) => R20): (...arg: Args) => R20;

/**
 * Returns the first element in the array that satisfies the predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to search
 * @returns Returns the first element that passes the predicate check, or undefined if no element passes
 * @example
 * const array = [1, 2, 3, 4, 5];
 * find(x => x > 3, array); // 4
 * find(x => x > 10, array); // undefined
 * find(x => x > 3)(array); // 4
 */
declare const find: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T | undefined;
    <T = any>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => T2 | undefined;
};

/**
 * Returns the index of the first element in the array that satisfies the predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to search
 * @returns Returns the index of the first element that passes the predicate check, or -1 if no element passes
 * @example
 * const array = [1, 2, 3, 4, 5];
 * findIndex(x => x > 3, array); // 3
 * findIndex(x => x < 0, array); // -1
 * findIndex(x => x > 3)(array); // 3
 */
declare const findIndex: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): number;
    <T = any>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => number;
};

/**
 * Returns the last element in the array that satisfies the predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to search
 * @returns Returns the last element that passes the predicate check, or undefined if no element passes
 * @example
 * const array = [1, 2, 3, 4, 5];
 * findLast(x => x > 3, array); // 5
 * findLast(x => x > 10, array); // undefined
 * findLast(x => x > 3)(array); // 5
 */
declare const findLast: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T | undefined;
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => T2 | undefined;
};

/**
 * Returns the index of the last element in the array that satisfies the predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to search
 * @returns Returns the index of the last element that passes the predicate check, or -1 if no element passes
 * @example
 * const array = [1, 2, 3, 4, 5, 3];
 * findLastIndex(x => x === 3, array); // 5
 * findLastIndex(x => x < 0, array); // -1
 * findLastIndex(x => x === 3)(array); // 5
 */
declare const findLastIndex: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): number;
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => number;
};

declare function firstImpl<T>(array: ArrayContainer<T>): T | undefined;
/**
 * Returns the first element of an array
 *
 * @category Array
 * @param array - The array to get the first element from
 * @returns Returns the first element of the array, or undefined if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * first(array); // 1
 * first([]); // undefined
 * first()(array); // 1
 */
declare const first: typeof firstImpl;

type ArrayFlatten<T, Depth extends number = 1> = Depth extends 0 ? T : ArrayFlatten<FlattenArray<T>, [-1, 0, 1, 2, 3, 4, 5][Depth]>;
type FlattenArrayInner<T> = T extends readonly (infer Item)[] ? (Item extends readonly any[] ? Item[number][] : Item[]) : T[];
type FlattenArray<T> = FlattenArrayInner<T>[number][];

declare const flatMap: {
    <T, R>(callbackfn: ArrayCallback<T, R>, data: ArrayContainer<T>): FlattenArray<R>;
    <T, R>(callbackfn: ArrayCallback<T, R>): (array: ArrayContainer<T>) => FlattenArray<R>;
};

/**
 * Flattens an array up to the specified depth
 *
 * @category Array
 * @param n - The depth level specifying how deep a nested array structure should be flattened
 * @param array - The array to flatten
 * @returns Returns the new flattened array
 * @example
 * const array = [1, [2, [3, [4]], 5]];
 * flatten(1, array); // [1, 2, [3, [4]], 5]
 * flatten(2, array); // [1, 2, 3, [4], 5]
 * flatten(1)(array); // [1, 2, [3, [4]], 5]
 */
declare const flatten: {
    <T, const Depth extends number>(n: Depth, array: ArrayContainer<T>): ArrayFlatten<T, Depth>;
    <T, const Depth extends number>(n: Depth): (array: ArrayContainer<T>) => ArrayFlatten<T, Depth>;
};

/**
 * Returns a new function that takes the first two arguments in reverse order.
 * Any additional arguments will be passed in their original order.
 *
 * @category Function
 * @param fn The function to flip
 * @returns A new function with the first two arguments flipped
 * @example
 * const subtract = (a: number, b: number) => a - b;
 * const flippedSubtract = flip(subtract);
 * subtract(5, 3) // 2
 * flippedSubtract(5, 3) // -2
 */
declare function flipImpl<T, U, R>(fn: (a: T, b: U, ...args: any[]) => R): (b: U, a: T, ...args: any[]) => R;
declare const flip: typeof flipImpl;

/**
 * Executes a function for each element in the array and returns the original array
 *
 * @category Array
 * @param callbackFn - The function to execute for each element
 * @param array - The array to iterate over
 * @returns Returns the original array
 * @example
 * const array = [1, 2, 3];
 * forEach(x => console.log(x), array); // logs: 1, 2, 3
 * // => [1, 2, 3]
 */
declare const forEach: {
    <T>(callbackFn: ArrayCallback<T, unknown>, array: ArrayContainer<T>): ArrayContainer<T>;
    <T>(callbackFn: ArrayCallback<T, unknown>): (array: ArrayContainer<T>) => ArrayContainer<T>;
};

type StrictPairs = readonly (readonly [PropertyKey, any])[];
type LoosePairs = unknown[][];
type FromPairsStrict<T extends StrictPairs> = {
    [P in T[number] as P[0]]: P[1];
};
type FromPairsLoose<T extends LoosePairs> = Record<Extract<T[number][number], PropertyKey>, T[number][number]>;
type FromPairs<T extends StrictPairs | LoosePairs> = Prettify$1<T extends StrictPairs ? FromPairsStrict<T> : T extends LoosePairs ? FromPairsLoose<T> : never>;
declare function fromPairsImpl<T extends StrictPairs | LoosePairs>(pairs: T): FromPairs<T>;
/**
 * Creates an object from an array of key-value pairs
 *
 * @category Array
 * @param pairs - The array of key-value pairs
 * @returns Returns an object created from the key-value pairs
 * @example
 * const pairs = [['a', 1], ['b', 2], ['c', 3]];
 * fromPairs(pairs); // { a: 1, b: 2, c: 3 }
 */
declare const fromPairs: typeof fromPairsImpl;

/**
 * Groups the elements of an array based on the result of a key function
 *
 * @category Array
 * @param callbackFn - The function to determine the group key for each element
 * @param array - The array to group
 * @returns Returns an object where the keys are the group keys and the values are arrays of grouped elements
 * @example
 * const array = [1, 2, 3, 4, 5];
 * groupBy(x => x % 2 === 0 ? 'even' : 'odd', array); // { odd: [1, 3, 5], even: [2, 4] }
 * groupBy(x => x.toString(), array); // { '1': [1], '2': [2], '3': [3], '4': [4], '5': [5] }
 * groupBy(x => x % 2 === 0 ? 'even' : 'odd')(array); // { odd: [1, 3, 5], even: [2, 4] }
 */
declare const groupBy: {
    <T, K extends PropertyKey>(callbackFn: ArrayCallback<T, K>, array: ArrayContainer<T>): Record<K, T[]>;
    <Fn extends ArrayCallback<any, PropertyKey>>(callbackFn: Fn): <T extends Parameters<Fn>[0], K extends ReturnType<Fn>>(array: ArrayContainer<T>) => Record<K, T[]>;
};

/**
 * Type guard functions for checking values.
 * @category Guard
 */
/**
 * Checks if a value is null or undefined.
 * @param value The value to check
 * @returns true if the value is null or undefined
 * @example
 * isNil(null) // true
 * isNil(undefined) // true
 * isNil(0) // false
 */
declare function isNil(value: unknown): value is null | undefined;
/**
 * Checks if a value is not null or undefined.
 * @param value The value to check
 * @returns true if the value is not null or undefined
 * @example
 * isNotNil(0) // true
 * isNotNil('') // true
 * isNotNil(null) // false
 */
declare function isNotNil<T>(value: T | null | undefined): value is T;
/**
 * Checks if a value is an array.
 * @param value The value to check
 * @returns true if the value is an array
 * @example
 * isArray([]) // true
 * isArray([1, 2, 3]) // true
 * isArray({}) // false
 */
declare function isArray(value: unknown): value is unknown[];
/**
 * Checks if a value is a string.
 * @param value The value to check
 * @returns true if the value is a string
 * @example
 * isString('') // true
 * isString('hello') // true
 * isString(123) // false
 */
declare function isString(value: unknown): value is string;
/**
 * Checks if a value is a number.
 * @param value The value to check
 * @returns true if the value is a number
 * @example
 * isNumber(0) // true
 * isNumber(123) // true
 * isNumber('123') // false
 */
declare function isNumber(value: unknown): value is number;
/**
 * Checks if a value is a boolean.
 * @param value The value to check
 * @returns true if the value is a boolean
 * @example
 * isBoolean(true) // true
 * isBoolean(false) // true
 * isBoolean(1) // false
 */
declare function isBoolean(value: unknown): value is boolean;
/**
 * Checks if a value is a function.
 * @param value The value to check
 * @returns true if the value is a function
 * @example
 * isFunction(() => {}) // true
 * isFunction(function() {}) // true
 * isFunction({}) // false
 */
declare function isFunction(value: unknown): value is Function;
/**
 * Checks if a value is an object.
 * @param value The value to check
 * @returns true if the value is an object
 * @example
 * isObject({}) // true
 * isObject([]) // true
 * isObject(null) // false
 */
declare function isObject(value: unknown): value is object;
/**
 * Checks if a value is a plain object.
 * @param value The value to check
 * @returns true if the value is a plain object
 * @example
 * isPlainObject({}) // true
 * isPlainObject({ a: 1 }) // true
 * isPlainObject([]) // false
 */
declare function isPlainObject(value: unknown): value is Record<string, unknown>;
/**
 * Checks if a value is a regular expression.
 * @param value The value to check
 * @returns true if the value is a regular expression
 * @example
 * isRegExp(/a/) // true
 * isRegExp(new RegExp('a')) // true
 * isRegExp('a') // false
 */
declare function isRegExp(value: unknown): value is RegExp;
/**
 * Checks if a value is a date.
 * @param value The value to check
 * @returns true if the value is a date
 * @example
 * isDate(new Date()) // true
 * isDate('2023-01-01') // false
 */
declare function isDate(value: unknown): value is Date;
/**
 * Checks if a value is an error.
 * @param value The value to check
 * @returns true if the value is an error
 * @example
 * isError(new Error()) // true
 * isError({ message: 'error' }) // false
 */
declare function isError(value: unknown): value is Error;
/**
 * Checks if a value is a symbol.
 * @param value The value to check
 * @returns true if the value is a symbol
 * @example
 * isSymbol(Symbol()) // true
 * isSymbol('symbol') // false
 */
declare function isSymbol(value: unknown): value is symbol;
/**
 * Checks if a value is null.
 * @param value The value to check
 * @returns true if the value is null
 * @example
 * isNull(null) // true
 * isNull(undefined) // false
 */
declare function isNull(value: unknown): value is null;
/**
 * Checks if a value is undefined.
 * @param value The value to check
 * @returns true if the value is undefined
 * @example
 * isUndefined(undefined) // true
 * isUndefined(null) // false
 */
declare function isUndefined(value: unknown): value is undefined;
/**
 * Checks if a value is NaN.
 * @param value The value to check
 * @returns true if the value is NaN
 * @example
 * isNaN(NaN) // true
 * isNaN(0) // false
 */
declare function isNaN(value: unknown): value is number;
/**
 * Checks if a value is a finite number.
 * @param value The value to check
 * @returns true if the value is a finite number
 * @example
 * isFinite(0) // true
 * isFinite(Infinity) // false
 */
declare function isFinite(value: unknown): value is number;
/**
 * Checks if a value is a positive number.
 * @param value The value to check
 * @returns true if the value is a positive number
 * @example
 * isPositive(1) // true
 * isPositive(0) // false
 */
declare function isPositive(value: unknown): value is number;
/**
 * Checks if a value is a negative number.
 * @param value The value to check
 * @returns true if the value is a negative number
 * @example
 * isNegative(-1) // true
 * isNegative(0) // false
 */
declare function isNegative(value: unknown): value is number;
/**
 * Checks if a value is zero.
 * @param value The value to check
 * @returns true if the value is zero
 * @example
 * isZero(0) // true
 * isZero(1) // false
 */
declare function isZero(value: unknown): value is number;
/**
 * Checks if a value is an even number.
 * @param value The value to check
 * @returns true if the value is an even number
 * @example
 * isEven(2) // true
 * isEven(1) // false
 */
declare function isEven(value: unknown): value is number;
/**
 * Checks if a value is an odd number.
 * @param value The value to check
 * @returns true if the value is an odd number
 * @example
 * isOdd(1) // true
 * isOdd(2) // false
 */
declare function isOdd(value: unknown): value is number;
/**
 * Checks if a value is Infinity.
 * @param value The value to check
 * @returns true if the value is Infinity
 * @example
 * isInfinity(Infinity) // true
 * isInfinity(0) // false
 */
declare function isInfinity(value: unknown): value is number;
/**
 * Checks if a value is negative Infinity.
 * @param value The value to check
 * @returns true if the value is negative Infinity
 * @example
 * isNegativeInfinity(-Infinity) // true
 * isNegativeInfinity(0) // false
 */
declare function isNegativeInfinity(value: unknown): value is number;
/**
 * Checks if a value is positive Infinity.
 * @param value The value to check
 * @returns true if the value is positive Infinity
 * @example
 * isPositiveInfinity(Infinity) // true
 * isPositiveInfinity(0) // false
 */
declare function isPositiveInfinity(value: unknown): value is number;
/**
 * Checks if a value is an empty string.
 * @param value The value to check
 * @returns true if the value is an empty string
 * @example
 * isEmptyString('') // true
 * isEmptyString('hello') // false
 */
declare function isEmptyString(value: unknown): value is string;
/**
 * Checks if a value is an empty array.
 * @param value The value to check
 * @returns true if the value is an empty array
 * @example
 * isEmptyArray([]) // true
 * isEmptyArray([1]) // false
 */
declare function isEmptyArray(value: unknown): value is unknown[];
/**
 * Checks if a value is an empty object.
 * @param value The value to check
 * @returns true if the value is an empty object
 * @example
 * isEmptyObject({}) // true
 * isEmptyObject({ a: 1 }) // false
 */
declare function isEmptyObject(value: unknown): value is Record<string, unknown>;
/**
 * Checks if a value is a blank string.
 * @param value The value to check
 * @returns true if the value is a blank string
 * @example
 * isBlankString('') // true
 * isBlankString('  ') // true
 * isBlankString('hello') // false
 */
declare function isBlankString(value: unknown): value is string;
/**
 * Checks if a value is a numeric string.
 * @param value The value to check
 * @returns true if the value is a numeric string
 * @example
 * isNumeric('123') // true
 * isNumeric('12.34') // true
 * isNumeric('abc') // false
 */
declare function isNumeric(value: unknown): value is string;
/**
 * Checks if a value is an alpha string.
 * @param value The value to check
 * @returns true if the value is an alpha string
 * @example
 * isAlpha('abc') // true
 * isAlpha('ABC') // true
 * isAlpha('123') // false
 */
declare function isAlpha(value: unknown): value is string;
/**
 * Checks if a value is an alphanumeric string.
 * @param value The value to check
 * @returns true if the value is an alphanumeric string
 * @example
 * isAlphanumeric('abc123') // true
 * isAlphanumeric('ABC123') // true
 * isAlphanumeric('abc!') // false
 */
declare function isAlphanumeric(value: unknown): value is string;
/**
 * Checks if a value is a valid email address.
 * @param value The value to check
 * @returns true if the value is a valid email address
 * @example
 * isEmail('test@example.com') // true
 * isEmail('invalid') // false
 */
declare function isEmail(value: unknown): value is string;
/**
 * Checks if a value is a valid URL.
 * @param value The value to check
 * @returns true if the value is a valid URL
 * @example
 * isUrl('https://example.com') // true
 * isUrl('invalid') // false
 */
declare function isUrl(value: unknown): value is string;
/**
 * Checks if a value is an array and all elements satisfy a predicate.
 * @param value The value to check
 * @param predicate The predicate function
 * @returns true if the value is an array and all elements satisfy the predicate
 * @example
 * isArrayOf([1, 2, 3], isNumber) // true
 * isArrayOf([1, '2', 3], isNumber) // false
 */
declare function isArrayOf<T>(value: unknown, predicate: (value: unknown) => value is T): value is T[];
/**
 * Checks if a value is array-like.
 * @param value The value to check
 * @returns true if the value is array-like
 * @example
 * isArrayLike([]) // true
 * isArrayLike({ length: 0 }) // true
 * isArrayLike({}) // false
 */
declare function isArrayLike(value: unknown): value is ArrayLike<unknown>;
/**
 * Checks if a value is a Promise.
 * @param value The value to check
 * @returns true if the value is a Promise
 * @example
 * isPromise(Promise.resolve()) // true
 * isPromise({}) // false
 */
declare function isPromise(value: unknown): value is Promise<unknown>;
/**
 * Checks if a value is iterable.
 * @param value The value to check
 * @returns true if the value is iterable
 * @example
 * isIterable([]) // true
 * isIterable('') // true
 * isIterable({}) // false
 */
declare function isIterable(value: unknown): value is Iterable<unknown>;
/**
 * Checks if a value is a generator function.
 * @param value The value to check
 * @returns true if the value is a generator function
 * @example
 * isGenerator(function* () {}) // true
 * isGenerator(() => {}) // false
 */
declare function isGenerator(value: unknown): value is GeneratorFunction;
/**
 * Checks if a value is an async generator function.
 * @param value The value to check
 * @returns true if the value is an async generator function
 * @example
 * isAsyncGenerator(async function* () {}) // true
 * isAsyncGenerator(function* () {}) // false
 */
declare function isAsyncGenerator(value: unknown): value is AsyncGeneratorFunction;
/**
 * Checks if a value is a generator function (either sync or async).
 * @param value The value to check
 * @returns true if the value is a generator function
 * @example
 * isGenericGenerator(function* () {}) // true
 * isGenericGenerator(async function* () {}) // true
 * isGenericGenerator(() => {}) // false
 */
declare function isGenericGenerator(value: unknown): value is GeneratorFunction | AsyncGeneratorFunction;
/**
 * Checks if a value is an integer.
 * @param value The value to check
 * @returns true if the value is an integer
 * @example
 * isInteger(1) // true
 * isInteger(1.0) // true
 * isInteger(1.1) // false
 * isInteger('1') // false
 */
declare function isInteger(value: unknown): value is number;
/**
 * Checks if a value is a float number.
 * @param value The value to check
 * @returns true if the value is a float number
 * @example
 * isFloat(1.1) // true
 * isFloat(1.0) // false
 * isFloat(1) // false
 * isFloat('1.1') // false
 * isFloat(Infinity) // false
 */
declare function isFloat(value: unknown): value is number;

/**
 * Checks if an object has a specific property
 *
 * @category Object
 * @param prop - The property to check for
 * @param obj - The object to check
 * @returns Returns true if the object has the property, false otherwise
 * @example
 * const obj = { name: 'John', age: 30 };
 * has('name', obj); // true
 * has('address', obj); // false
 *
 * const sym = Symbol('sym');
 * const objWithSymbol = { [sym]: 'value' };
 * has(sym, objWithSymbol); // true
 */
declare const has: {
    <T, K>(prop: unknown, obj: T): K extends keyof T ? true : false;
    <K extends PropertyKey>(prop: K): <T>(obj: T) => K extends keyof T ? true : false;
};

/**
 * Returns the value that was passed as the argument.
 * This function is useful as a default or placeholder function.
 *
 * @category Function
 * @param value The value to return
 * @returns The value that was passed as the argument
 * @example
 * identity(5) // 5
 * identity({ a: 1 }) // { a: 1 }
 */
declare function identityImpl<T>(value: T, ..._args: any[]): T;
declare const identity: typeof identityImpl;

/**
 * Checks if an array includes a specific element
 *
 * @category Array
 * @param item - The item to search for
 * @param array - The array to search in
 * @returns Returns true if the item is found in the array, false otherwise
 * @example
 * const array = [1, 2, 3, 4, 5];
 * includes(3, array); // true
 * includes(6, array); // false
 * includes(3)(array); // true
 */
declare const includes: {
    <T, U>(item: U, array: ArrayContainer<T>): boolean;
    <T, U>(item: U): <T2 extends T>(array: ArrayContainer<T2>) => boolean;
};

/**
 * Creates an object from an array by using the result of the callbackFn function as the key
 *
 * @category Array
 * @param callbackFn - The function to generate the key for each element
 * @param array - The array to convert to an object
 * @returns Returns an object with keys generated by callbackFn and values from the array
 * @example
 * const array = [
 *   { id: 1, name: 'Alice' },
 *   { id: 2, name: 'Bob' },
 *   { id: 3, name: 'Charlie' }
 * ];
 * indexBy(item => item.id, array);
 * // => { 1: { id: 1, name: 'Alice' }, 2: { id: 2, name: 'Bob' }, 3: { id: 3, name: 'Charlie' } }
 */
declare const indexBy: {
    <T, K extends PropertyKey>(callbackFn: ArrayCallback<T, K>, array: ArrayContainer<T>): Record<K, T>;
    <T, K extends PropertyKey>(callbackFn: ArrayCallback<T, K>): <T2 extends T>(array: ArrayContainer<T2>) => Record<K, T2>;
};

/**
 * Returns the index of the first occurrence of an item in an array
 *
 * @category Array
 * @param item - The item to search for
 * @param array - The array to search in
 * @returns Returns the index of the first occurrence of the item, or -1 if not found
 * @example
 * const array = [1, 2, 3, 4, 5, 3];
 * indexOf(3, array); // 2
 * indexOf(6, array); // -1
 * indexOf(3)(array); // 2
 */
declare const indexOf: {
    <T>(item: unknown, array: ArrayContainer<T>): number;
    (item: unknown): <T>(array: ArrayContainer<T>) => number;
};

declare function initImpl<T>(array: ArrayContainer<T>): T[];
/**
 * Returns all but the last element of an array
 *
 * @category Array
 * @param array - The array to get all but the last element from
 * @returns Returns a new array containing all but the last element
 * @example
 * const array = [1, 2, 3, 4, 5];
 * init(array); // [1, 2, 3, 4]
 * init([]); // []
 * init()(array); // [1, 2, 3, 4]
 */
declare const init: typeof initImpl;

/**
 * Inserts an item into an array at the specified index
 *
 * @category Array
 * @param index - The index at which to insert the item
 * @param item - The item to insert
 * @param array - The array to insert into
 * @returns Returns a new array with the item inserted at the specified index
 * @example
 * const array = [1, 2, 3, 4];
 * insert(1, 5, array); // [1, 5, 2, 3, 4]
 * insert(-1, 5, array); // [1, 2, 3, 5, 4]
 * insert(1)(5)(array); // [1, 5, 2, 3, 4]
 */
declare const insert: {
    <T, U>(index: number, item: U, array: ArrayContainer<T>): (T | U)[];
    <T, U>(index: number, item: U): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | U)[];
    <T>(index: number): {
        <T2 extends T, U>(item: U, array: ArrayContainer<T2>): (T2 | U)[];
        <U_1>(item: U_1): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | U_1)[];
    };
};

/**
 * Inserts a separator between each element of the array and flattens one level
 *
 * @category Array
 * @param separator - The separator to insert between elements
 * @param arrays - The array of arrays to intercalate
 * @returns Returns a new array with the separator inserted between elements and flattened one level
 * @example
 * const arrays = [[1, 2], [3, 4], [5, 6]];
 * intercalate(0, arrays); // [1, 2, 0, 3, 4, 0, 5, 6]
 * intercalate('|', arrays); // [1, 2, '|', 3, 4, '|', 5, 6]
 * intercalate(0)(arrays); // [1, 2, 0, 3, 4, 0, 5, 6]
 */
declare const intercalate: {
    <T extends ArrayContainer, S>(separator: S, arrays: ArrayContainer<T>): (T[number] | S)[];
    <T extends ArrayContainer, S>(separator: S): <T2 extends T>(arrays: ArrayContainer<T2>) => (T2[number] | S)[];
};

/**
 * Interleaves elements from two arrays
 *
 * @category Array
 * @param array1 - The first array
 * @param array2 - The second array
 * @returns Returns a new array with elements from both arrays interleaved
 * @example
 * const array1 = [1, 2, 3];
 * const array2 = ['a', 'b', 'c'];
 * interleave(array1, array2); // [1, 'a', 2, 'b', 3, 'c']
 * interleave(array1)(array2); // [1, 'a', 2, 'b', 3, 'c']
 */
declare const interleave: {
    <T, U>(array2: ArrayContainer<T>, array1: ArrayContainer<U>): (T | U)[];
    <U>(array2: ArrayContainer<U>): <T>(array1: ArrayContainer<T>) => (T | U)[];
};

/**
 * Returns an array containing elements that exist in both arrays
 *
 * @category Array
 * @param array1 - The first array to compare
 * @param array2 - The second array to compare against
 * @returns Returns a new array containing elements common to both arrays
 * @example
 * const array1 = [1, 2, 3, 4, 5];
 * const array2 = [2, 4, 6];
 * intersection(array1, array2); // [2, 4]
 * intersection(array1)(array2); // [2, 4]
 */
declare const intersection: {
    <T, U>(array2: ArrayContainer<U>, array1: ArrayContainer<T>): (T & U)[];
    <T, U>(array2: ArrayContainer<U>): <T2 extends T>(array1: ArrayContainer<T2>) => (T2 & U)[];
};

/**
 * Creates an array of values that are included in both arrays,
 * using an iteratee function to determine equality
 *
 * @category Array
 * @param iteratee - The function invoked per element
 * @param array1 - The first array to inspect
 * @param array2 - The second array to inspect
 * @returns Returns the new array of intersecting values
 * @example
 * const array1 = [{ x: 1 }, { x: 2 }];
 * const array2 = [{ x: 1 }, { x: 3 }];
 * intersectionBy(item => item.x, array1, array2); // => [{ x: 1 }]
 */
declare const intersectionBy: {
    <T, U, I>(iteratee: ArrayCallback<T | U, I>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): T[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>, array2: ArrayContainer<U>): <T2 extends T>(array1: ArrayContainer<T2>) => T2[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>): {
        <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>): T2[];
        <T2 extends T, U2_1 extends U>(array2: ArrayContainer<U2_1>): <T3 extends T2>(array1: ArrayContainer<T3>) => T3[];
    };
};

/**
 * Creates an array of values that are included in both arrays,
 * using a custom comparator function to determine equality
 *
 * @category Array
 * @param comparator - The function used to compare elements
 * @param array1 - The first array to inspect
 * @param array2 - The second array to inspect
 * @returns Returns the new array of intersecting values
 * @example
 * const array1 = [{ x: 1, y: 2 }, { x: 2, y: 1 }];
 * const array2 = [{ x: 1, y: 2 }, { x: 3, y: 4 }];
 * intersectionWith((a, b) => a.x === b.x && a.y === b.y, array1, array2); // => [{ x: 1, y: 2 }]
 */
declare const intersectionWith: {
    <T, U>(comparator: Comparator<T, U, boolean>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): T[];
    <T, U>(comparator: Comparator<T, U, boolean>, array2: ArrayContainer<U>): <T2 extends T>(array2: ArrayContainer<T>) => T2[];
    <T, U>(comparator: Comparator<T, U, boolean>): {
        <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>): T2[];
        <T2 extends T, U2_1 extends U>(array2: ArrayContainer<U2_1>): <T3 extends T2>(array1: ArrayContainer<T2>) => T3[];
    };
};

/**
 * Inserts a value between each element of an array
 *
 * @category Array
 * @param value - The value to insert between elements
 * @param array - The array to intersperse
 * @returns Returns a new array with the value inserted between elements
 * @example
 * const array = [1, 2, 3];
 * intersperse(0, array); // [1, 0, 2, 0, 3]
 * intersperse(0)(array); // [1, 0, 2, 0, 3]
 */
declare const intersperse: {
    <T, S>(value: S, array: ArrayContainer<T>): (T | S)[];
    <T, S>(value: S): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | S)[];
};

/**
 * Inverts the keys and values of an object. If a value is duplicated, the last key overwrites previous ones.
 * Only handles string and number keys/values.
 *
 * @category Object
 * @param obj The object to invert
 * @returns A new object with keys and values swapped
 * @example
 * invert({ a: 1, b: 2, c: 1 }) // { '1': 'c', '2': 'b' }
 */
declare function invertImpl<T extends PropertyKey, U extends PropertyKey>(obj: Record<T, U>): Record<U, T>;
declare const invert: typeof invertImpl;

declare const invertMulti: {
    <T extends Record<PropertyKey, PropertyKey>>(obj: T): Record<string, Array<keyof T>>;
};

declare const isEqual: (a: unknown, b: unknown) => boolean;

/**
 * Joins all elements of an array into a string using the specified separator
 *
 * @category Array
 * @param separator - The string to use as a separator
 * @param array - The array to join
 * @returns Returns the joined string
 * @example
 * const array = [1, 2, 3, 4, 5];
 * join(',', array); // '1,2,3,4,5'
 * join('|', array); // '1|2|3|4|5'
 * join(',')(array); // '1,2,3,4,5'
 */
declare const join: {
    <T extends ArrayContainer>(separator: string, array: T): string;
    (separator: string): <T extends ArrayContainer>(array: T) => string;
};

/**
 * Applies multiple functions to the same value and returns an array of results
 *
 * @category Array
 * @param fns - Array of functions to apply
 * @param value - The value to apply the functions to
 * @returns Returns an array of results from applying each function to the value
 * @example
 * const fns = [x => x + 1, x => x * 2, x => x ** 2];
 * juxt(fns, 2); // [3, 4, 4]
 * juxt(fns)(2); // [3, 4, 4]
 */
declare const juxt: {
    <Fn extends AnyFunction>(fns: ArrayContainer<Fn>, value: IsNever<Fn> extends true ? unknown : Parameters<Fn>[0]): ReturnType<Fn>[];
    <Fn extends AnyFunction>(fns: ArrayContainer<Fn>): (value: IsNever<Fn> extends true ? unknown : Parameters<Fn>[0]) => ReturnType<Fn>[];
};

declare function keysImpl<T extends string | number>(obj: Record<T, unknown>): `${T}`[];
/**
 * Returns an array of all enumerable and non-enumerable keys of an object
 *
 * @category Object
 * @param obj - The object to get keys from
 * @returns Returns an array of all keys
 * @example
 * const obj = { name: 'John', age: 30 };
 * keys(obj); // ['name', 'age']
 *
 * const sym = Symbol('sym');
 * const objWithSymbol = { [sym]: 'value', name: 'John' };
 * keys(objWithSymbol); // ['name', Symbol(sym)]
 */
declare const keys: typeof keysImpl;

declare function lastImpl<T>(array: ArrayContainer<T>): T;
/**
 * Returns the last element of an array
 *
 * @category Array
 * @param array - The array to get the last element from
 * @returns Returns the last element of the array, or undefined if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * last(array); // 5
 * last([]); // undefined
 * last()(array); // 5
 */
declare const last: typeof lastImpl;

/**
 * Returns the index of the last occurrence of an item in an array
 *
 * @category Array
 * @param item - The item to search for
 * @param array - The array to search in
 * @returns Returns the index of the last occurrence of the item, or -1 if not found
 * @example
 * const array = [1, 2, 3, 4, 5, 3];
 * lastIndexOf(3, array); // 5
 * lastIndexOf(6, array); // -1
 * lastIndexOf(3)(array); // 5
 */
declare const lastIndexOf: {
    <T>(item: unknown, array: ArrayContainer<T>): number;
    (item: unknown): <T>(array: ArrayContainer<T>) => number;
};

declare function lengthImpl<T extends ArrayContainer>(array: T): T['length'];
/**
 * Returns the length of an array
 *
 * @category Array
 * @param array - The array to get the length from
 * @returns Returns the length of the array
 * @example
 * const array = [1, 2, 3, 4, 5];
 * length(array); // 5
 * length([]); // 0
 * length()(array); // 5
 */
declare const length: typeof lengthImpl;

interface MergeWithContext {
    key: string | number;
    path: (string | number)[];
    source: any;
    target: any;
}
type MergeDeleteSymbol = {
    readonly __deleteProperty: unique symbol;
};
declare const mergeDeleteSymbol: MergeDeleteSymbol;
type MergeWithCustomizer = (sourceValue: any, targetValue: any, context: MergeWithContext) => any;
/**
 * Deeply merges two objects, supporting custom merge functions and circular reference handling.
 *
 * @category Object
 * @param customizer - The custom merge function
 * @param target - The target object
 * @param source - The source object
 * @returns Returns the merged object
 * @example
 * const target = { a: 1, b: 2 };
 * const source = { b: 3, c: 4 };
 * mergeWith(null, target, source); // { a: 1, b: 3, c: 4 }
 * mergeWith((s, t) => s + t, target, source); // { a: 1, b: 5, c: 4 }
 */
declare const mergeWith: {
    <T extends object, S extends object, Customizer extends MergeWithCustomizer | null | undefined>(customizer: Customizer, target: T, source: S): T & S;
    <T extends object, Customizer extends MergeWithCustomizer | null | undefined>(customizer: Customizer, target: T): <S extends object>(source: S) => T & S;
    <Customizer extends MergeWithCustomizer | null | undefined>(customizer: Customizer): {
        <T extends object, S extends object>(target: T, source: S): T & S;
        <T extends object>(target: T): <S_1 extends object>(source: S_1) => T & S_1;
    };
};
/**
 * In-place deep merge of two objects, supporting custom merge functions and circular reference handling.
 *
 * @category Object
 * @param customizer - The custom merge function
 * @param target - The target object
 * @param source - The source object
 * @returns Returns the merged object
 * @example
 * const target = { a: 1, b: 2 };
 * const source = { b: 3, c: 4 };
 * mergeWithInPlace(null, target, source); // { a: 1, b: 3, c: 4 }
 */
declare const mergeWithInPlace: {
    <T extends object, S extends object, Customizer extends MergeWithCustomizer | null | undefined>(customizer: Customizer, target: T, source: S): T & S;
    <T extends object, Customizer extends MergeWithCustomizer | null | undefined>(customizer: Customizer, target: T): <S extends object>(source: S) => T & S;
    <Customizer extends MergeWithCustomizer | null | undefined>(customizer: Customizer): {
        <T extends object, S extends object>(target: T, source: S): T & S;
        <T extends object>(target: T): <S_1 extends object>(source: S_1) => T & S_1;
    };
};

declare const mergeLeft: {
    <T extends object, S extends object>(target: T, source: S): T & S;
    <T extends object>(target: T): <S extends object>(source: S) => T & S;
};
declare const mergeRight: {
    <T extends object, S extends object>(target: T, source: S): T & S;
    <T extends object>(target: T): <S extends object>(source: S) => T & S;
};
declare const mergeLeftInPlace: {
    <T extends object, S extends object>(target: T, source: S): T & S;
    <T extends object>(target: T): <S extends object>(source: S) => T & S;
};
declare const mergeRightInPlace: {
    <T extends object, S extends object>(target: T, source: S): T & S;
    <T extends object>(target: T): <S extends object>(source: S) => T & S;
};

/**
 * Maps each element in an array using a callback function
 *
 * @category Array
 * @param callbackFn - The function to map each element
 * @param array - The array to map
 * @returns Returns a new array with each element mapped by the callback function
 * @example
 * const array = [1, 2, 3, 4, 5];
 * map(x => x * 2, array); // [2, 4, 6, 8, 10]
 * map(x => x.toString())(array); // ['1', '2', '3', '4', '5']
 */
declare const map: {
    <T, U>(callbackFn: ArrayCallback<T, U>, array: ArrayContainer<T>): U[];
    <T, U>(callbackFn: ArrayCallback<T, U>): (array: ArrayContainer<T>) => U[];
};

/**
 * Transforms object entries using a mapping function
 *
 * @category Object
 * @param fn - The function to transform entries
 * @param obj - The object to transform
 * @returns Returns a new object with transformed entries
 * @example
 * const obj = { name: 'John', age: 30 };
 * mapEntries(([key, value]) => [`user_${key}`, value.toString()], obj);
 * // { user_name: 'John', user_age: '30' }
 * mapEntries(([key, value]) => [key.toUpperCase(), value])(obj);
 * // { NAME: 'John', AGE: 30 }
 */
declare const mapEntries: {
    <T extends PropertyKey, U, R extends PropertyKey, V>(fn: (entry: [T, U], obj: Record<T, U>) => [R, V], obj: Record<T, U>): Record<R, V>;
    <K extends PropertyKey, V, R extends PropertyKey, U>(fn: (entry: readonly [K, V], obj: Record<K, V>) => readonly [R, U]): (obj: Record<K & PropertyKey, V>) => Record<R, U>;
};

/**
 * Transforms object keys using a mapping function
 *
 * @category Object
 * @param fn - The function to transform keys
 * @param obj - The object to transform
 * @returns Returns a new object with transformed keys
 * @example
 * const obj = { name: 'John', age: 30 };
 * mapKeys(key => `user_${key}`, obj); // { user_name: 'John', user_age: 30 }
 * mapKeys(key => key.toUpperCase())(obj); // { NAME: 'John', AGE: 30 }
 */
declare const mapKeys: {
    <T extends PropertyKey, U, R extends PropertyKey>(fn: (key: T, value: U, obj: Record<T, U>) => R, obj: Record<T, U>): Record<R, U>;
    <T extends PropertyKey, U, R extends PropertyKey>(fn: (key: T, value: U, obj: Record<T, U>) => R): <T2 extends T, U2 extends U>(obj: Record<T2, U2>) => Record<R, U>;
};

/**
 * Transforms object values using a mapping function
 *
 * @category Object
 * @param fn - The function to transform values
 * @param obj - The object to transform
 * @returns Returns a new object with transformed values
 * @example
 * const obj = { name: 'John', age: 30 };
 * mapValues(value => value.toString(), obj); // { name: 'John', age: '30' }
 * mapValues((value, key) => `${key}: ${value}`)(obj); // { name: 'name: John', age: 'age: 30' }
 */
declare const mapValues: {
    <T extends PropertyKey, U, R>(fn: (value: U, key: T, obj: Record<T, U>) => R, obj: Record<T, U>): Record<T, R>;
    <T extends PropertyKey, U, R>(fn: (value: U, key: T, obj: Record<T, U>) => R): <T2 extends T, U2 extends U>(obj: Record<T2, U2>) => Record<T, R>;
};

declare function maxImpl<T extends number>(array: ArrayContainer<T>): number | undefined;
/**
 * Finds the maximum value in an array of numbers
 *
 * @category Array
 * @param array - The array of numbers
 * @returns Returns the maximum value, or undefined if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * max(array); // 5
 * max([5, 3, 1, 4, 2]); // 5
 * max()(array); // 5
 */
declare const max: typeof maxImpl;

/**
 * Finds the maximum value in an array by applying a function to each element
 *
 * @category Array
 * @param fn - The function to apply to each element
 * @param array - The array to process
 * @returns Returns the element with the maximum value, or undefined if the array is empty
 * @example
 * const array = [{ value: 1 }, { value: 2 }, { value: 3 }];
 * maxBy(item => item.value, array); // => { value: 3 }
 * maxBy(item => item.value * 2)(array); // => { value: 3 }
 */
declare const maxBy: {
    <T, U>(fn: (value: T) => U, array: ArrayContainer<T>): T | undefined;
    <T, U>(fn: (value: T) => U): <T2 extends T>(array: ArrayContainer<T2>) => T2 | undefined;
};

/**
 * Finds the maximum value in an array using a custom comparator function
 *
 * @category Array
 * @param comparator - The comparison function that returns a negative number if a < b, 0 if a === b, or a positive number if a > b
 * @param array - The array to process
 * @returns Returns the element with the maximum value, or undefined if the array is empty
 * @example
 * const array = [{ value: 1 }, { value: 2 }, { value: 3 }];
 * maxWith((a, b) => a.value - b.value, array); // => { value: 3 }
 * maxWith((a, b) => b.value - a.value)(array); // => { value: 1 }
 */
declare const maxWith: {
    <T>(comparator: Comparator<T, T>, array: ArrayContainer<T>): T | undefined;
    <T>(comparator: Comparator<T, T>): <T2 extends T>(array: ArrayContainer<T2>) => T2 | undefined;
};

declare function meanImpl<T extends number>(array: ArrayContainer<T>): number;
/**
 * Calculates the mean (average) value of an array of numbers
 *
 * @category Array
 * @param array - The array of numbers
 * @returns Returns the mean value, or NaN if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * mean(array); // 3
 * mean([1, 2, 3, 4]); // 2.5
 * mean()(array); // 3
 */
declare const mean: typeof meanImpl;

declare function medianImpl<T extends number>(array: ArrayContainer<T>): number;
/**
 * Calculates the median value of an array of numbers
 *
 * @category Array
 * @param array - The array of numbers
 * @returns Returns the median value, or NaN if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * median(array); // 3
 * median([1, 2, 3, 4]); // 2.5
 * median()(array); // 3
 */
declare const median: typeof medianImpl;

declare function minImpl<T extends number>(array: ArrayContainer<T>): number | undefined;
/**
 * Finds the minimum value in an array of numbers
 *
 * @category Array
 * @param array - The array of numbers
 * @returns Returns the minimum value, or undefined if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * min(array); // 1
 * min([5, 3, 1, 4, 2]); // 1
 * min()(array); // 1
 */
declare const min: typeof minImpl;

/**
 * Finds the minimum value in an array by applying a function to each element
 *
 * @category Array
 * @param fn - The function to apply to each element
 * @param array - The array to process
 * @returns Returns the element with the minimum value, or undefined if the array is empty
 * @example
 * const array = [{ value: 1 }, { value: 2 }, { value: 3 }];
 * minBy(item => item.value, array); // => { value: 1 }
 * minBy(item => item.value * 2)(array); // => { value: 1 }
 */
declare const minBy: {
    <T, I>(fn: (value: T) => I, array: ArrayContainer<T>): T | undefined;
    <T, I>(fn: (value: T) => I): <T2 extends T>(array: ArrayContainer<T2>) => T2 | undefined;
};

/**
 * Finds the minimum value in an array using a custom comparator function
 *
 * @category Array
 * @param comparator - The comparison function that returns a negative number if a < b, 0 if a === b, or a positive number if a > b
 * @param array - The array to process
 * @returns Returns the element with the minimum value, or undefined if the array is empty
 * @example
 * const array = [{ value: 1 }, { value: 2 }, { value: 3 }];
 * minWith((a, b) => a.value - b.value, array); // => { value: 1 }
 * minWith((a, b) => b.value - a.value)(array); // => { value: 3 }
 */
declare const minWith: {
    <T>(comparator: Comparator<T, T>, array: ArrayContainer<T>): T | undefined;
    <T>(comparator: Comparator<T, T>): <T2 extends T>(array: ArrayContainer<T2>) => T2 | undefined;
};

/**
 * Moves an element in an array from one index to another
 *
 * @category Array
 * @param fromIndex - The index of the element to move
 * @param toIndex - The index to move the element to
 * @param array - The array to move the element in
 * @returns Returns a new array with the element moved
 * @example
 * const array = [1, 2, 3, 4, 5];
 * move(0, 4, array); // => [2, 3, 4, 5, 1]
 * move(-1, 0, array); // => [5, 1, 2, 3, 4]
 */
declare const move: {
    <T>(fromIndex: number, toIndex: number, array: ArrayContainer<T>): T[];
    (fromIndex: number, toIndex: number): <T>(array: ArrayContainer<T>) => T[];
    (fromIndex: number): {
        <T>(toIndex: number, array: ArrayContainer<T>): T[];
        (toIndex: number): <T>(array: ArrayContainer<T>) => T[];
    };
};

/**
 * Checks if none of the elements in the array satisfy the given predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to check
 * @returns Returns true if no elements satisfy the predicate function, false otherwise
 * @example
 * const array = [1, 2, 3, 4, 5];
 * none(x => x < 0, array); // true
 * none(x => x > 3, array); // false
 * none(x => x < 0)(array); // true
 */
declare const none: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): boolean;
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => boolean;
};

/**
 * Checks if none of the predicates return true for the given value
 *
 * @category Array
 * @param predicates - The array of predicate functions to test
 * @param value - The value to test against the predicates
 * @returns Returns true if none of the predicates return true, false otherwise
 * @example
 * const isEven = (x: number) => x % 2 === 0;
 * const isPositive = (x: number) => x > 0;
 * nonePass([isEven, isPositive], -1); // false
 * nonePass([isEven, isPositive])(-1); // false
 */
declare const nonePass: {
    <T>(predicates: ArrayContainer<ArrayCallback<T, boolean>>, value: T): boolean;
    <T>(predicates: ArrayContainer<ArrayCallback<T, boolean>>): <T2 extends T>(value: T2) => boolean;
};

/**
 * Returns a no-operation function.
 * This function is useful as a default or placeholder function.
 *
 * @category Function
 * @returns A function that does nothing
 * @example
 * noop() // undefined
 * noop(1, 2, 3) // undefined
 */
declare function noop(..._args: any[]): void;

/**
 * Gets the element at the specified index in an array
 *
 * @category Array
 * @param index - The index of the element to get
 * @param array - The array to get the element from
 * @returns Returns the element at the specified index, or undefined if the index is out of bounds
 * @example
 * const array = [1, 2, 3, 4, 5];
 * nth(2, array); // 3
 * nth(-1, array); // 5
 * nth(2)(array); // 3
 */
declare const nth: {
    <T>(index: number, array: ArrayContainer<T>): T | undefined;
    <T>(index: number): <T2 extends T>(array: ArrayContainer<T2>) => T2 | undefined;
};

/**
 * Creates a new object without the specified properties
 *
 * @category Object
 * @param keys - The array of property keys to omit
 * @param obj - The object to omit properties from
 * @returns Returns a new object without the specified properties
 * @example
 * const obj = { name: 'John', age: 30, city: 'New York' };
 * omit(['age'], obj); // { name: 'John', city: 'New York' }
 * omit(['name', 'city'])(obj); // { age: 30 }
 */
declare const omit: {
    <T extends Record<PropertyKey, any>, K extends PropertyKey>(keys: readonly (K | keyof T)[], obj: T): Omit<T, K>;
    <T extends Record<PropertyKey, any>, K extends PropertyKey>(keys: readonly (K | keyof T)[]): <T2 extends T>(obj: T2) => Omit<T2, K>;
};

declare const omitBy: {
    <T extends Record<PropertyKey, unknown>>(predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean, obj: T): Partial<T>;
    <T extends Record<PropertyKey, unknown>>(predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean): <T2 extends T>(obj: T2) => Partial<T2>;
};

/**
 * Creates a new array excluding elements at the specified indices
 *
 * @category Array
 * @param indices - The array of indices to omit
 * @param array - The array to omit from
 * @returns Returns a new array excluding elements at the specified indices
 * @example
 * const array = ['a', 'b', 'c', 'd'];
 * omitIndices([0, 2], array); // ['b', 'd']
 * omitIndices([1, 3], array); // ['a', 'c']
 */
declare const omitIndices: {
    <T, U extends number>(indices: ArrayContainer<U>, array: ArrayContainer<T>): T[];
    <T, U extends number>(indices: ArrayContainer<U>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

/**
 * @category Function
 * @description Creates a function that is restricted to invoking func once. Repeat calls to the function return the value of the first invocation.
 * @example
 * ```typescript
 * const f = once((x: number) => x + 1)
 * f(1) // => 2
 * f(2) // => 2 (first result is cached)
 * ```
 */
declare function once<T extends (...args: any[]) => any>(fn: T): T;

/**
 * Pads the array with a value on the left side until it reaches the specified length
 *
 * @category Array
 * @param length - The target length of the array
 * @param value - The value to pad with
 * @param array - The array to pad
 * @returns Returns a new array padded to the specified length
 * @example
 * const array = [1, 2, 3];
 * padLeft(5, 0, array); // [0, 0, 1, 2, 3]
 * padLeft(2, 0, array); // [1, 2, 3]
 */
declare const padLeft: {
    <T, U>(length: number, value: U, array: ArrayContainer<T>): (T | U)[];
    <T, U, N extends number>(length: N, value: U): <T_1>(array: ArrayContainer<T_1>) => (T_1 | U)[];
    <T, U, N extends number>(length: N): {
        <U2 extends U, T2 extends T>(value: U2, array: ArrayContainer<T2>): (T2 | U2)[];
        <U2 extends U>(value: U2): <T2_1 extends T>(array: ArrayContainer<T2_1>) => (T2_1 | U2)[];
    };
};

/**
 * Pads the array with a value on the right side until it reaches the specified length
 *
 * @category Array
 * @param length - The target length of the array
 * @param value - The value to pad with
 * @param array - The array to pad
 * @returns Returns a new array padded to the specified length
 * @example
 * const array = [1, 2, 3];
 * padRight(5, 0, array); // [1, 2, 3, 0, 0]
 * padRight(2, 0, array); // [1, 2, 3]
 */
declare const padRight: {
    <T, U, N extends number>(length: N, value: U, array: ArrayContainer<T>): (T | U)[];
    <T, U, N extends number>(length: N, value: U): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | U)[];
    <T, U, N extends number>(length: N): {
        <U2 extends U, T2 extends T>(value: U2, array: ArrayContainer<T2>): (T2 | U2)[];
        <U2 extends U>(value: U2): <T2_1 extends T>(array: ArrayContainer<T2_1>) => (T2_1 | U2)[];
    };
};

declare function pairwiseImpl<T>(array: ArrayContainer<T>): [T, T][];
/**
 * Returns an array of pairs from the input array, where each pair contains two consecutive elements
 * This is a special case of chunk(2)
 *
 * @category Array
 * @param array - The input array
 * @returns Returns an array of pairs
 * @example
 * const array = [1, 2, 3, 4, 5];
 * pairwise(array); // [[1, 2], [3, 4]]
 * pairwise([1, 2, 3]); // [[1, 2]]
 */
declare const pairwise: typeof pairwiseImpl;

/**
 * Splits an object into two parts based on the specified property list
 * @category Object
 * @param {readonly PropertyKey[]} pickProps - List of properties to keep
 * @param {T} obj - Object to split
 * @returns {[Pick<T, K>, Omit<T, K>]} A tuple containing two objects, first with picked properties, second with omitted properties
 * @example
 * ```ts
 * const obj = { a: 1, b: 2, c: 3 };
 * const [picked, omitted] = partition(['a', 'b'], obj);
 * // picked = { a: 1, b: 2 }
 * // omitted = { c: 3 }
 * ```
 */
declare const partition: {
    <T extends object, K extends keyof T>(pickProps: readonly K[], obj: T): [Pick<T, K>, Omit<T, K>];
    <K extends PropertyKey>(pickProps: readonly K[]): <T extends object & { [P in K]?: any; }>(obj: T) => [Pick<T, K>, Omit<T, K>];
};

/**
 * Partitions the array into two arrays based on the predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to spilt
 * @returns Returns a tuple containing two arrays: [elements that satisfy the predicate, elements that don't]
 * @example
 * const array = [1, 2, 3, 4, 5];
 * spiltBy(x => x % 2 === 0, array); // [[2, 4], [1, 3, 5]]
 * spiltBy(x => x % 2 === 0)(array); // [[2, 4], [1, 3, 5]]
 */
declare const splitBy: {
    <T>(predicate: (value: T, index: number, array: ArrayContainer<T>) => boolean, array: ArrayContainer<T>): [T[], T[]];
    <T>(predicate: (value: T, index: number, array: ArrayContainer<T>) => boolean): <T2 extends T>(array: ArrayContainer<T2>) => [T2[], T2[]];
};

type GetPathValue<T, P extends readonly PropertyKey[], D = unknown> = P extends readonly [] ? T : P extends readonly [infer Head, ...infer Tail extends readonly PropertyKey[]] ? Head extends keyof T ? GetPathValue<T[Head], Tail, D> : T extends readonly any[] ? Head extends number ? T[Head & number] extends infer ElementOrUndefined ? GetPathValue<ElementOrUndefined, Tail, D> : D : D : D : D;
/**
 * Returns the value at a given path in a nested object
 *
 * @category Object
 * @param path - The path to the value
 * @param obj - The object to get the value from
 * @returns Returns the value at the path or undefined if the path doesn't exist
 * @example
 * const obj = { user: { name: 'John', address: { city: 'New York' } } };
 * path(['user', 'name'], obj); // 'John'
 * path(['user', 'address', 'city'])(obj); // 'New York'
 *
 * const obj2 = { '0': 'zero', [Symbol('test')]: 'symbol' };
 * path(['0'], obj2); // 'zero'
 * path([Symbol('test')], obj2); // 'symbol'
 */
declare const path: {
    <T, const P extends ArrayContainer<PropertyKey>, D>(path: P, obj: T): GetPathValue<T, P, D>;
    <const P extends ArrayContainer<PropertyKey>>(path: P): <T, D>(obj: T) => GetPathValue<T, P, D>;
};

/**
 * Returns the value at a given path in a nested object, or a default value if the path doesn't exist
 *
 * @category Object
 * @param defaultValue - The default value to return if the path doesn't exist
 * @param path - The path to the value
 * @param obj - The object to get the value from
 * @returns Returns the value at the path or the default value
 * @example
 * const obj = { user: { name: 'John', address: { city: 'New York' } } };
 * pathOr('Unknown', ['user', 'name'], obj); // 'John'
 * pathOr('Unknown', ['user', 'age'])(obj); // 'Unknown'
 * pathOr('Unknown', ['user', 'address', 'city'])(obj); // 'New York'
 */
declare const pathOr: {
    <const T, const P extends ArrayContainer<PropertyKey>, D>(defaultValue: D, path: P, obj: T): GetPathValue<T, P, D>;
    <const T, const P extends ArrayContainer<PropertyKey>, D>(defaultValue: D, path: P): <T2 extends T>(obj: T2) => GetPathValue<T2, P, D>;
    <const T, const P extends ArrayContainer<PropertyKey>, D>(defaultValue: D): {
        <const T2 extends T>(path: P, obj: T2): GetPathValue<T2, P, D>;
        <const P2 extends P>(path: P2): <const T2 extends T>(obj: T2) => GetPathValue<T2, P2, D>;
    };
};

/**
 * Creates a new object with only the specified properties
 *
 * @category Object
 * @param keys - The array of property keys to pick
 * @param obj - The object to pick properties from
 * @returns Returns a new object with only the specified properties
 * @example
 * const obj = { name: 'John', age: 30, city: 'New York' };
 * pick(['name', 'age'], obj); // { name: 'John', age: 30 }
 * pick(['name'])(obj); // { name: 'John' }
 */
declare const pick: {
    <T extends Record<PropertyKey, any>, K extends PropertyKey>(keys: readonly (K | keyof T)[], obj: T): Pick<T, K>;
    <T extends Record<PropertyKey, any>, K extends PropertyKey>(keys: readonly (K | keyof T)[]): <T2 extends T>(obj: T2) => Pick<T2, K>;
};

declare const pickBy: {
    <T extends Record<PropertyKey, unknown>>(predicate: (value: T[keyof T], key: keyof T) => boolean, obj: T): Partial<T>;
    <T extends Record<PropertyKey, unknown>>(predicate: (value: T[keyof T], key: keyof T) => boolean): <T2 extends T>(obj: T2) => Partial<T2>;
};

/**
 * Creates a new array with elements from the input array at the specified indices
 *
 * @category Array
 * @param indices - The array of indices to pick
 * @param array - The array to pick from
 * @returns Returns a new array containing elements at the specified indices
 * @example
 * const array = ['a', 'b', 'c', 'd'];
 * pickIndices([0, 2], array); // ['a', 'c']
 * pickIndices([1, 3, 5], array); // ['b', 'd']
 */
declare const pickIndices: {
    <T>(indices: number[], array: ArrayContainer<T>): T[];
    (indices: number[]): <T>(array: ArrayContainer<T>) => T[];
};

declare function pipe<A>(data: A): A;
declare function pipe<Data, R1>(data: Data, f1: (arg: Data) => R1): R1;
declare function pipe<Data, R1, R2>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2): R2;
declare function pipe<Data, R1, R2, R3>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3): R3;
declare function pipe<Data, R1, R2, R3, R4>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4): R4;
declare function pipe<Data, R1, R2, R3, R4, R5>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5): R5;
declare function pipe<Data, R1, R2, R3, R4, R5, R6>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6): R6;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7): R7;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8): R8;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9): R9;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10): R10;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11): R11;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12): R12;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13): R13;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14): R14;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15): R15;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16): R16;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17): R17;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17, f18: (arg: R17) => R18): R18;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17, f18: (arg: R17) => R18, f19: (arg: R18) => R19): R19;
declare function pipe<Data, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20>(data: Data, f1: (data: Data) => R1, f2: (arg: R1) => R2, f3: (arg: R2) => R3, f4: (arg: R3) => R4, f5: (arg: R4) => R5, f6: (arg: R5) => R6, f7: (arg: R6) => R7, f8: (arg: R7) => R8, f9: (arg: R8) => R9, f10: (arg: R9) => R10, f11: (arg: R10) => R11, f12: (arg: R11) => R12, f13: (arg: R12) => R13, f14: (arg: R13) => R14, f15: (arg: R14) => R15, f16: (arg: R15) => R16, f17: (arg: R16) => R17, f18: (arg: R17) => R18, f19: (arg: R18) => R19, f20: (arg: R19) => R20): R20;

declare function flowAsync(): <T>(x: T) => Awaitable<T>;
declare function flowAsync<R1 extends AwaitableFunction>(f1: R1): R1;
declare function flowAsync<Args extends readonly any[], R1, R2>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>): AwaitableFunction<Args, R2>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>): AwaitableFunction<Args, R3>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>): AwaitableFunction<Args, R4>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>): AwaitableFunction<Args, R5>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>): AwaitableFunction<Args, R6>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>): AwaitableFunction<Args, R7>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>): AwaitableFunction<Args, R8>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>): AwaitableFunction<Args, R9>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>): AwaitableFunction<Args, R10>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>): AwaitableFunction<Args, R11>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>): AwaitableFunction<Args, R12>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>): AwaitableFunction<Args, R13>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>, f14: AwaitableFunction<[Awaited<R13>], R14>): AwaitableFunction<Args, R14>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>, f14: AwaitableFunction<[Awaited<R13>], R14>, f15: AwaitableFunction<[Awaited<R14>], R15>): AwaitableFunction<Args, R15>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>, f14: AwaitableFunction<[Awaited<R13>], R14>, f15: AwaitableFunction<[Awaited<R14>], R15>, f16: AwaitableFunction<[Awaited<R15>], R16>): AwaitableFunction<Args, R16>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>, f14: AwaitableFunction<[Awaited<R13>], R14>, f15: AwaitableFunction<[Awaited<R14>], R15>, f16: AwaitableFunction<[Awaited<R15>], R16>, f17: AwaitableFunction<[Awaited<R16>], R17>): AwaitableFunction<Args, R17>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>, f14: AwaitableFunction<[Awaited<R13>], R14>, f15: AwaitableFunction<[Awaited<R14>], R15>, f16: AwaitableFunction<[Awaited<R15>], R16>, f17: AwaitableFunction<[Awaited<R16>], R17>, f18: AwaitableFunction<[Awaited<R17>], R18>): AwaitableFunction<Args, R18>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>, f14: AwaitableFunction<[Awaited<R13>], R14>, f15: AwaitableFunction<[Awaited<R14>], R15>, f16: AwaitableFunction<[Awaited<R15>], R16>, f17: AwaitableFunction<[Awaited<R16>], R17>, f18: AwaitableFunction<[Awaited<R17>], R18>, f19: AwaitableFunction<[Awaited<R18>], R19>): AwaitableFunction<Args, R19>;
declare function flowAsync<Args extends readonly any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20>(f1: AwaitableFunction<Args, R1>, f2: AwaitableFunction<[Awaited<R1>], R2>, f3: AwaitableFunction<[Awaited<R2>], R3>, f4: AwaitableFunction<[Awaited<R3>], R4>, f5: AwaitableFunction<[Awaited<R4>], R5>, f6: AwaitableFunction<[Awaited<R5>], R6>, f7: AwaitableFunction<[Awaited<R6>], R7>, f8: AwaitableFunction<[Awaited<R7>], R8>, f9: AwaitableFunction<[Awaited<R8>], R9>, f10: AwaitableFunction<[Awaited<R9>], R10>, f11: AwaitableFunction<[Awaited<R10>], R11>, f12: AwaitableFunction<[Awaited<R11>], R12>, f13: AwaitableFunction<[Awaited<R12>], R13>, f14: AwaitableFunction<[Awaited<R13>], R14>, f15: AwaitableFunction<[Awaited<R14>], R15>, f16: AwaitableFunction<[Awaited<R15>], R16>, f17: AwaitableFunction<[Awaited<R16>], R17>, f18: AwaitableFunction<[Awaited<R17>], R18>, f19: AwaitableFunction<[Awaited<R18>], R19>, f20: AwaitableFunction<[Awaited<R19>], R20>): AwaitableFunction<Args, R20>;

/**
 * Extracts a list of property values from an array of objects
 *
 * @category Array
 * @param key - The property key to extract
 * @param array - The array of objects
 * @returns Returns an array containing the values of the specified property
 * @example
 * const array = [{name: 'John', age: 30}, {name: 'Jane', age: 25}];
 * pluck('name', array); // ['John', 'Jane']
 * pluck('age', array); // [30, 25]
 * pluck('name')(array); // ['John', 'Jane']
 */
declare const pluck: {
    <const K extends PropertyKey, T extends readonly { [P in K]?: unknown; }[]>(key: K, array: T): Pluck<T, K>;
    <const K extends PropertyKey>(key: K): <T extends readonly { [P in K]?: unknown; }[]>(array: T) => Pluck<T, K>;
};
type Pluck<T extends readonly {
    [P in K]?: unknown;
}[], K extends PropertyKey> = {
    [I in keyof T]: T[I] extends {
        [P in K]?: unknown;
    } ? T[I][K] : never;
};

/**
 * Adds an item to the beginning of an array
 *
 * @category Array
 * @param item - The item to add
 * @param array - The array to prepend to
 * @returns Returns a new array with the item added at the beginning
 * @example
 * const array = [1, 2, 3];
 * prepend(0, array); // [0, 1, 2, 3]
 * prepend('a')([1, 2, 3]); // ['a', 1, 2, 3]
 */
declare const prepend: {
    <T, U>(item: U, array: ArrayContainer<T>): (T | U)[];
    <T, U>(item: U): <T2 extends T>(array: ArrayContainer<T2>) => (T | U)[];
};

declare function productImpl<T extends number>(array: ArrayContainer<T>): number;
/**
 * Calculates the product of all numbers in an array
 *
 * @category Array
 * @param array - The array of numbers
 * @returns Returns the product of all numbers, or 1 if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * product(array); // => 120
 * product([1, 2, 3, 4]); // => 24
 */
declare const product: typeof productImpl;

/**
 * Returns the value of a property from an object
 *
 * @category Object
 * @param key - The property key to get
 * @param obj - The object to get the property from
 * @returns Returns the value of the property
 * @example
 * const obj = { name: 'John', age: 30 };
 * prop('name', obj); // 'John'
 * prop('age')(obj); // 30
 */
declare const prop: {
    <T, const K extends keyof T>(key: K, obj: T): T[K];
    <const K extends PropertyKey>(key: K): <T, const K2 extends keyof T & K>(obj: T) => K2 extends keyof T ? T[K2] : never;
};

/**
 * Returns the value of a property from an object, or a default value if the property doesn't exist
 *
 * @category Object
 * @param defaultValue - The default value to return if the property doesn't exist
 * @param key - The property key to get
 * @param obj - The object to get the property from
 * @returns Returns the value of the property or the default value
 * @example
 * const obj = { name: 'John', age: 30 };
 * propOr('Unknown', 'name', obj); // 'John'
 * propOr(0, 'age')(obj); // 30
 * propOr('Unknown', 'address')(obj); // 'Unknown'
 */
declare const propOr: {
    <T extends Record<PropertyKey, unknown>, K extends keyof T = keyof T, D = unknown>(defaultValue: D, key: K, obj: T): T[K] | D;
    <T extends Record<PropertyKey, unknown>, K extends keyof T = keyof T, D = unknown>(defaultValue: D, key: K): (obj: T) => T[K] | D;
    <T extends Record<PropertyKey, unknown>, K extends keyof T = keyof T, D = unknown>(defaultValue: D): {
        (key: K, obj: T): T[K] | D;
        (key: K): (obj: T) => T[K] | D;
    };
};

/**
 * Creates an array of numbers from start to end (exclusive) with optional step
 *
 * @category Array
 * @param from - The start of the range (inclusive)
 * @param to - The end of the range (exclusive)
 * @param step - The step between numbers (default: 1)
 * @returns Returns an array of numbers
 * @example
 * range(0, 5); // [0, 1, 2, 3, 4]
 * range(0, 5, 2); // [0, 2, 4]
 * range(5, 0, -1); // [5, 4, 3, 2, 1]
 */
declare const range: {
    (from: number, to: number, step: number): number[];
    (from: number, to: number): (step: number) => number[];
    (from: number): {
        (to: number, step: number): number[];
        (to: number): (step: number) => number[];
    };
};

declare const reduce: {
    <T, A, R>(reducer: ArrayReducer<A, T, R>, initialValue: A, array: ArrayContainer<T>): R;
    <T, A>(reducer: ArrayReducer<A, T, A>, initialValue: A): <T2 extends T>(array: ArrayContainer<T2>) => A;
    <T, A>(reducer: ArrayReducer<A, T, A>): {
        <T2 extends T, A2 extends A>(initialValue: A, array: ArrayContainer<T2>): A2 | A;
        <const A2_1 extends A>(initialValue: A2_1): <T2 extends T>(array: ArrayContainer<T2>) => A2_1 | A;
    };
};

/**
 * Reduces the array from right to left using the provided reducer function
 *
 * @category Array
 * @param reducer - The reducer function to apply
 * @param initialValue - The initial value for the reduction
 * @param array - The array to reduce
 * @returns Returns the reduced value
 * @example
 * const array = [1, 2, 3, 4, 5];
 * reduceRight((acc, val) => acc + val, 0, array); // 15
 * reduceRight((acc, val) => acc + val, 0)(array); // 15
 */
declare const reduceRight: {
    <T, A>(reducer: ArrayReducer<A, T>, initialValue: A, array: ArrayContainer<T>): A;
    <T, A>(reducer: ArrayReducer<A, T>, initialValue: A): <T2 extends T>(array: ArrayContainer<T2>) => A;
    <T, A>(reducer: ArrayReducer<A, T>): {
        <T2 extends T, A2 extends A>(initialValue: A, array: ArrayContainer<T2>): A2 | A;
        <const A2_1 extends A>(initialValue: A2_1): <T2 extends T>(array: ArrayContainer<T2>) => A2_1 | A;
    };
};

/**
 * Reduces the array from right to left while the predicate function returns true
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param reducer - The reducer function to apply
 * @param initialValue - The initial value for the reduction
 * @param array - The array to reduce
 * @returns Returns the reduced value
 * @example
 * const array = [1, 2, 3, 4, 5];
 * reduceRightWhile(
 *   (acc, val) => acc + val < 10,
 *   (acc, val) => acc + val,
 *   0,
 *   array
 * ); // 9
 */
declare const reduceRightWhile: {
    <T, A>(predicate: ArrayReducer<A, T, boolean>, reducer: ArrayReducer<A, T, A>, initialValue: A, array: ArrayContainer<T>): A;
    <T, A>(predicate: ArrayReducer<A, T, boolean>, reducer: ArrayReducer<A, T, A>, initialValue: A): <T2 extends T>(array: ArrayContainer<T2>) => A;
    <T, A>(predicate: ArrayReducer<A, T, boolean>, reducer: ArrayReducer<A, T, A>): {
        <T2 extends T, A2 extends A>(initialValue: A2, array: ArrayContainer<T2>): A2 | A;
        <const A2_1 extends A>(initialValue: A2_1): <T2 extends T>(array: ArrayContainer<T2>) => A2_1 | A;
    };
    <T, A>(predicate: ArrayReducer<A, T, boolean>): {
        <T2 extends T, const A2 extends A>(reducer: ArrayReducer<A2, T2, A2>, initialValue: A2, array: ArrayContainer<T2>): A2 | A2;
        <T2 extends T, const A2_1 extends A>(reducer: ArrayReducer<A2_1, T2, A2_1>, initialValue: A2_1): <T3 extends T2>(array: ArrayContainer<T3>) => A2_1 | A2_1;
        <T2 extends T, A2_2 extends A>(reducer: ArrayReducer<A2_2, T2, A2_2>): {
            <T3 extends T2, const A3 extends A2_2>(initialValue: A3, array: ArrayContainer<T3>): A3 | A2_2;
            <const A3_1 extends A2_2>(initialValue: A3_1): <T3 extends T2>(array: ArrayContainer<T3>) => A3_1 | A2_2;
        };
    };
};

/**
 * Reduces the array while the predicate function returns true
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param reducer - The reducer function to apply
 * @param initialValue - The initial value for the reduction
 * @param array - The array to reduce
 * @returns Returns the reduced value
 * @example
 * const array = [1, 2, 3, 4, 5];
 * reduceWhile(
 *   (acc, val) => acc + val < 10,
 *   (acc, val) => acc + val,
 *   0,
 *   array
 * ); // 6
 */
declare const reduceWhile: {
    <T, A>(predicate: ArrayReducer<A, T, boolean>, reducer: ArrayReducer<A, T, A>, initialValue: A, array: ArrayContainer<T>): A;
    <T, A>(predicate: ArrayReducer<A, T, boolean>, reducer: ArrayReducer<A, T, A>, initialValue: A): <T2 extends T>(array: ArrayContainer<T2>) => A;
    <T, A>(predicate: ArrayReducer<A, T, boolean>, reducer: ArrayReducer<A, T, A>): {
        <T2 extends T, A2 extends A>(initialValue: A2, array: ArrayContainer<T2>): A2 | A;
        <const A2_1 extends A>(initialValue: A2_1): <T2 extends T>(array: ArrayContainer<T2>) => A2_1 | A;
    };
    <T, A>(predicate: ArrayReducer<A, T, boolean>): {
        <T2 extends T, const A2 extends A>(reducer: ArrayReducer<A2, T2, A2>, initialValue: A2, array: ArrayContainer<T2>): A2 | A2;
        <T2 extends T, const A2_1 extends A>(reducer: ArrayReducer<A2_1, T2, A2_1>, initialValue: A2_1): <T3 extends T2>(array: ArrayContainer<T3>) => A2_1 | A2_1;
        <T2 extends T, A2_2 extends A>(reducer: ArrayReducer<A2_2, T2, A2_2>): {
            <T3 extends T2, const A3 extends A2_2>(initialValue: A3, array: ArrayContainer<T3>): A3 | A2_2;
            <const A3_1 extends A2_2>(initialValue: A3_1): <T3 extends T2>(array: ArrayContainer<T3>) => A3_1 | A2_2;
        };
    };
};

/**
 * Filters out elements that satisfy the predicate function
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to filter
 * @returns Returns a new array containing elements that do not satisfy the predicate
 * @example
 * const array = [1, 2, 3, 4, 5];
 * reject(x => x > 3, array); // [1, 2, 3]
 * reject(x => x % 2 === 0, array); // [1, 3, 5]
 */
declare const reject: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T[];
    <T>(predicate: ArrayPredicate<T>): (array: ArrayContainer<T>) => T[];
};

/**
 * Removes an element at the specified index from an array
 *
 * @category Array
 * @param index - The index of the element to remove
 * @param array - The array to remove from
 * @returns Returns a new array with the element removed
 * @example
 * const array = [1, 2, 3, 4, 5];
 * remove(2, array); // [1, 2, 4, 5]
 * remove(-1, array); // [1, 2, 3, 4]
 * remove(2)(array); // [1, 2, 4, 5]
 */
declare const remove: {
    <T>(index: number, array: ArrayContainer<T>): T[];
    <T>(index: number): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

/**
 * Creates an array with the specified value repeated count times
 *
 * @category Array
 * @param value - The value to repeat
 * @param count - The number of times to repeat the value
 * @returns Returns an array with the value repeated count times
 * @example
 * repeat('a', 3); // ['a', 'a', 'a']
 * repeat(42, 2); // [42, 42]
 * repeat({ id: 1 }, 2); // [{ id: 1 }, { id: 1 }]
 * repeat('a')(3); // ['a', 'a', 'a']
 */
declare const repeat: {
    <T>(value: T, count: number): T[];
    <T>(value: T): (count: number) => T[];
};

declare function reverseImpl<T>(array: ArrayContainer<T>): T[];
/**
 * Reverses the elements of an array
 *
 * @category Array
 * @param array - The array to reverse
 * @returns Returns a new array with elements in reverse order
 * @example
 * const array = [1, 2, 3, 4, 5];
 * reverse(array); // [5, 4, 3, 2, 1]
 * reverse(['a', 'b', 'c']); // ['c', 'b', 'a']
 */
declare const reverse: typeof reverseImpl;

/**
 * Rotates the array to the left by n positions
 *
 * @category Array
 * @param n - The number of positions to rotate
 * @param array - The array to rotate
 * @returns Returns a new array rotated to the left by n positions
 * @example
 * const array = [1, 2, 3, 4, 5];
 * rotateLeft(2, array); // [3, 4, 5, 1, 2]
 * rotateLeft(-2, array); // [4, 5, 1, 2, 3]
 * rotateLeft(2)(array); // [3, 4, 5, 1, 2]
 */
declare const rotateLeft: {
    <T>(offset: number, array: ArrayContainer<T>): T[];
    <T>(offset: number): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

/**
 * Rotates the array to the right by n positions
 *
 * @category Array
 * @param n - The number of positions to rotate
 * @param array - The array to rotate
 * @returns Returns a new array rotated to the right by n positions
 * @example
 * const array = [1, 2, 3, 4, 5];
 * rotateRight(2, array); // [4, 5, 1, 2, 3]
 * rotateRight(-2, array); // [3, 4, 5, 1, 2]
 * rotateRight(2)(array); // [4, 5, 1, 2, 3]
 */
declare const rotateRight: {
    <T>(offset: number, array: ArrayContainer<T>): T[];
    <T>(offset: number): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

declare function sampleImpl<T>(array: ArrayContainer<T>): T | undefined;
/**
 * Returns a random element from the array
 *
 * @category Array
 * @param array - The array to sample from
 * @returns Returns a random element from the array, or undefined if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * sample(array); // Returns a random element from the array
 * sample([]); // undefined
 */
declare const sample: typeof sampleImpl;

/**
 * Returns n random elements from the array
 *
 * @category Array
 * @param size - The number of elements to sample
 * @param array - The array to sample from
 * @returns Returns an array of n random elements from the array
 * @example
 * const array = [1, 2, 3, 4, 5];
 * sampleSize(2, array); // Returns an array of 2 random elements
 * sampleSize(10, array); // Returns a shuffled copy of the array
 * sampleSize(2)(array); // Returns an array of 2 random elements
 */
declare const sampleSize: {
    <T>(size: number, array: ArrayContainer<T>): T[];
    (size: number): <T>(array: ArrayContainer<T>) => T[];
};

/**
 * Performs a cumulative scan over an array, returning an array of intermediate results
 *
 * @category Array
 * @param reducer - The function used for accumulation
 * @param initialValue - The initial accumulation value
 * @param array - The array to scan
 * @returns Returns an array containing all intermediate accumulation results
 * @example
 * const numbers = [1, 2, 3, 4, 5];
 * scan((acc, curr) => acc + curr, 0, numbers); // [0, 1, 3, 6, 10, 15]
 * scan((acc, curr) => acc + curr, 0)(numbers); // [0, 1, 3, 6, 10, 15]
 */
declare const scan: {
    <T, A>(reducer: ArrayReducer<A, T>, initialValue: A, array: ArrayContainer<T>): A[];
    <T, A>(reducer: ArrayReducer<A, T>, initialValue: A): <T2 extends T>(array: ArrayContainer<T2>) => A[];
    <T, A>(reducer: ArrayReducer<A, T>): {
        <T2 extends T, A2 extends A>(initialValue: A, array: ArrayContainer<T2>): (A2 | A)[];
        <const A2_1 extends A>(initialValue: A2_1): <T2 extends T>(array: ArrayContainer<T2>) => (A2_1 | A)[];
    };
};

/**
 * Scans the array from right to left using the provided reducer function, returning an array of all intermediate values
 *
 * @category Array
 * @param reducer - The reducer function to apply
 * @param initialValue - The initial value for the reduction
 * @param array - The array to scan
 * @returns Returns an array containing all intermediate values
 * @example
 * const array = [1, 2, 3, 4, 5];
 * scanRight((acc, val) => acc + val, 0, array); // [15, 14, 12, 9, 5, 0]
 * scanRight((acc, val) => acc + val, 0)(array); // [15, 14, 12, 9, 5, 0]
 */
declare const scanRight: {
    <T, A>(reducer: ArrayReducer<A, T>, initialValue: A, array: ArrayContainer<T>): A[];
    <T, A>(reducer: ArrayReducer<A, T>, initialValue: A): <T2 extends T>(array: ArrayContainer<T2>) => A[];
    <T, A>(reducer: ArrayReducer<A, T>): {
        <T2 extends T, A2 extends A>(initialValue: A, array: ArrayContainer<T2>): (A2 | A)[];
        <const A2_1 extends A>(initialValue: A2_1): <T2 extends T>(array: ArrayContainer<T2>) => (A2_1 | A)[];
    };
};

/**
 * Sets a property value on an object and returns a new object with the updated property
 *
 * @category Object
 * @param key - The property key to set
 * @param value - The value to set
 * @param obj - The object to set the property on
 * @returns Returns a new object with the updated property
 * @example
 * const obj = { name: 'John', age: 30 };
 * set('age', 31, obj); // { name: 'John', age: 31 }
 * set('age')(31)(obj); // { name: 'John', age: 31 }
 */
declare const set: {
    <T extends Record<PropertyKey, unknown>, const K extends PropertyKey, const V>(key: K | keyof T, value: V | T[K], obj: T): T & { [p in K]: V; };
    <T extends Record<PropertyKey, unknown>, const K extends PropertyKey, const V>(key: K | keyof T, value: V | T[K]): <T2 extends T>(obj: T2) => T2 & { [p in K]: V; };
    <T extends Record<PropertyKey, unknown>, const K extends PropertyKey>(key: K | keyof T): {
        <T2 extends T, const V>(value: V | T2[K], obj: T2): T2 & { [p in K]: V; };
        <const V_1>(value: V_1): <T2 extends T>(obj: T2) => T2 & { [p in K]: V_1; };
    };
};

/**
 * Sets a value at a given path in a nested object and returns a new object.
 * If the path doesn't exist, it will be created automatically.
 * For non-negative integer keys, arrays will be created; for other keys, objects will be created.
 *
 * @category Object
 * @param path - The path to set the value at
 * @param value - The value to set
 * @param obj - The object to set the value in
 * @returns Returns a new object with the value set at the given path
 * @throws {Error} If trying to set a property of null or non-object
 * @example
 * const obj = { user: { name: 'John', age: 30 } };
 * setPath(['user', 'age'], 31, obj); // { user: { name: 'John', age: 31 } }
 * setPath(['user', 'age'])(31)(obj); // { user: { name: 'John', age: 31 } }
 * setPath(['user', 'address', 'city'], 'New York', obj); // { user: { name: 'John', age: 30, address: { city: 'New York' } } }
 * setPath(['items', 0, 'name'], 'Item 1', {}); // { items: [{ name: 'Item 1' }] }
 */
declare const setPath: {
    <T, const P extends readonly PropertyKey[], const V>(path: P, value: V, obj: T): SetByPath<T, P, V>;
    <T, const P extends readonly PropertyKey[], const V>(path: P, value: V): <T2 extends T>(obj: T2) => SetByPath<T, P, V>;
    <T, const P extends readonly PropertyKey[]>(path: P): {
        <T2 extends T, const V>(value: V, obj: T2): SetByPath<T, P, V>;
        <const V_1>(value: V_1): <T2 extends T>(obj: T2) => SetByPath<T, P, V_1>;
    };
};
type IsNumberKey<K> = K extends number ? true : K extends `${number}` ? true : false;
type ToNumber<S extends string> = S extends `${infer N extends number}` ? N : never;
type CreateTupleWithValue<Index extends number, Value, Rest = unknown> = {
    [K in Index]: Value;
} & {
    [k: number]: Rest;
};
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
type SetByPath<Obj, Path extends readonly PropertyKey[], Value> = Path extends readonly [] ? Obj : Path extends readonly [infer First extends PropertyKey, ...infer Rest extends PropertyKey[]] ? IsNumberKey<First> extends true ? First extends `${infer N extends number}` ? Rest['length'] extends 0 ? Obj extends any[] ? Omit<Obj, N> & Record<N, Value> : Prettify<CreateTupleWithValue<ToNumber<`${N}`>, Value>> : Obj extends any[] ? Omit<Obj, N> & Record<N, SetByPath<Obj[ToNumber<`${N}`>] extends undefined ? {} : Obj[ToNumber<`${N}`>], Rest, Value>> : Prettify<CreateTupleWithValue<ToNumber<`${N}`>, SetByPath<{}, Rest, Value>>> : First extends number ? Rest['length'] extends 0 ? Obj extends any[] ? Omit<Obj, `${First}`> & Record<`${First}`, Value> : Prettify<CreateTupleWithValue<First, Value>> : Obj extends any[] ? Omit<Obj, `${First}`> & Record<`${First}`, SetByPath<Obj[First] extends undefined ? {} : Obj[First], Rest, Value>> : Prettify<CreateTupleWithValue<First, SetByPath<{}, Rest, Value>>> : never : Rest['length'] extends 0 ? Obj extends object ? Prettify<Omit<Obj, First> & Record<First & string, Value>> : Prettify<Record<First & string, Value>> : Obj extends object ? Prettify<Omit<Obj, First> & Record<First & string, SetByPath<First extends keyof Obj ? Obj[First] : {}, Rest, Value>>> : Prettify<Record<First & string, SetByPath<{}, Rest, Value>>> : Obj;

declare function shuffleImpl<T>(array: ArrayContainer<T>): T[];
/**
 * Randomly shuffles the array using the Fisher-Yates algorithm
 *
 * @category Array
 * @param array - The array to shuffle
 * @returns Returns a new array with elements in random order
 * @example
 * const array = [1, 2, 3, 4, 5];
 * shuffle(array); // [3, 1, 5, 2, 4] (random order)
 */
declare const shuffle: typeof shuffleImpl;

/**
 * Returns a slice of an array from start to end (exclusive)
 *
 * @category Array
 * @param start - The start index
 * @param end - The end index (exclusive)
 * @param array - The array to slice
 * @returns Returns a new array containing the sliced elements
 * @example
 * const array = [1, 2, 3, 4, 5];
 * slice(1, 3, array); // [2, 3]
 * slice(1)(3, array); // [2, 3]
 * slice(1, 3)(array); // [2, 3]
 */
declare const slice: {
    <T>(start: number, end: number | undefined, array: ArrayContainer<T>): T[];
    <T>(start: number, end: number | undefined): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
    <T>(start: number): {
        <T2 extends T>(end: number | undefined, array: ArrayContainer<T2>): T2[];
        (end: number | undefined): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
    };
};

declare function sortImpl<T>(array: ArrayContainer<T>): T[];
/**
 * Sorts the elements of an array in ascending order
 *
 * @category Array
 * @param array - The array to sort
 * @returns Returns a new sorted array
 * @example
 * const array = [3, 1, 4, 1, 5];
 * sort(array); // [1, 1, 3, 4, 5]
 * sort(['c', 'a', 'b']); // ['a', 'b', 'c']
 */
declare const sort: typeof sortImpl;

/**
 * Sorts the elements of an array based on the values returned by the given function
 *
 * @category Array
 * @param fn - The function to determine the sort order
 * @param array - The array to sort
 * @returns Returns a new sorted array
 * @example
 * const array = [{id: 3}, {id: 1}, {id: 2}];
 * sortBy(x => x.id, array); // [{id: 1}, {id: 2}, {id: 3}]
 * sortBy(x => x.id)(array); // [{id: 1}, {id: 2}, {id: 3}]
 */
declare const sortBy: {
    <T, U extends number | undefined>(fn: (item: T) => U, array: ArrayContainer<T>): T[];
    <T, U extends number | undefined>(fn: (item: T) => U): (array: ArrayContainer<T>) => T[];
};

/**
 * Sorts the elements of an array using a custom comparator function
 *
 * @category Array
 * @param comparator - The comparator function to determine sort order
 * @param array - The array to sort
 * @returns Returns a new sorted array
 * @example
 * const array = [3, 1, 4, 1, 5];
 * sortWith((a, b) => b - a, array); // [5, 4, 3, 1, 1]
 * sortWith((a, b) => b - a)(array); // [5, 4, 3, 1, 1]
 */
declare const sortWith: {
    <T>(comparator: Comparator<T, T>, array: ArrayContainer<T>): T[];
    <T>(comparator: Comparator<T, T>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

/**
 * Modifies the contents of an array by removing or replacing existing elements and/or adding new elements
 *
 * @category Array
 * @param start - The index at which to begin changing the array
 * @param deleteCount - The number of elements to remove
 * @param items - The elements to add to the array
 * @param array - The array to modify
 * @returns Returns a new array with the specified changes
 * @example
 * const array = [1, 2, 3, 4, 5];
 * splice(1, 2, [6, 7], array); // [1, 6, 7, 4, 5]
 * splice(1, 2)([6, 7])(array); // [1, 6, 7, 4, 5]
 */
declare const splice: {
    <T, U>(start: number, deleteCount: number, items: ArrayContainer<U>, array: ArrayContainer<T>): (T | U)[];
    <T, U>(start: number, deleteCount: number, items: ArrayContainer<U>): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | U)[];
    <T, U>(start: number, deleteCount: number): {
        <T2 extends T, U2 extends U>(items: ArrayContainer<U2>, array: ArrayContainer<T2>): (T2 | U2)[];
        <U2_1 extends U>(items: ArrayContainer<U2_1>): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | U2_1)[];
    };
    <T, U>(start: number): {
        <T2 extends T, U2 extends U>(deleteCount: number, items: ArrayContainer<U2>, array: ArrayContainer<T2>): (T2 | U2)[];
        <U2_1 extends U>(deleteCount: number, items: ArrayContainer<U2_1>): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | U2_1)[];
        (deleteCount: number): {
            <T2 extends T, U2_1 extends U>(items: ArrayContainer<U2_1>, array: ArrayContainer<T2>): (T2 | U2_1)[];
            <U2_2 extends U>(items: ArrayContainer<U2_2>): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | U2_2)[];
        };
    };
};

/**
 * Splits an array into two parts at the specified index
 *
 * @category Array
 * @param index - The index at which to split the array
 * @param array - The array to split
 * @returns Returns a tuple of two arrays, split at the given index
 * @example
 * const array = [1, 2, 3, 4, 5];
 * splitAt(2, array); // [[1, 2], [3, 4, 5]]
 * splitAt(2)(array); // [[1, 2], [3, 4, 5]]
 */
declare const splitAt: {
    <T>(index: number, array: ArrayContainer<T>): [T[], T[]];
    <T>(index: number): <T2 extends T>(array: ArrayContainer<T2>) => [T2[], T2[]];
};

/**
 * Splits the array into two parts at the first element that satisfies the predicate
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to split
 * @returns Returns a tuple containing two arrays: [elements before the first match, elements from the first match onwards]
 * @example
 * const array = [1, 2, 3, 4, 5];
 * splitWhen(x => x > 3, array); // [[1, 2, 3], [4, 5]]
 * splitWhen(x => x > 3)(array); // [[1, 2, 3], [4, 5]]
 */
declare const splitWhen: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): [T[], T[]];
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => [T2[], T2[]];
};

declare function sumImpl<T extends number>(array: ArrayContainer<T>): number;
/**
 * Calculates the sum of all numbers in an array
 *
 * @category Array
 * @param array - The array of numbers
 * @returns Returns the sum of all numbers, or 0 if the array is empty
 * @example
 * const array = [1, 2, 3, 4, 5];
 * sum(array); // => 15
 * sum([1, 2, 3, 4]); // => 10
 */
declare const sum: typeof sumImpl;

/**
 * Calculates the sum of values in an array by applying a function to each element
 *
 * @category Array
 * @param fn - The function to apply to each element
 * @param array - The array to process
 * @returns Returns the sum of the values returned by the function
 * @example
 * const array = [{ value: 1 }, { value: 2 }, { value: 3 }];
 * sumBy(item => item.value, array); // => 6
 * sumBy(item => item.value * 2)(array); // => 12
 */
declare const sumBy: {
    <T>(fn: (value: T) => number, array: ArrayContainer<T>): number;
    <T>(fn: (value: T) => number): <T2 extends T>(array: ArrayContainer<T2>) => number;
};

/**
 * Swaps two elements in an array at the specified indices
 *
 * @category Array
 * @param index1 - The index of the first element to swap
 * @param index2 - The index of the second element to swap
 * @param array - The array to swap elements in
 * @returns Returns a new array with the elements swapped
 * @example
 * const array = [1, 2, 3, 4, 5];
 * swap(0, 4, array); // => [5, 2, 3, 4, 1]
 * swap(-1, -2, array); // => [1, 2, 3, 5, 4]
 */
declare const swap: {
    <T>(index1: number, index2: number, array: ArrayContainer<T>): T[];
    (index1: number, index2: number): <T>(array: ArrayContainer<T>) => T[];
    (index1: number): {
        <T>(index2: number, array: ArrayContainer<T>): T[];
        (index2: number): <T>(array: ArrayContainer<T>) => T[];
    };
};

/**
 * Returns an array containing elements that exist in either array but not in both arrays
 *
 * @category Array
 * @param array1 - The first array to compare
 * @param array2 - The second array to compare against
 * @returns Returns a new array containing elements unique to either array
 * @example
 * const array1 = [1, 2, 3, 4, 5];
 * const array2 = [2, 4, 6];
 * symmetricDifference(array1, array2); // [1, 3, 5, 6]
 * symmetricDifference(array1)(array2); // [1, 3, 5, 6]
 */
declare const symmetricDifference: {
    <T>(array2: ArrayContainer<T>, array1: ArrayContainer<T>): T[];
    <T>(array2: ArrayContainer<T>): <T2 extends T>(array1: ArrayContainer<T2>) => T[];
};

/**
 * Creates an array of values that are in either array but not in both,
 * using an iteratee function to determine equality
 *
 * @category Array
 * @param iteratee - The function invoked per element
 * @param array1 - The first array to inspect
 * @param array2 - The second array to inspect
 * @returns Returns the new array of filtered values
 * @example
 * const array1 = [{ x: 1 }, { x: 2 }];
 * const array2 = [{ x: 1 }, { x: 3 }];
 * symmetricDifferenceBy(item => item.x, array1, array2); // => [{ x: 2 }, { x: 3 }]
 */
declare const symmetricDifferenceBy: {
    <T, U, I>(iteratee: ArrayCallback<T | U, I>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): (T | U)[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>): <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>) => (T | U)[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>): <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>) => <T3 extends T2>(array1: ArrayContainer<T3>) => (T | U)[];
};

/**
 * Creates an array of values that are in either array but not in both,
 * using a custom comparator function to determine equality
 *
 * @category Array
 * @param comparator - The function used to compare elements
 * @param array1 - The first array to inspect
 * @param array2 - The second array to inspect
 * @returns Returns the new array of filtered values
 * @example
 * const array1 = [{ x: 1, y: 2 }, { x: 2, y: 1 }];
 * const array2 = [{ x: 1, y: 2 }, { x: 3, y: 4 }];
 * symmetricDifferenceWith((a, b) => a.x === b.x && a.y === b.y, array1, array2); // => [{ x: 2, y: 1 }, { x: 3, y: 4 }]
 */
declare const symmetricDifferenceWith: {
    <T, U>(comparator: Comparator<T, U, boolean>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): (T | U)[];
    <T, U>(comparator: Comparator<T, U, boolean>, array2: ArrayContainer<U>): <T2 extends T>(array1: ArrayContainer<T2>) => (T2 | U)[];
    <T, U>(comparator: Comparator<T, U, boolean>): {
        <U2 extends U, T2 extends T>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>): (T2 | U2)[];
        <U2 extends U>(array2: ArrayContainer<U2>): <T2_1 extends T>(array1: ArrayContainer<T2_1>) => (T2_1 | U2)[];
    };
};

declare function tailImpl<T>(array: ArrayContainer<T>): T[];
/**
 * Returns all elements of the array except the first one
 *
 * @category Array
 * @param array - The array to get the tail from
 * @returns Returns a new array containing all elements except the first one
 * @example
 * const array = [1, 2, 3, 4, 5];
 * tail(array); // [2, 3, 4, 5]
 * tail([1, 2, 3]); // [2, 3]
 */
declare const tail: typeof tailImpl;

/**
 * Takes the first n elements from an array
 *
 * @category Array
 * @param count - The number of elements to take
 * @param array - The array to take elements from
 * @returns Returns a new array with the first n elements
 * @example
 * const array = [1, 2, 3, 4, 5];
 * take(3, array); // => [1, 2, 3]
 * take(3)([1, 2, 3, 4]); // => [1, 2, 3]
 */
declare const take: {
    <T>(count: number, array: ArrayContainer<T>): T[];
    (count: number): <T>(array: ArrayContainer<T>) => T[];
};

/**
 * Takes the last n elements from an array
 *
 * @category Array
 * @param count - The number of elements to take from the end
 * @param array - The array to take elements from
 * @returns Returns a new array with the last n elements
 * @example
 * const array = [1, 2, 3, 4, 5];
 * takeLast(3, array); // => [3, 4, 5]
 * takeLast(3)([1, 2, 3, 4]); // => [2, 3, 4]
 */
declare const takeLast: {
    <T>(count: number, array: ArrayContainer<T>): T[];
    (count: number): <T>(array: ArrayContainer<T>) => T[];
};

/**
 * Takes elements from the end of an array while the predicate returns true
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to take elements from
 * @returns Returns a new array with the elements taken from the end
 * @example
 * const array = [1, 2, 3, 4, 5];
 * takeLastWhile(x => x > 3, array); // => [4, 5]
 * takeLastWhile(x => x > 3)(array); // => [4, 5]
 */
declare const takeLastWhile: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T[];
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

/**
 * Takes elements from an array while the predicate returns true
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to take elements from
 * @returns Returns a new array with the elements taken from the start
 * @example
 * const array = [1, 2, 3, 4, 5];
 * takeWhile(x => x < 4, array); // => [1, 2, 3]
 * takeWhile(x => x < 4)(array); // => [1, 2, 3]
 */
declare const takeWhile: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): T[];
    <T>(predicate: ArrayPredicate<T>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

declare function tallyImpl<T>(array: ArrayContainer<T>): Map<T, number>;
declare const tally: typeof tallyImpl;

declare const tap: {
    <T>(fn: (value: T) => void, value: T): T;
    <T>(fn: (value: T) => void): <T2 extends T>(value: T2) => T2;
};

/**
 * Creates an array of values by calling the callback function count times
 *
 * @category Array
 * @param callback - The function to call for each index
 * @param count - The number of times to call the callback
 * @returns Returns an array of values generated by the callback
 * @example
 * times(index => index * 2, 3); // [0, 2, 4]
 * times(() => Math.random(), 2); // [0.123, 0.456]
 * times(index => ({ id: index }), 2); // [{ id: 0 }, { id: 1 }]
 */
declare const times: {
    <T>(callback: (index: number) => T, count: number): T[];
    <T>(callback: (index: number) => T): (count: number) => T[];
};

type ObjectEntriesWithOptional<T> = {
    [K in keyof T]-?: [K, T[K] extends undefined ? undefined : T[K]];
}[keyof T][];
declare function toPairsImpl<const T extends Record<PropertyKey, any>>(obj: T): ObjectEntriesWithOptional<T>;
/**
 * Converts an object into an array of key-value pairs
 *
 * @category Array
 * @param obj - The object to convert
 * @returns Returns an array of key-value pairs
 * @example
 * const obj = { a: 1, b: 2, c: 3 };
 * toPairs(obj); // [['a', 1], ['b', 2], ['c', 3]]
 */
declare const toPairs: typeof toPairsImpl;

declare function transposeImpl<T>(array: ArrayContainer<ArrayContainer<T>>): T[][];
/**
 * Transposes the rows and columns of a two-dimensional array
 *
 * @category Array
 * @param array - The array to transpose
 * @returns Returns a new transposed array
 * @example
 * const array = [[1, 2], [3, 4], [5, 6]];
 * transpose(array); // => [[1, 3, 5], [2, 4, 6]]
 */
declare const transpose: typeof transposeImpl;

/**
 * Returns true.
 * This function is useful as a default or placeholder function.
 *
 * @category Function
 * @returns true
 * @example
 * True() // true
 */
declare function True(..._: unknown[]): true;

/**
 * Wraps a function of any arity (including nullary) in a function that accepts exactly 1 parameter.
 * Any extraneous parameters will not be passed to the supplied function.
 *
 * @category Function
 * @param fn The function to wrap
 * @returns A new function that accepts exactly one parameter
 * @example
 * const fn = (a: number, b: number) => a + (b ?? 0);
 * const unaryFn = unary(fn);
 * unaryFn(1, 2, 3) // 1
 */
declare function unaryImpl<T, R>(fn: (...args: any[]) => R): (arg: T) => R;
declare const unary: typeof unaryImpl;

type UnfoldFn<T, R> = (value: T) => [R, T] | false;
/**
 * Builds a list from a seed value using an iterator function
 *
 * @category Array
 * @param fn - The iterator function that returns [value, newSeed] or false to stop
 * @param seed - The initial seed value
 * @returns Returns a list generated from the seed value
 * @example
 * const fn = (n: number) => n < 5 ? [n, n + 1] : false;
 * unfold(fn, 0); // [0, 1, 2, 3, 4]
 */
declare const unfold: {
    <T, R>(fn: UnfoldFn<T, R>, seed: T): R[];
    <T, R>(fn: UnfoldFn<T, R>): <T2 extends T>(seed: T2) => R[];
};

/**
 * Returns an array containing unique elements from both arrays
 *
 * @category Array
 * @param array1 - The first array to combine
 * @param array2 - The second array to combine
 * @returns Returns a new array containing unique elements from both arrays
 * @example
 * const array1 = [1, 2, 3, 4, 5];
 * const array2 = [2, 4, 6];
 * union(array1, array2); // [1, 2, 3, 4, 5, 6]
 * union(array1)(array2); // [1, 2, 3, 4, 5, 6]
 */
declare const union: {
    <T, U>(array2: ArrayContainer<U>, array1: ArrayContainer<T>): (T | U)[];
    <U>(array2: ArrayContainer<U>): <T>(array1: ArrayContainer<T>) => (T | U)[];
};

/**
 * Creates an array of unique values from all given arrays,
 * using an iteratee function to determine equality
 *
 * @category Array
 * @param iteratee - The function invoked per element
 * @param array1 - The first array to inspect
 * @param array2 - The second array to inspect
 * @returns Returns the new array of combined values
 * @example
 * const array1 = [{ x: 1 }, { x: 2 }];
 * const array2 = [{ x: 1 }, { x: 3 }];
 * unionBy(item => item.x, array1, array2); // => [{ x: 1 }, { x: 2 }, { x: 3 }]
 */
declare const unionBy: {
    <T, U, I>(iteratee: ArrayCallback<T | U, I>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): (T | U)[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>): <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>) => (T | U)[];
    <T, U, I>(iteratee: ArrayCallback<T | U, I>): <T2 extends T, U2 extends U>(array2: ArrayContainer<U2>) => <T3 extends T2>(array1: ArrayContainer<T3>) => (T | U)[];
};

/**
 * Creates an array of unique values from all given arrays,
 * using a custom comparator function to determine equality
 *
 * @category Array
 * @param comparator - The function used to compare elements
 * @param array1 - The first array to inspect
 * @param array2 - The second array to inspect
 * @returns Returns the new array of combined values
 * @example
 * const array1 = [{ x: 1, y: 2 }, { x: 2, y: 1 }];
 * const array2 = [{ x: 1, y: 2 }, { x: 3, y: 4 }];
 * unionWith((a, b) => a.x === b.x && a.y === b.y, array1, array2); // => [{ x: 1, y: 2 }, { x: 2, y: 1 }, { x: 3, y: 4 }]
 */
declare const unionWith: {
    <T, U>(comparator: Comparator<T | U, U, boolean>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): (T | U)[];
    <T, U>(comparator: Comparator<T | U, U, boolean>, array2: ArrayContainer<U>): <T2 extends T>(array1: ArrayContainer<T2>) => (T2 | U)[];
    <T, U>(comparator: Comparator<T | U, U, boolean>): {
        <U2 extends U, T2 extends T>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>): (T2 | U2)[];
        <U2 extends U>(array2: ArrayContainer<U2>): <T2_1 extends T>(array1: ArrayContainer<T2_1>) => (T2_1 | U2)[];
    };
};

declare function uniqueImpl<T>(array: ArrayContainer<T>): T[];
/**
 * Returns an array of unique elements from the input array
 *
 * @category Array
 * @param array - The array to get unique elements from
 * @returns Returns a new array containing only unique elements
 * @example
 * const array = [1, 2, 2, 3, 3, 4];
 * unique(array); // [1, 2, 3, 4]
 * unique([1, 1, 2, 2]); // [1, 2]
 */
declare const unique: typeof uniqueImpl;

/**
 * Returns an array of unique elements from the input array based on the iteratee function
 *
 * @category Array
 * @param iteratee - The function to transform elements for comparison
 * @param array - The array to get unique elements from
 * @returns Returns a new array containing only unique elements based on the iteratee
 * @example
 * const array = [{id: 1}, {id: 2}, {id: 1}];
 * uniqueBy(x => x.id, array); // [{id: 1}, {id: 2}]
 * uniqueBy(x => x.id)([{id: 1}, {id: 2}]); // [{id: 1}, {id: 2}]
 */
declare const uniqueBy: {
    <T, I>(iteratee: ArrayCallback<T, I>, array: ArrayContainer<T>): T[];
    <T, I>(iteratee: ArrayCallback<T, I>): <T2 extends T>(array: ArrayContainer<T2>) => T2[];
};

declare function unzipImpl<T extends ArrayContainer>(array: ArrayContainer<T>): {
    [K in keyof T]: T[K][];
};
/**
 * Transforms an array of tuples into a tuple of arrays
 *
 * @category Array
 * @param array - The array of tuples to unzip
 * @returns Returns a tuple of arrays, where each array contains the elements from the corresponding position in the input tuples
 * @example
 * const array = [[1, 'a'], [2, 'b'], [3, 'c']];
 * unzip(array); // [[1, 2, 3], ['a', 'b', 'c']]
 * unzip([[1, 'a', true], [2, 'b', false]]); // [[1, 2], ['a', 'b'], [true, false]]
 */
declare const unzip: typeof unzipImpl;

/**
 * Updates an element at the specified index in an array
 *
 * @category Array
 * @param index - The index of the element to update
 * @param item - The new item to replace with
 * @param array - The array to update
 * @returns Returns a new array with the element updated
 * @example
 * const array = [1, 2, 3, 4, 5];
 * update(0, 10, array); // [10, 2, 3, 4, 5]
 * update(-1, 10, array); // [1, 2, 3, 4, 10]
 */
declare const update: {
    <T, const I>(index: number, item: I, array: ArrayContainer<T>): (T | I)[];
    <T, const I>(index: number, item: I): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | I)[];
    <T>(index: number): {
        <T2 extends T, const I2>(item: I2, array: ArrayContainer<T2>): (T2 | I2)[];
        <const I2_1>(item: I2_1): <T2 extends T>(array: ArrayContainer<T2>) => (T2 | I2_1)[];
    };
};

declare function valuesImpl<T extends Record<PropertyKey, unknown>>(obj: T): Array<T[keyof T]>;
/**
 * Returns an array of all enumerable and non-enumerable values of an object
 *
 * @category Object
 * @param obj - The object to get values from
 * @returns Returns an array of all values
 * @example
 * const obj = { name: 'John', age: 30 };
 * values(obj); // ['John', 30]
 *
 * const sym = Symbol('sym');
 * const objWithSymbol = { [sym]: 'value', name: 'John' };
 * values(objWithSymbol); // ['John', 'value']
 */
declare const values: typeof valuesImpl;

/**
 * Creates the cartesian product of two arrays
 *
 * @category Array
 * @param array1 - The first array
 * @param array2 - The second array
 * @returns Returns an array of pairs containing all possible combinations of elements from both arrays
 * @example
 * const array1 = [1, 2];
 * const array2 = ['a', 'b'];
 * xprod(array1, array2); // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
 */
declare const xprod: {
    <T, U>(array1: ArrayContainer<T>, array2: ArrayContainer<U>): [T, U][];
    <T>(array1: ArrayContainer<T>): <U>(array2: ArrayContainer<U>) => [T, U][];
};

type Zip<A extends readonly unknown[], B extends readonly unknown[]> = A extends readonly [] ? [] : B extends readonly [] ? [] : A extends readonly [infer AHead, ...infer ATail] ? B extends readonly [infer BHead, ...infer BTail] ? [[AHead, BHead], ...Zip<ATail, BTail>] : [] : [];
/**
 * Creates an array of paired elements from two arrays
 *
 * @category Array
 * @param array1 - The first array
 * @param array2 - The second array
 * @returns Returns an array of paired elements
 * @example
 * const array1 = [1, 2, 3];
 * const array2 = ['a', 'b', 'c'];
 * zip(array1, array2); // [[1, 'a'], [2, 'b'], [3, 'c']]
 * zip(array1)(array2); // [[1, 'a'], [2, 'b'], [3, 'c']]
 */
declare const zip: {
    <const T extends ArrayContainer, const U extends ArrayContainer>(array2: U, array1: T): Zip<T, U>;
    <const U extends ArrayContainer>(array2: U): <const T extends ArrayContainer>(array1: T) => Zip<T, U>;
};

type ZipObj<K extends ArrayContainer<PropertyKey>, V extends ArrayContainer> = FromPairs<Zip<K, V>>;
/**
 * Creates an object from two arrays, using the first array as keys and the second array as values
 *
 * @category Array
 * @param keys - The array of keys
 * @param values - The array of values
 * @returns Returns an object with keys from the first array and values from the second array
 * @example
 * const keys = ['a', 'b', 'c'];
 * const values = [1, 2, 3];
 * zipObj(keys, values); // { a: 1, b: 2, c: 3 }
 * zipObj(keys)(values); // { a: 1, b: 2, c: 3 }
 */
declare const zipObj: {
    <const K extends ArrayContainer<PropertyKey>, const V extends ArrayContainer>(keys: K, values: V): ZipObj<K, V>;
    <const K extends ArrayContainer<PropertyKey>>(keys: K): <const V extends ArrayContainer>(values: V) => ZipObj<K, V>;
};

type ZipWithTransformer<T, U, R> = (a: T, b: U) => R;
/**
 * Creates a new array by applying a function to corresponding elements from two input arrays
 *
 * @category Array
 * @param transform - The function to apply to each pair of elements
 * @param array1 - The first input array
 * @param array2 - The second input array
 * @returns Returns a new array with the results of applying the transform function to each pair of elements
 * @example
 * const array1 = [1, 2, 3];
 * const array2 = [4, 5, 6];
 * zipWith((a, b) => a + b, array1, array2); // [5, 7, 9]
 * zipWith((a, b) => a * b)(array1)(array2); // [4, 10, 18]
 */
declare const zipWith: {
    <T, U, R>(transformer: ZipWithTransformer<T, U, R>, array2: ArrayContainer<U>, array1: ArrayContainer<T>): R[];
    <T, U, R>(transformer: ZipWithTransformer<T, U, R>, array2: ArrayContainer<U>): <T2 extends T>(array1: ArrayContainer<T2>) => R[];
    <T, U, R>(transformer: ZipWithTransformer<T, U, R>): {
        <U2 extends U, T2 extends T>(array2: ArrayContainer<U2>, array1: ArrayContainer<T2>): R[];
        <U2 extends U>(array2: ArrayContainer<U2>): <T2_1 extends T>(array1: ArrayContainer<T2_1>) => R[];
    };
};

declare const ZipAllShortest: unique symbol;
type ZipAllMode<T> = T | typeof ZipAllShortest;
/**
 * Zips multiple arrays together, either using a default value to fill shorter arrays
 * or using the shortest array length as the target length
 *
 * @category Array
 * @param defaultValue - The value to use for filling shorter arrays, or ZipAllShortest to use shortest length
 * @param arrays - The arrays to zip together
 * @returns Returns a new array of arrays containing the zipped values
 * @example
 * const arrays = [[1, 2, 3], [4, 5], [6, 7, 8]];
 * zipAll(0, arrays); // [[1, 4, 6], [2, 5, 7], [3, 0, 8]]
 * zipAll(ZipAllShortest, arrays); // [[1, 4, 6], [2, 5, 7]]
 */
declare const zipAll: {
    <D, T>(defaultValue: ZipAllMode<D>, arrays: ArrayContainer<T[]>): (T | D)[][];
    <D>(defaultValue: ZipAllMode<D>): <T>(arrays: ArrayContainer<T[]>) => (T | D)[][];
};

declare function weaveImpl<T>(arrays: ArrayContainer<ArrayContainer<T>>): T[];
/**
 * Interleaves multiple arrays, taking elements from each array in turn
 *
 * @category Array
 * @param arrays - The arrays to interleave
 * @returns Returns a new array with elements interleaved from the input arrays
 * @example
 * weave([[1, 2, 3], [4, 5], [6, 7, 8]]) // [1, 4, 6, 2, 5, 7, 3, 8]
 */
declare const weave: typeof weaveImpl;

/**
 * Transforms a list of tuples into a list of values by applying a function to each tuple
 *
 * @category Array
 * @param fn - The function to transform each tuple
 * @param array - The array of tuples to transform
 * @returns Returns a new array with the results of applying the function to each tuple
 * @example
 * const array = [[1, 2], [3, 4], [5, 6]];
 * unzipWith(([a, b]) => a + b, array); // [9, 12]
 * unzipWith(([a, b]) => a * b)(array); // [2, 12, 30]
 */
declare const unzipWith: {
    <T, R>(fn: (tuple: T[]) => R, array: ArrayContainer<T[]>): R[];
    <T, R>(fn: (tuple: T[]) => R): (array: ArrayContainer<T[]>) => R[];
};

/**
 * Checks if the specified property of an object equals the given value
 *
 * @category Object
 * @param value - The value to compare against
 * @param prop - The property name to check
 * @param obj - The object to check
 * @returns Returns true if the property equals the value, false otherwise
 * @example
 * const user = { id: 1, name: 'Alice' };
 * propEq(1, 'id', user); // true
 * propEq('Bob', 'name', user); // false
 *
 * @example
 * // With currying
 * const isAdmin = propEq('admin', 'role');
 * isAdmin({ role: 'admin' }); // true
 * isAdmin({ role: 'user' }); // false
 */
declare const propEq: {
    <V, K extends PropertyKey, T extends Record<PropertyKey, unknown>>(value: V, prop: K | keyof T, obj: T): boolean;
    <V, K extends PropertyKey>(value: V, prop: K): <T extends Record<PropertyKey, unknown>>(obj: T) => boolean;
    <V>(value: V): {
        <K extends PropertyKey, T extends Record<K, unknown>>(prop: K | keyof T, obj: T): boolean;
        <K extends PropertyKey>(prop: K): <T_1 extends Record<K, unknown>>(obj: T_1) => boolean;
    };
};

/**
 * Checks if the value at the specified path of an object equals the given value
 *
 * @category Object
 * @param value - The value to compare against
 * @param path - The path to check (array of keys)
 * @param obj - The object to check
 * @returns Returns true if the path value equals the value, false otherwise
 * @example
 * const user = {
 *   profile: {
 *     name: 'Alice',
 *     address: { city: 'New York' }
 *   }
 * };
 * pathEq('Alice', ['profile', 'name'], user); // true
 * pathEq('London', ['profile', 'address', 'city'], user); // false
 *
 * @example
 * // With currying
 * const isInNewYork = pathEq('New York', ['profile', 'address', 'city']);
 * isInNewYork(user); // true
 */
declare const pathEq: {
    <const T, const P extends ArrayContainer<PropertyKey>, D>(value: D, path: P, obj: T): boolean;
    <const P extends ArrayContainer<PropertyKey>, D>(value: D, path: P): <const T>(obj: T) => boolean;
    <D>(value: D): {
        <const T, const P>(path: P, obj: T): boolean;
        <const P_1>(path: P_1): <const T>(obj: T) => boolean;
    };
};

/**
 * Partitions an object into two objects based on a predicate function
 *
 * @category Object
 * @param predicate - The predicate function to test each property value and key
 * @param obj - The object to partition
 * @returns Returns a tuple containing two objects: [trueValues, falseValues]
 * @example
 * const obj = { a: 1, b: 2, c: 3 };
 * partitionWith((value) => value > 2, obj); // [{ c: 3 }, { a: 1, b: 2 }]
 *
 * const user = { name: 'Alice', age: 20, active: true };
 * partitionWith((value, key) => typeof value === 'string', user);
 * // [{ name: 'Alice' }, { age: 20, active: true }]
 */
declare const partitionWith: {
    <T extends Record<string, any>>(predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean, obj: T): [Partial<T>, Partial<T>];
    <T extends Record<string, any>>(predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean): (obj: T) => [Partial<T>, Partial<T>];
};

declare function jsonCloneImpl<T>(value: T): T;
/**
 * Creates a deep clone of a value using JSON serialization and deserialization
 *
 * @category Object
 * @param value - The value to clone
 * @returns A deep clone of the input value
 * @example
 * const obj = { a: 1, b: { c: 2 } };
 * const cloned = jsonClone(obj);
 * // cloned is a deep copy of obj
 *
 * @example
 * // Will throw an error due to circular reference
 * const obj = { a: 1 };
 * obj.self = obj;
 * jsonClone(obj); // Error: Converting circular structure to JSON
 *
 * @example
 * // Will throw an error due to BigInt
 * const obj = { a: 1n };
 * jsonClone(obj); // Error: BigInt value can't be serialized in JSON
 *
 * @example
 * // Will throw an error due to function
 * const obj = { a: () => {} };
 * jsonClone(obj); // Error: Function can't be serialized in JSON
 */
declare const jsonClone: typeof jsonCloneImpl;

/**
 * Checks if an array includes an element that, when transformed by the given function, equals the specified value
 *
 * @category Array
 * @param fn - The function to transform each element
 * @param value - The value to compare against
 * @param array - The array to check
 * @returns Returns true if any element's transformed value equals the specified value, false otherwise
 * @example
 * const array = [1, 2, 3, 4, 5];
 * includesBy(x => x * 2, 6, array); // true (because 3 * 2 === 6)
 * includesBy(x => x * 2, 11, array); // false
 *
 * const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
 * includesBy(user => user.name, 'Alice', users); // true
 * includesBy(user => user.name, 'Charlie', users); // false
 */
declare const includesBy: {
    <T, R>(fn: ArrayCallback<T, unknown>, value: R, array: ArrayContainer<T>): boolean;
    <T, R>(fn: ArrayCallback<T, unknown>, value: R): (array: ArrayContainer<T>) => boolean;
    <T>(fn: ArrayCallback<T, unknown>): {
        <R>(value: R, array: ArrayContainer<T>): boolean;
        <R>(value: R): (array: ArrayContainer<T>) => boolean;
    };
};

/**
 * Finds the first element that satisfies the predicate and transforms it using the same function
 *
 * @category Array
 * @param fn - The function that both tests and transforms elements. Returns undefined for elements that should be skipped
 * @param array - The array to search
 * @returns Returns the first non-undefined result from the function, or undefined if no element satisfies the condition
 * @example
 * const array = [1, 2, 3, 4, 5];
 * findMap(x => x % 2 === 0 ? x * 2 : undefined, array); // 4
 * findMap(x => x > 3 ? x.toString() : undefined)(array); // "4"
 */
declare const findMap: {
    <T, R, D>(defaultValue: D, fn: ArrayCallback<T, R>, array: ArrayContainer<T>): R | D;
    <T, R, D>(defaultValue: D, fn: ArrayCallback<T, R>): (array: ArrayContainer<T>) => R | D;
    <D>(defaultValue: D): {
        <T, R>(fn: ArrayCallback<T, R>, array: ArrayContainer<T>): R | D;
        <T, R_1>(fn: ArrayCallback<T, R_1>): (array: ArrayContainer<T>) => R_1 | D;
    };
};

/**
 * Returns an array of indices where the predicate function returns true
 *
 * @category Array
 * @param predicate - The predicate function to test each element
 * @param array - The array to search
 * @returns Returns an array of indices where the predicate function returns true
 * @example
 * const array = [1, 2, 3, 4, 5];
 * findIndices(x => x % 2 === 0, array); // [1, 3]
 * findIndices(x => x > 3)(array); // [3, 4]
 */
declare const findIndices: {
    <T>(predicate: ArrayPredicate<T>, array: ArrayContainer<T>): number[];
    <T>(predicate: ArrayPredicate<T>): (array: ArrayContainer<T>) => number[];
};

/**
 * Constant array containing all falsy values
 */
declare const FALSY_VALUES: readonly [false, null, 0, 0, 0n, "", undefined, number];
type FALSY_VALUES_SAFE = false | null | 0 | '' | undefined | 0n;
type Compact<T extends readonly any[]> = {
    [K in keyof T]: Exclude<T[K], FALSY_VALUES_SAFE>;
};
declare function compactImpl<T>(array: ArrayContainer<T>): Compact<T[]>;
/**
 * Removes all falsy values from the array
 *
 * @category Array
 * @param array - The array to compact
 * @returns Returns a new array with all falsy values removed
 * @example
 * const array = [0, 1, false, 2, '', 3];
 * compact(array); // [1, 2, 3]
 * compact([0, 1, false, 2, '', 3]); // [1, 2, 3]
 */
declare const compact: typeof compactImpl;

type IsArray<T> = T extends any[] ? true : false;
type Transformer<T, R = T> = (input: T) => R;
type TransformMap<T> = {
    [K in keyof T]?: T[K] extends object ? IsArray<T[K]> extends true ? Transformer<T[K]> : TransformMap<T[K]> | Transformer<T[K]> : Transformer<T[K]>;
};
/**
 * 推断转换后的类型
 */
type Evolved<T, TF extends TransformMap<T>> = {
    [K in keyof T]: K extends keyof TF ? TF[K] extends Transformer<T[K], infer R> ? R : T[K] extends object ? TF[K] extends TransformMap<T[K]> ? Evolved<T[K], TF[K]> : T[K] : T[K] : T[K];
};
/**
 * Recursively transforms an object by applying transformation functions to its properties
 *
 * @category Object
 * @param transforms - An object containing transformation functions for each property
 * @param obj - The object to transform
 * @returns Returns a new object with transformed values
 * @example
 * const obj = {
 *   name: 'Alice',
 *   age: 20,
 *   scores: [1, 2, 3],
 *   profile: {
 *     email: 'alice@example.com',
 *     active: true
 *   }
 * };
 *
 * const transforms = {
 *   name: (name: string) => name.toUpperCase(),
 *   age: (age: number) => age + 1,
 *   scores: (scores: number[]) => scores.map(n => n * 2),
 *   profile: {
 *     email: (email: string) => email.toLowerCase(),
 *     active: (active: boolean) => !active
 *   }
 * };
 *
 * evolve(transforms, obj);
 * // {
 * //   name: 'ALICE',
 * //   age: 21,
 * //   scores: [2, 4, 6],
 * //   profile: {
 * //     email: 'alice@example.com',
 * //     active: false
 * //   }
 * // }
 */
declare const evolve: {
    <const T, TF extends TransformMap<T>>(transformations: TF, obj: T): Evolved<T, TF>;
    <const T, TF extends TransformMap<T>>(transformations: TF): <T2 extends T, TF2 extends TransformMap<T2>>(obj: T2) => Evolved<T2, TF2>;
};

/**
 * A lens is a pair of functions that allow you to focus on a specific part of a data structure.
 * The getter function retrieves the focused value, and the setter function creates a new data structure
 * with the focused value updated.
 */
interface Lens<S, A> {
    get: (s: S) => A;
    set: (a: A, s: S) => S;
}
/**
 * Creates a lens from a getter and setter function
 *
 * @category Object
 * @param getter - Function to get the focused value
 * @param setter - Function to set the focused value
 * @returns Returns a lens object with get and set methods
 * @example
 * const nameLens = lens(
 *   (obj) => obj.name,
 *   (name, obj) => ({ ...obj, name })
 * );
 * view(nameLens, { name: 'Alice', age: 20 }); // 'Alice'
 * set(nameLens, 'Bob', { name: 'Alice', age: 20 }); // { name: 'Bob', age: 20 }
 */
declare function lens<S, A>(get: (s: S) => A, set: (a: A, s: S) => S): Lens<S, A>;
/**
 * Creates a lens that focuses on a specific property of an object
 *
 * @category Object
 * @param prop - The property name to focus on
 * @returns Returns a lens object with get and set methods
 * @example
 * const nameLens = lensProp('name');
 * view(nameLens, { name: 'Alice', age: 20 }); // 'Alice'
 * set(nameLens, 'Bob', { name: 'Alice', age: 20 }); // { name: 'Bob', age: 20 }
 */
declare function lensProp<K extends PropertyKey>(prop: K): Lens<Record<K, any>, any>;
/**
 * Creates a lens that focuses on a specific path in an object
 *
 * @category Object
 * @param path - The path to focus on
 * @returns Returns a lens object with get and set methods
 * @example
 * const nameLens = lensPath(['user', 'profile', 'name']);
 * view(nameLens, { user: { profile: { name: 'Alice' } } }); // 'Alice'
 * set(nameLens, 'Bob', { user: { profile: { name: 'Alice' } } }); // { user: { profile: { name: 'Bob' } } }
 */
declare function lensPath(pathArray: PropertyKey[]): Lens<any, any>;
/**
 * Gets the value focused by a lens
 *
 * @category Object
 * @param lens - The lens to use
 * @param obj - The object to view
 * @returns Returns the focused value
 * @example
 * const nameLens = lensProp('name');
 * view(nameLens, { name: 'Alice', age: 20 }); // 'Alice'
 */
declare const lensView: {
    <S, A>(lens: Lens<S, A>, obj: S): A;
    <S, A>(lens: Lens<S, A>): (obj: S) => A;
};
/**
 * Sets the value focused by a lens
 *
 * @category Object
 * @param lens - The lens to use
 * @param value - The new value to set
 * @param obj - The object to update
 * @returns Returns a new object with the focused value updated
 * @example
 * const nameLens = lensProp('name');
 * set(nameLens, 'Bob', { name: 'Alice', age: 20 }); // { name: 'Bob', age: 20 }
 */
declare const lensSet: {
    <S, A>(lens: Lens<S, A>, value: A, obj: S): S;
    <S, A>(lens: Lens<S, A>, value: A): (obj: S) => S;
    <S, A>(lens: Lens<S, A>): (value: A) => (obj: S) => S;
};
/**
 * Applies a function to the value focused by a lens
 *
 * @category Object
 * @param lens - The lens to use
 * @param fn - The function to apply
 * @param obj - The object to update
 * @returns Returns a new object with the focused value transformed
 * @example
 * const nameLens = lensProp('name');
 * over(nameLens, (name) => name.toUpperCase(), { name: 'Alice', age: 20 }); // { name: 'ALICE', age: 20 }
 */
declare const lensOver: {
    <S, A>(lens: Lens<S, A>, fn: (a: A) => A, obj: S): S;
    <S, A>(lens: Lens<S, A>, fn: (a: A) => A): (obj: S) => S;
    <S, A>(lens: Lens<S, A>): (fn: (a: A) => A) => (obj: S) => S;
};

declare const cloneDeep: <T>(source: T) => T;

/**
 * Checks if an object has a specified path
 *
 * @category Object
 * @param path - The path to check, can be an array of keys or a dot-separated string
 * @param obj - The object to check
 * @returns Returns true if the path exists in the object, false otherwise
 * @example
 * const obj = { a: { b: { c: 1 } } };
 * hasPath(['a', 'b', 'c'], obj); // true
 * hasPath(['a', 'b', 'd'], obj); // false
 * hasPath('a.b.c', obj); // true
 *
 * @example
 * // With currying
 * const hasUserProfile = hasPath(['user', 'profile']);
 * hasUserProfile({ user: { profile: { name: 'Alice' } } }); // true
 * hasUserProfile({ user: { settings: {} } }); // false
 */
declare const hasPath: {
    (path: PropertyKey[], obj: Record<PropertyKey, unknown>): boolean;
    (path: PropertyKey[]): (obj: Record<PropertyKey, unknown>) => boolean;
};

declare function pathToArrayImpl(path: string): PropertyKey[];
/**
 * Converts a path string to an array of property keys
 * Supports dot notation, array indices, and numeric properties
 *
 * @category Object
 * @param path - The path string to convert (e.g. 'a.b[0].1.c')
 * @returns Returns an array of property keys
 * @example
 * pathToArray('a.b.c'); // ['a', 'b', 'c']
 * pathToArray('user.profile[0].name'); // ['user', 'profile', 0, 'name']
 * pathToArray('a.1.b[2]'); // ['a', '1', 'b', 2]
 * pathToArray(''); // []
 */
declare const pathToArray: typeof pathToArrayImpl;

/**
 * 将对象类型的所有属性及其嵌套属性都变为可选
 * @example
 * type User = {
 *   name: string;
 *   profile: {
 *     age: number;
 *     address: {
 *       city: string;
 *     }
 *   }
 * }
 *
 * type PartialUser = DeepPartial<User>;
 * // 等价于:
 * // {
 * //   name?: string;
 * //   profile?: {
 * //     age?: number;
 * //     address?: {
 * //       city?: string;
 * //     }
 * //   }
 * // }
 */
type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;

type Predicate$1<T, K extends PropertyKey, O extends Record<K, unknown>> = (value: T, key: K, obj: O) => boolean;
/**
 * Checks if an object satisfies all predicates in the spec object
 *
 * @category Object
 * @param predicates - The specification object containing predicate functions
 * @param obj - The object to check
 * @returns Returns true if the object satisfies all predicates, false otherwise
 * @example
 * const predicates = {
 *   name: (x: string) => x.length > 0,
 *   age: (x: number) => x >= 18
 * };
 * where(predicates, { name: 'Alice', age: 20 }); // true
 * where(predicates, { name: '', age: 16 }); // false
 *
 * @example
 * // With currying
 * const isAdult = where({ age: (x: number) => x >= 18 });
 * isAdult({ name: 'Alice', age: 20 }); // true
 * isAdult({ name: 'Bob', age: 16 }); // false
 */
declare const where: {
    <S extends Record<PropertyKey, unknown>>(predicates: { [K in keyof S]?: Predicate$1<S[K], K, S>; }, obj: DeepPartial<S> | Record<PropertyKey, unknown>): boolean;
    <S extends Record<PropertyKey, unknown>>(predicates: { [K in keyof S]?: Predicate$1<S[K], K, S>; }): (obj: DeepPartial<S> | Record<PropertyKey, unknown>) => boolean;
};

/**
 * Checks if an object satisfies all property equality assertions in the spec object
 *
 * @category Object
 * @param spec - The specification object containing property equality assertions
 * @param obj - The object to check
 * @returns Returns true if the object satisfies all property equality assertions, false otherwise
 * @example
 * const spec = { name: 'Alice', age: 20 };
 * whereEq(spec, { name: 'Alice', age: 20, role: 'admin' }); // true
 * whereEq(spec, { name: 'Bob', age: 20 }); // false
 *
 * @example
 * // With currying
 * const isAlice = whereEq({ name: 'Alice' });
 * isAlice({ name: 'Alice', age: 20 }); // true
 * isAlice({ name: 'Bob', age: 20 }); // false
 */
declare const whereEq: {
    <S extends Record<PropertyKey, unknown>>(spec: S, obj: DeepPartial<S> | Record<PropertyKey, unknown>): boolean;
    <S extends Record<PropertyKey, unknown>>(spec: S): (obj: DeepPartial<S> | Record<PropertyKey, unknown>) => boolean;
};

type Predicate<T, K extends PropertyKey, O extends Record<K, unknown>> = (value: T, key: K, obj: O) => boolean;
/**
 * Checks if an object satisfies any predicate in the spec object
 *
 * @category Object
 * @param predicates - The specification object containing predicate functions
 * @param obj - The object to check
 * @returns Returns true if the object satisfies any predicate, false otherwise
 * @example
 * const predicates = {
 *   name: (x: string) => x.length > 0,
 *   age: (x: number) => x >= 18
 * };
 * whereAny(predicates, { name: '', age: 20 }); // true
 * whereAny(predicates, { name: '', age: 16 }); // false
 *
 * @example
 * // With currying
 * const hasValidNameOrAge = whereAny({
 *   name: (x: string) => x.length > 0,
 *   age: (x: number) => x >= 18
 * });
 * hasValidNameOrAge({ name: '', age: 20 }); // true
 * hasValidNameOrAge({ name: '', age: 16 }); // false
 */
declare const whereAny: {
    <S extends Record<PropertyKey, unknown>>(predicates: { [K in keyof S]?: Predicate<S[K], K, S>; }, obj: DeepPartial<S> | Record<PropertyKey, unknown>): boolean;
    <S extends Record<PropertyKey, unknown>>(predicates: { [K in keyof S]?: Predicate<S[K], K, S>; }): (obj: DeepPartial<S> | Record<PropertyKey, unknown>) => boolean;
};

type OptionalTuple<T extends readonly any[]> = {
    [K in keyof T]?: T[K];
};
type Fn<T, R> = (value: T) => R;
declare const useWith: {
    <R>(fn: (...args: []) => R, transformers: []): (...args: []) => R;
    <R, A1, T1>(fn: (...args: [A1]) => R, transformers: [Fn<T1, A1>]): (...args: [T1]) => R;
    <R, A1, A2, T1, T2>(fn: (...args: [A1, A2]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>]>): (...args: [T1, T2]) => R;
    <R, A1, A2, A3, T1, T2, T3>(fn: (...args: [A1, A2, A3]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>]>): (...args: [T1, T2, T3]) => R;
    <R, A1, A2, A3, A4, T1, T2, T3, T4>(fn: (...args: [A1, A2, A3, A4]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>]>): (...args: [T1, T2, T3, T4]) => R;
    <R, A1, A2, A3, A4, A5, T1, T2, T3, T4, T5>(fn: (...args: [A1, A2, A3, A4, A5]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>]>): (...args: [T1, T2, T3, T4, T5]) => R;
    <R, A1, A2, A3, A4, A5, A6, T1, T2, T3, T4, T5, T6>(fn: (...args: [A1, A2, A3, A4, A5, A6]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>]>): (...args: [T1, T2, T3, T4, T5, T6]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7, T1, T2, T3, T4, T5, T6, T7>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>]>): (...args: [T1, T2, T3, T4, T5, T6, T7]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7, A8, T1, T2, T3, T4, T5, T6, T7, T8>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7, A8]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>, Fn<T8, A8>]>): (...args: [T1, T2, T3, T4, T5, T6, T7, T8]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7, A8, A9, T1, T2, T3, T4, T5, T6, T7, T8, T9>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7, A8, A9]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>, Fn<T8, A8>, Fn<T9, A9>]>): (...args: [T1, T2, T3, T4, T5, T6, T7, T8, T9]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) => R, transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>, Fn<T8, A8>, Fn<T9, A9>, Fn<T10, A10>]>): (...args: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) => R;
    <R>(fn: (...args: []) => R): (transformers: []) => (...args: []) => R;
    <R, A1>(fn: (...args: [A1]) => R): <T1>(transformers: OptionalTuple<[Fn<T1, A1>]>) => (...args: [T1]) => R;
    <R, A1, A2>(fn: (...args: [A1, A2]) => R): <T1, T2>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>]>) => (...args: [T1, T2]) => R;
    <R, A1, A2, A3>(fn: (...args: [A1, A2, A3]) => R): <T1, T2, T3>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>]>) => (...args: [T1, T2, T3]) => R;
    <R, A1, A2, A3, A4>(fn: (...args: [A1, A2, A3, A4]) => R): <T1, T2, T3, T4>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>]>) => (...args: [T1, T2, T3, T4]) => R;
    <R, A1, A2, A3, A4, A5>(fn: (...args: [A1, A2, A3, A4, A5]) => R): <T1, T2, T3, T4, T5>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>]>) => (...args: [T1, T2, T3, T4, T5]) => R;
    <R, A1, A2, A3, A4, A5, A6>(fn: (...args: [A1, A2, A3, A4, A5, A6]) => R): <T1, T2, T3, T4, T5, T6>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>]>) => (...args: [T1, T2, T3, T4, T5, T6]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7]) => R): <T1, T2, T3, T4, T5, T6, T7>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>]>) => (...args: [T1, T2, T3, T4, T5, T6, T7]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7, A8>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7, A8]) => R): <T1, T2, T3, T4, T5, T6, T7, T8>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>, Fn<T8, A8>]>) => (...args: [T1, T2, T3, T4, T5, T6, T7, T8]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7, A8, A9]) => R): <T1, T2, T3, T4, T5, T6, T7, T8, T9>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>, Fn<T8, A8>, Fn<T9, A9>]>) => (...args: [T1, T2, T3, T4, T5, T6, T7, T8, T9]) => R;
    <R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(fn: (...args: [A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) => R): <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(transformers: OptionalTuple<[Fn<T1, A1>, Fn<T2, A2>, Fn<T3, A3>, Fn<T4, A4>, Fn<T5, A5>, Fn<T6, A6>, Fn<T7, A7>, Fn<T8, A8>, Fn<T9, A9>, Fn<T10, A10>]>) => (...args: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) => R;
};

declare const converge: {
    <T extends any[], R>(convergingFn: (...args: any[]) => R, branchingFns: ((...args: T) => any)[]): (...args: T) => R;
    <T extends any[], R>(convergingFn: (...args: any[]) => R): (branchingFns: ((...args: T) => any)[]) => (...args: T) => R;
};

declare const call: {
    <T extends any[], R>(fn: (...args: T) => R, args: T): R;
    <T extends any[], R>(fn: (...args: T) => R): (args: T) => R;
};

declare const bind: {
    <T extends (...args: any[]) => any, This>(fn: T, thisArg: This): (...args: Parameters<T>) => ReturnType<T>;
    <T extends (...args: any[]) => any>(fn: T): <This>(thisArg: This) => (...args: Parameters<T>) => ReturnType<T>;
};

export { FALSY_VALUES, False, True, ZipAllShortest, adjust, all, allPass, always, any, anyPass, ap, aperture, append, bifurcate, bind, call, chunk, clone, cloneDeep, compact, complement, compose, composeAsync, concat, converge, countBy, curry, difference, differenceBy, differenceWith, drop, dropLast, dropLastWhile, dropRepeats, dropRepeatsWith, dropWhile, evolve, filter, find, findIndex, findIndices, findLast, findLastIndex, findMap, first, flatMap, flatten, flip, flow, flowAsync, forEach, fromPairs, groupBy, has, hasPath, identity, includes, includesBy, indexBy, indexOf, init, insert, intercalate, interleave, intersection, intersectionBy, intersectionWith, intersperse, invert, invertMulti, isAlpha, isAlphanumeric, isArray, isArrayLike, isArrayOf, isAsyncGenerator, isBlankString, isBoolean, isDate, isEmail, isEmptyArray, isEmptyObject, isEmptyString, isEqual, isError, isEven, isFinite, isFloat, isFunction, isGenerator, isGenericGenerator, isInfinity, isInteger, isIterable, isNaN, isNegative, isNegativeInfinity, isNil, isNotNil, isNull, isNumber, isNumeric, isObject, isOdd, isPlainObject, isPositive, isPositiveInfinity, isPromise, isRegExp, isString, isSymbol, isUndefined, isUrl, isZero, join, jsonClone, juxt, keys, last, lastIndexOf, length, lens, lensOver, lensPath, lensProp, lensSet, lensView, map, mapEntries, mapKeys, mapValues, max, maxBy, maxWith, mean, median, mergeDeleteSymbol, mergeLeft, mergeLeftInPlace, mergeRight, mergeRightInPlace, mergeWith, mergeWithInPlace, min, minBy, minWith, move, none, nonePass, noop, nth, omit, omitBy, omitIndices, once, padLeft, padRight, pairwise, partition, partitionWith, path, pathEq, pathOr, pathToArray, pick, pickBy, pickIndices, pipe, pluck, prepend, product, prop, propEq, propOr, range, reduce, reduceRight, reduceRightWhile, reduceWhile, reject, remove, repeat, reverse, rotateLeft, rotateRight, sample, sampleSize, scan, scanRight, set, setPath, shuffle, slice, sort, sortBy, sortWith, splice, splitAt, splitBy, splitWhen, sum, sumBy, swap, symmetricDifference, symmetricDifferenceBy, symmetricDifferenceWith, tail, take, takeLast, takeLastWhile, takeWhile, tally, tap, times, toPairs, transpose, unary, unfold, union, unionBy, unionWith, unique, uniqueBy, unzip, unzipWith, update, useWith, values, weave, where, whereAny, whereEq, xprod, zip, zipAll, zipObj, zipWith };
export type { FromPairs, FromPairsLoose, FromPairsStrict, GetPathValue, Lens, MergeDeleteSymbol, MergeWithCustomizer, Zip, ZipObj };