export type RambdaTypes = "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "RegExp" | "NaN" | "Function" | "Undefined" | "Async" | "Promise" | "Symbol" | "Set" | "Error" | "Map" | "WeakMap" | "Generator" | "GeneratorFunction" | "BigInt" | "ArrayBuffer" | "Date"
type LastArrayElement<ValueType extends readonly unknown[]> = ValueType extends readonly [infer ElementType] ? ElementType : ValueType extends readonly [infer _, ...infer Tail] ? LastArrayElement<Tail> : ValueType extends ReadonlyArray<infer ElementType> ? ElementType : never;type FirstArrayElement<ValueType extends readonly unknown[]> = ValueType extends readonly [infer ElementType] ? ElementType : ValueType extends readonly [...infer Head, infer _] ? FirstArrayElement<Head> : ValueType extends ReadonlyArray<infer ElementType> ? ElementType : never;
export function reduceStopper<T>(input: T) : Texport type IndexedIterator<T, U> = (x: T, i: number) => U;export type Iterator<T, U> = (x: T) => U;export type ObjectIterator<T, U> = (x: T, prop: string, inputObj: Dictionary<T>) => U;type Ord = number | string | boolean | Date;type Ordering = -1 | 0 | 1;type Path = string | (number | string)[];export type RamdaPath = (number | string)[];type Predicate<T> = (x: T) => boolean;export type IndexedPredicate<T> = (x: T, i: number) => boolean;export type ObjectPredicate<T> = (x: T, prop: string, inputObj: Dictionary<T>) => boolean;type CondPair<T extends any[], R> = [(...val: T) => boolean, (...val: T) => R]type Prop<T, P extends keyof never> = P extends keyof Exclude<T, undefined> ? T extends undefined ? undefined : T[Extract<P, keyof T>] : undefined;
type ValueOfRecord<R> = R extends Record<any, infer T> ? T : never;
interface KeyValuePair<K, V> extends Array<K | V> { 0: K; 1: V;}export type Functor<A> = { map: <B>(fn: (a: A) => B) => Functor<B>; [key: string]: any };export type Lens<S, A> = (functorFactory: (a: A) => Functor<A>) => (s: S) => Functor<S>;
export type ObjPred<T = unknown> = (value: any, key: unknown extends T ? string : keyof T) => boolean;
type Arity1Fn = (x: any) => any;type Arity2Fn = (x: any, y: any) => any;
type Pred = (...x: any[]) => boolean;
export interface Dictionary<T> {[index: string]: T}type Partial<T> = { [P in keyof T]?: T[P]};
type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;export type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;
type Evolvable<E extends Evolver> = {[P in keyof E]?: Evolved<E[P]>};
type Evolver<T extends Evolvable<any> = any> = { [key in keyof Partial<T>]: ((value: T[key]) => T[key]) | (T[key] extends Evolvable<any> ? Evolver<T[key]> : never);};
type Evolve<O extends Evolvable<E>, E extends Evolver> = { [P in keyof O]: P extends keyof E ? EvolveValue<O[P], E[P]> : O[P];};
type Evolved<A> = A extends (value: infer V) => any ? V : A extends Evolver ? Evolvable<A> : never;
type EvolveNestedValue<O, E extends Evolver> = O extends object ? O extends Evolvable<E> ? Evolve<O, E> : never : never;
type EvolveValue<V, E> = E extends (value: V) => any ? ReturnType<E> : E extends Evolver ? EvolveNestedValue<V, E> : never;
interface AssocPartialOne<K extends keyof any> { <T>(val: T): <U>(obj: U) => Record<K, T> & U; <T, U>(val: T, obj: U): Record<K, T> & U;}type AtLeastOneFunctionsFlowFromRightToLeft<TArgs extends any[], TResult> = | [(...args: any) => TResult, ...Array<(args: any) => any>, (...args: TArgs) => any] | [(...args: TArgs) => TResult];
type AnyFunction = (...args: any[]) => unknown;type AnyConstructor = new (...args: any[]) => unknown;
type RegExpReplacerFn = | ((m: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, p3: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, p3: string, p4: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, p3: string, p4: string, p5: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, p3: string, p4: string, p5: string, p6: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, p3: string, p4: string, p5: string, p6: string, p7: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, p3: string, p4: string, p5: string, p6: string, p7: string, p8: string, offset: number, s: string, groups?: Record<string, string>) => string) | ((m: string, p1: string, p2: string, p3: string, p4: string, p5: string, p6: string, p7: string, p8: string, p9: string, offset: number, s: string, groups?: Record<string, string>) => string)type RegExpReplacer = string | RegExpReplacerFn
type IsFirstSubtypeOfSecond<First, Second> = (First extends Second ? Second : never);
type Func<T> = (input: any) => T;type VoidInputFunc<T> = () => T;type Fn<In, Out> = (x: In) => Out;type SortObjectPredicate<T> = (aProp: string, bProp: string, aValue: T, bValue: T) => number;
type IdentityFunction<T> = (x: T) => T;
interface Filter<T> { (list: T[]): T[]; (obj: Dictionary<T>): Dictionary<T>;}
type ArgumentTypes<T> = T extends (...args: infer U) => infer R ? U : never;type isfn<T> = (x: any, y: any) => T;
interface Switchem<T> { is: isfn<Switchem<T>>; default: IdentityFunction<T>;}
interface Schema { [key: string]: any;}
interface SchemaAsync { [key: string]: Promise<boolean>;}
export interface IsValid { input: object; schema: Schema;}
export interface IsValidAsync { input: object; schema: Schema | SchemaAsync;}
type ProduceRules<Output,K extends keyof Output, Input> = { [P in K]: (input: Input) => Output[P];};type ProduceAsyncRules<Output,K extends keyof Output, Input> = { [P in K]: (input: Input) => Promise<Output[P]>;};type ProduceAsyncRule<Input> = (input: Input) => Promise<any>;type Async<T> = (x: any) => Promise<T>;type AsyncIterable<T, K> = (x: T) => Promise<K>;type AsyncIterableIndexed<T, K> = (x: T, i: number) => Promise<K>;type AsyncPredicate<T> = (x: T) => Promise<boolean>;type AsyncPredicateIndexed<T> = (x: T, i: number) => Promise<boolean>;type AsyncWithProp<T> = (x: any, prop?: string) => Promise<T>;
type ApplyDiffUpdate = {op:'update', path: string, value: any};type ApplyDiffAdd = {op:'add', path: string, value: any};type ApplyDiffRemove = {op:'remove', path: string};type ApplyDiffRule = ApplyDiffUpdate | ApplyDiffAdd | ApplyDiffRemove;
export function F(): boolean;
export function T(): boolean;
export function add(a: number, b: number): number;export function add(a: number): (b: number) => number;
export function addIndex(originalFn: any): (fn: any) => (list: any[]) => any[];export function addIndex(originalFn: any): (fn: any, list: any[]) => any[];
export function addIndexRight(originalFn: any): (fn: any) => (list: any[]) => any[];export function addIndexRight(originalFn: any): (fn: any, list: any[]) => any[];
export function adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[];export function adjust<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[];
export function all<T>(predicate: (x: T) => boolean, list: T[]): boolean;export function all<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
export function allPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;export function allPass<T>(predicates: ((...inputs: T[]) => boolean)[]): (...inputs: T[]) => boolean;
export function always<T>(x: T): (...args: unknown[]) => T;
export function and<T, U>(x: T, y: U): T | U;export function and<T>(x: T): <U>(y: U) => T | U;
export function any<T>(predicate: (x: T) => boolean, list: T[]): boolean;export function any<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
export function anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;export function anyPass<T>(predicates: ((...inputs: T[]) => boolean)[]): (...inputs: T[]) => boolean;
export function ap<T, U>(fns: Array<(a: T) => U>[], vs: T[]): U[];export function ap<T, U>(fns: Array<(a: T) => U>): (vs: T[]) => U[];export function ap<R, A, B>(fn: (r: R, a: A) => B, fn1: (r: R) => A): (r: R) => B;
export function aperture<N extends number, T>(n: N, list: T[]): Array<Tuple<T, N>> | [];export function aperture<N extends number>(n: N): <T>(list: T[]) => Array<Tuple<T, N>> | [];
export function append<T>(xToAppend: T, iterable: T[]): T[];export function append<T, U>(xToAppend: T, iterable: IsFirstSubtypeOfSecond<T, U>[]) : U[];export function append<T>(xToAppend: T): <U>(iterable: IsFirstSubtypeOfSecond<T, U>[]) => U[];export function append<T>(xToAppend: T): (iterable: T[]) => T[];
export function apply<T = any>(fn: (...args: any[]) => T, args: any[]): T;export function apply<T = any>(fn: (...args: any[]) => T): (args: any[]) => T;
export function applySpec<Spec extends Record<string, AnyFunction>>( spec: Spec): ( ...args: Parameters<ValueOfRecord<Spec>>) => { [Key in keyof Spec]: ReturnType<Spec[Key]> };export function applySpec<T>(spec: any): (...args: unknown[]) => T;
export function applyTo<T, U>(el: T, fn: (t: T) => U): U;export function applyTo<T>(el: T): <U>(fn: (t: T) => U) => U;
export function ascend<T>(fn: (obj: T) => Ord, a: T, b: T): Ordering;export function ascend<T>(fn: (obj: T) => Ord): (a: T, b: T) => Ordering;
export function assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & Omit<U, K>;export function assoc<T, K extends string>(prop: K, val: T): <U>(obj: U) => Record<K, T> & Omit<U, K>;export function assoc<K extends string>(prop: K): AssocPartialOne<K>;
export function assocPath<Output>(path: Path, newValue: any, obj: object): Output;export function assocPath<Output>(path: Path, newValue: any): (obj: object) => Output;export function assocPath<Output>(path: Path): (newValue: any) => (obj: object) => Output;
export function binary<T extends (...arg: any[]) => any>(fn: T): (...args: any[]) => ReturnType<T>;
export function bind<F extends AnyFunction, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>;export function bind<F extends AnyFunction, T>(fn: F): (thisObj: T) => (...args: Parameters<F>) => ReturnType<F>;
export function both(pred1: Pred, pred2: Pred): Pred;export function both<T>(pred1: Predicate<T>, pred2: Predicate<T>): Predicate<T>;export function both<T>(pred1: Predicate<T>): (pred2: Predicate<T>) => Predicate<T>;export function both(pred1: Pred): (pred2: Pred) => Pred;
export function call<T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>): ReturnType<T>;
export function chain<T, U>(fn: (n: T) => U[], list: T[]): U[];export function chain<T, U>(fn: (n: T) => U[]): (list: T[]) => U[];
export function clamp(min: number, max: number, input: number): number;export function clamp(min: number, max: number): (input: number) => number;
export function clone<T>(input: T): T;export function clone<T>(input: T[]): T[];
export function collectBy<T, K extends PropertyKey>(keyFn: (value: T) => K, list: T[]): T[][];export function collectBy<T, K extends PropertyKey>(keyFn: (value: T) => K): (list: T[]) => T[][];
export function comparator<T>(pred: (a: T, b: T) => boolean): (x: T, y: T) => Ordering;
export function complement<T extends any[]>(predicate: (...args: T) => unknown): (...args: T) => boolean;
export function compose<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7, TResult>( ...func: [ fnLast: (a: any) => TResult, ...func: Array<(a: any) => any>, f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: TArgs) => R1 ]): (...args: TArgs) => TResult;export function compose<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7, TResult>( f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: TArgs) => R1): (...args: TArgs) => R7;export function compose<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7>( f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: TArgs) => R1): (...args: TArgs) => R7;export function compose<TArgs extends any[], R1, R2, R3, R4, R5, R6>( f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: TArgs) => R1): (...args: TArgs) => R6;export function compose<TArgs extends any[], R1, R2, R3, R4, R5>( f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: TArgs) => R1): (...args: TArgs) => R5;export function compose<TArgs extends any[], R1, R2, R3, R4>( f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: TArgs) => R1): (...args: TArgs) => R4;export function compose<TArgs extends any[], R1, R2, R3>( f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: TArgs) => R1): (...args: TArgs) => R3;export function compose<TArgs extends any[], R1, R2>( f2: (a: R1) => R2, f1: (...args: TArgs) => R1): (...args: TArgs) => R2;export function compose<TArgs extends any[], R1>( f1: (...args: TArgs) => R1): (...args: TArgs) => R1;
export function composeWith<TArgs extends any[], TResult>( transformer: (fn: (...args: any[]) => any, intermediatResult: any) => any, fns: AtLeastOneFunctionsFlowFromRightToLeft<TArgs, TResult>,): (...args: TArgs) => TResult;export function composeWith( transformer: (fn: (...args: any[]) => any, intermediatResult: any) => any,): <TArgs extends any[], TResult>( fns: AtLeastOneFunctionsFlowFromRightToLeft<TArgs, TResult>,) => (...args: TArgs) => TResult;
export function concat<T>(x: T[], y: T[]): T[];export function concat<T>(x: T[]): (y: T[]) => T[];export function concat(x: string, y: string): string;export function concat(x: string): (y: string) => string;
export function cond<T extends any[], R>(conditions: Array<CondPair<T, R>>): (...args: T) => R;
export function converge(after: ((...a: any[]) => any), fns: ((...x: any[]) => any)[]): (...y: any[]) => any;
export function count<T>(predicate: (x: T) => boolean, list: T[]): number;export function count<T>(predicate: (x: T) => boolean): (list: T[]) => number;
export function countBy<T extends unknown>(transformFn: (x: T) => any, list: T[]): Record<string, number>;export function countBy<T extends unknown>(transformFn: (x: T) => any): (list: T[]) => Record<string, number>;
export function curry(fn: AnyFunction): (...a: any[]) => any;
export function curryN(length: number, fn: AnyFunction): (...a: any[]) => any;
export function dec(x: number): number;
export function defaultTo<T>(defaultValue: T, input: T | null | undefined): T;export function defaultTo<T>(defaultValue: T): (input: T | null | undefined) => T;
export function descend<T>(fn: (obj: T) => Ord, a: T, b: T): Ordering;export function descend<T>(fn: (obj: T) => Ord): (a: T, b: T) => Ordering;
export function difference<T>(a: T[], b: T[]): T[];export function difference<T>(a: T[]): (b: T[]) => T[];
export function differenceWith<T1, T2>( pred: (a: T1, b: T2) => boolean, list1: T1[], list2: T2[],): T1[];export function differenceWith<T1, T2>( pred: (a: T1, b: T2) => boolean,): (list1: T1[], list2: T2[]) => T1[];export function differenceWith<T1, T2>( pred: (a: T1, b: T2) => boolean, list1: T1[],): (list2: T2[]) => T1[];
export function dissoc<T extends object, K extends keyof T>(prop: K, obj: T): Omit<T, K>;export function dissoc<K extends string | number>(prop: K): <T extends object>(obj: T) => Omit<T, K>;
export function dissocPath<T>(path: Path, obj: any): T;export function dissocPath<T>(path: Path): (obj: any) => T;
export function divide(x: number, y: number): number;export function divide(x: number): (y: number) => number;
export function drop<T>(howMany: number, input: T[]): T[];export function drop(howMany: number, input: string): string;export function drop<T>(howMany: number): { <T>(input: T[]): T[]; (input: string): string;};
export function dropLast<T>(howMany: number, input: T[]): T[];export function dropLast(howMany: number, input: string): string;export function dropLast<T>(howMany: number): { <T>(input: T[]): T[]; (input: string): string;};
export function dropLastWhile(predicate: (x: string) => boolean, iterable: string): string;export function dropLastWhile(predicate: (x: string) => boolean): (iterable: string) => string;export function dropLastWhile<T>(predicate: (x: T) => boolean, iterable: T[]): T[];export function dropLastWhile<T>(predicate: (x: T) => boolean): <T>(iterable: T[]) => T[];
export function dropRepeats<T>(list: T[]): T[];
export function dropRepeatsBy<T, U>(fn: (a: T) => U, list: T[]): T[];export function dropRepeatsBy<T, U>( fn: (a: T) => U): (list: T[]) => T[];export function dropRepeatsBy(fn: any): <T>(list: T[]) => T[];
export function dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean, list: T[]): T[];export function dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean): (list: T[]) => T[];
export function dropWhile(fn: Predicate<string>, iterable: string): string;export function dropWhile(fn: Predicate<string>): (iterable: string) => string;export function dropWhile<T>(fn: Predicate<T>, iterable: T[]): T[];export function dropWhile<T>(fn: Predicate<T>): (iterable: T[]) => T[];
export function either(firstPredicate: Pred, secondPredicate: Pred): Pred;export function either<T>(firstPredicate: Predicate<T>, secondPredicate: Predicate<T>): Predicate<T>;export function either<T>(firstPredicate: Predicate<T>): (secondPredicate: Predicate<T>) => Predicate<T>;export function either(firstPredicate: Pred): (secondPredicate: Pred) => Pred;
export function empty<T>(x: T): T;
export function endsWith<T extends string>(question: T, str: string): boolean;export function endsWith<T extends string>(question: T): (str: string) => boolean;export function endsWith<T>(question: T[], list: T[]): boolean;export function endsWith<T>(question: T[]): (list: T[]) => boolean;
export function eqBy<T>(fn: (a: T) => unknown, a: T, b: T): boolean;export function eqBy<T>(fn: (a: T) => unknown, a: T): (b: T) => boolean;export function eqBy<T>(fn: (a: T) => unknown): { (a: T, b: T): boolean; (a: T): (b: T) => boolean;};
export function eqProps<T, U>(prop: string, obj1: T, obj2: U): boolean;export function eqProps<P extends string>(prop: P): <T, U>(obj1: Record<P, T>, obj2: Record<P, U>) => boolean;export function eqProps<T>(prop: string, obj1: T): <U>(obj2: U) => boolean;
export function equals<T>(x: T, y: T): boolean;export function equals<T>(x: T): (y: T) => boolean;
export function evolve<T, U>(rules: ((x: T) => U)[], list: T[]): U[];export function evolve<T, U>(rules: ((x: T) => U)[]) : (list: T[]) => U[];export function evolve<E extends Evolver, V extends Evolvable<E>>(rules: E, obj: V): Evolve<V, E>;export function evolve<E extends Evolver>(rules: E): <V extends Evolvable<E>>(obj: V) => Evolve<V, E>;
export function filter<T>(predicate: Predicate<T>): (input: T[]) => T[];export function filter<T>(predicate: Predicate<T>, input: T[]): T[];export function filter<T, U>(predicate: ObjectPredicate<T>): (x: Dictionary<T>) => Dictionary<T>;export function filter<T>(predicate: ObjectPredicate<T>, x: Dictionary<T>): Dictionary<T>;
export function find<T>(predicate: (x: T) => boolean, list: T[]): T | undefined;export function find<T>(predicate: (x: T) => boolean): (list: T[]) => T | undefined;
export function findIndex<T>(predicate: (x: T) => boolean, list: T[]): number;export function findIndex<T>(predicate: (x: T) => boolean): (list: T[]) => number;
export function findLast<T>(fn: (x: T) => boolean, list: T[]): T | undefined;export function findLast<T>(fn: (x: T) => boolean): (list: T[]) => T | undefined;
export function findLastIndex<T>(predicate: (x: T) => boolean, list: T[]): number;export function findLastIndex<T>(predicate: (x: T) => boolean): (list: T[]) => number;
export function flatten<T>(list: any[]): T[];
export function flip<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult;
export function forEach<T>(fn: Iterator<T, void>, list: T[]): T[];export function forEach<T>(fn: Iterator<T, void>): (list: T[]) => T[];export function forEach<T>(fn: ObjectIterator<T, void>, list: Dictionary<T>): Dictionary<T>;export function forEach<T, U>(fn: ObjectIterator<T, void>): (list: Dictionary<T>) => Dictionary<T>;
export function forEachObjIndexed<T>(fn: (value: T[keyof T], key: keyof T, obj: T) => void, obj: T): T;export function forEachObjIndexed<T>(fn: (value: T[keyof T], key: keyof T, obj: T) => void): (obj: T) => T;
export function fromPairs<V>(listOfPairs: ([number, V])[]): { [index: number]: V };export function fromPairs<V>(listOfPairs: ([string, V])[]): { [index: string]: V };
export function groupBy<T>(groupFn: (x: T) => string, list: T[]): { [index: string]: T[] };export function groupBy<T>(groupFn: (x: T) => string): (list: T[]) => { [index: string]: T[] };export function groupBy<T, U>(groupFn: (x: T) => string, list: T[]): U;export function groupBy<T, U>(groupFn: (x: T) => string): (list: T[]) => U;
export function groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: T[]) => (T[])[];export function groupWith<T>(compareFn: (x: T, y: T) => boolean, input: T[]): (T[])[];export function groupWith<T>(compareFn: (x: T, y: T) => boolean, input: string): string[];
export function gt<T, U>(x: T, y: U): boolean;export function gt<T, U>(x: T): (y: U) => boolean;
export function gte<T, U>(x: T, y: U): boolean;export function gte<T, U>(x: T): (y: U) => boolean;
export function has<T>(prop: string, obj: T): boolean;export function has(prop: string): <T>(obj: T) => boolean;
export function hasIn(searchProperty: string): <T>(obj: T) => boolean;export function hasIn<T>(searchProperty: string, obj: T): boolean;
export function hasPath<T>( path: string | string[], input: object): boolean;export function hasPath<T>( path: string | string[]): (input: object) => boolean;
export function head(str: string): string;export function head(str: ''): undefined;export function head<T>(list: never[]): undefined;export function head<T extends unknown[]>(array: T): FirstArrayElement<T>export function head<T extends readonly unknown[]>(array: T): FirstArrayElement<T>
export function identical<T>(x: T, y: T): boolean;export function identical<T>(x: T): (y: T) => boolean;
export function identity<T>(input: T): T;
export function ifElse<T, TFiltered extends T, TOnTrueResult, TOnFalseResult>( pred: (a: T) => a is TFiltered, onTrue: (a: TFiltered) => TOnTrueResult, onFalse: (a: Exclude<T, TFiltered>) => TOnFalseResult,): (a: T) => TOnTrueResult | TOnFalseResult;export function ifElse<TArgs extends any[], TOnTrueResult, TOnFalseResult>(fn: (...args: TArgs) => boolean, onTrue: (...args: TArgs) => TOnTrueResult, onFalse: (...args: TArgs) => TOnFalseResult): (...args: TArgs) => TOnTrueResult | TOnFalseResult;
export function inc(x: number): number;
export function includes<T extends string>(valueToFind: T, input: string): boolean;export function includes<T extends string>(valueToFind: T): (input: string) => boolean;export function includes<T>(valueToFind: T, input: T[]): boolean;export function includes<T>(valueToFind: T): (input: T[]) => boolean;
export function indexBy<T, K extends string | number = string>(condition: (key: T) => K, list: T[]): { [key in K]: T };export function indexBy<T, K extends string | number | undefined = string>(condition: (key: T) => K, list: T[]): { [key in NonNullable<K>]?: T };export function indexBy<T, K extends string | number = string>(condition: (key: T) => K): (list: T[]) => { [key in K]: T };export function indexBy<T, K extends string | number | undefined = string>(condition: (key: T) => K | undefined): (list: T[]) => { [key in NonNullable<K>]?: T };export function indexBy<T>(condition: string, list: T[]): { [key: string]: T };export function indexBy<T>(condition: string): (list: T[]) => { [key: string]: T };
export function indexOf<T>(valueToFind: T, list: T[]): number;export function indexOf<T>(valueToFind: T): (list: T[]) => number;
export function init<T extends unknown[]>(input: T): T extends readonly [...infer U, any] ? U : [...T];export function init(input: string): string;
export function innerJoin<T1, T2>( pred: (a: T1, b: T2) => boolean,): (list1: T1[], list2: T2[]) => T1[];export function innerJoin<T1, T2>( pred: (a: T1, b: T2) => boolean, list1: T1[],): (list2: T2[]) => T1[];export function innerJoin<T1, T2>(pred: (a: T1, b: T2) => boolean, list1: T1[], list2: T2[]): T1[];
export function insert(index: number): <T>(itemToInsert: T, list: T[]) => T[];export function insert<T>(index: number, itemToInsert: T): (list: T[]) => T[];export function insert<T>(index: number, itemToInsert: T, list: T[]): T[];
export function insertAll(index: number): <T>(itemsToInsert: T[], list: T[]) => T[];export function insertAll<T>(index: number, itemsToInsert: T[]): (list: T[]) => T[];export function insertAll<T>(index: number, itemsToInsert: T[], list: T[]): T[];
export function intersection<T>(listA: T[], listB: T[]): T[];export function intersection<T>(listA: T[]): (listB: T[]) => T[];
export function intersperse<T>(separator: T, list: T[]): T[];export function intersperse<T>(separator: T): (list: T[]) => T[];
export function is<C extends () => any>(targetPrototype: C, val: any): val is ReturnType<C>;export function is<C extends new () => any>(targetPrototype: C, val: any): val is InstanceType<C>;export function is<C extends () => any>(targetPrototype: C): (val: any) => val is ReturnType<C>;export function is<C extends new () => any>(targetPrototype: C): (val: any) => val is InstanceType<C>;
export function isEmpty<T>(x: T): boolean;
export function isNil(x: any): x is null | undefined;
export function isNotNil<T>(value: T): value is NonNullable<T>;
export function join<T>(glue: string, list: T[]): string;export function join<T>(glue: string): (list: T[]) => string;
export function juxt<A extends any[], R1>(fns: [(...a: A) => R1]): (...a: A) => [R1];export function juxt<A extends any[], R1, R2>(fns: [(...a: A) => R1, (...a: A) => R2]): (...a: A) => [R1, R2];export function juxt<A extends any[], R1, R2, R3>(fns: [(...a: A) => R1, (...a: A) => R2, (...a: A) => R3]): (...a: A) => [R1, R2, R3];export function juxt<A extends any[], R1, R2, R3, R4>(fns: [(...a: A) => R1, (...a: A) => R2, (...a: A) => R3, (...a: A) => R4]): (...a: A) => [R1, R2, R3, R4];export function juxt<A extends any[], R1, R2, R3, R4, R5>(fns: [(...a: A) => R1, (...a: A) => R2, (...a: A) => R3, (...a: A) => R4, (...a: A) => R5]): (...a: A) => [R1, R2, R3, R4, R5];export function juxt<A extends any[], U>(fns: Array<(...args: A) => U>): (...args: A) => U[];
export function keys<T extends object>(x: T): (keyof T & string)[];export function keys<T>(x: T): string[];
export function last(str: ''): undefined;export function last(str: string): string;export function last(list: never[]): undefined;export function last<T extends unknown[]>(array: T): LastArrayElement<T>export function last<T extends readonly unknown[]>(array: T): LastArrayElement<T>
export function lastIndexOf<T>(target: T, list: T[]): number;export function lastIndexOf<T>(target: T): (list: T[]) => number;
export function length<T>(input: T[]): number;
export function lens<S, A>(getter: (s: S) => A, setter: (a: A, s: S) => S): Lens<S, A>;
export function lensIndex<A>(n: number): Lens<A[], A>;export function lensIndex<A extends any[], N extends number>(n: N): Lens<A, A[N]>;
export function lensPath<S, K0 extends keyof S = keyof S>(path: [K0]): Lens<S, S[K0]>;export function lensPath<S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0]>( path: [K0, K1],): Lens<S, S[K0][K1]>;export function lensPath< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1]>(path: [K0, K1, K2]): Lens<S, S[K0][K1][K2]>;export function lensPath< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1], K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2]>(path: [K0, K1, K2, K3]): Lens<S, S[K0][K1][K2][K3]>;export function lensPath< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1], K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2], K4 extends keyof S[K0][K1][K2][K3] = keyof S[K0][K1][K2][K3]>(path: [K0, K1, K2, K3, K4]): Lens<S, S[K0][K1][K2][K3][K4]>;export function lensPath< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1], K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2], K4 extends keyof S[K0][K1][K2][K3] = keyof S[K0][K1][K2][K3], K5 extends keyof S[K0][K1][K2][K3][K4] = keyof S[K0][K1][K2][K3][K4]>(path: [K0, K1, K2, K3, K4, K5]): Lens<S, S[K0][K1][K2][K3][K4][K5]>;export function lensPath<S = any, A = any>(path: Path): Lens<S, A>;
export function lensProp<S, K extends keyof S = keyof S>(prop: K): Lens<S, S[K]>;
export function lt<T, U>(x: T, y: U): boolean;export function lt<T, U>(x: T): (y: U) => boolean;
export function map<T, U>(fn: ObjectIterator<T, U>, iterable: Dictionary<T>): Dictionary<U>;export function map<T, U>(fn: Iterator<T, U>, iterable: T[]): U[];export function map<T, U>(fn: Iterator<T, U>): (iterable: T[]) => U[];export function map<T, U, S>(fn: ObjectIterator<T, U>): (iterable: Dictionary<T>) => Dictionary<U>;export function map<T>(fn: Iterator<T, T>): (iterable: T[]) => T[];export function map<T>(fn: Iterator<T, T>, iterable: T[]): T[];
export function mapObjIndexed<T>(fn: ObjectIterator<T, T>, iterable: Dictionary<T>): Dictionary<T>;export function mapObjIndexed<T, U>(fn: ObjectIterator<T, U>, iterable: Dictionary<T>): Dictionary<U>;export function mapObjIndexed<T>(fn: ObjectIterator<T, T>): (iterable: Dictionary<T>) => Dictionary<T>;export function mapObjIndexed<T, U>(fn: ObjectIterator<T, U>): (iterable: Dictionary<T>) => Dictionary<U>;
export function match(regExpression: RegExp, str: string): string[];export function match(regExpression: RegExp): (str: string) => string[];
export function mathMod(x: number, y: number): number;export function mathMod(x: number): (y: number) => number;
export function max<T extends Ord>(x: T, y: T): T;export function max<T extends Ord>(x: T): (y: T) => T;
export function maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T;export function maxBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;export function maxBy<T>(compareFn: (input: T) => Ord): (x: T) => (y: T) => T;
export function mean(list: number[]): number;
export function median(list: number[]): number;
export function merge<A, B>(target: A, newProps: B): A & Bexport function merge<Output>(target: any): (newProps: any) => Output;
export function mergeAll<T>(list: object[]): T;export function mergeAll(list: object[]): object;
export function mergeDeepLeft<Output>(newProps: object, target: object): Output;export function mergeDeepLeft<Output>(newProps: object): (target: object) => Output;
export function mergeDeepRight<Output>(target: object, newProps: object): Output;export function mergeDeepRight<Output>(target: object): (newProps: object) => Output;
export function mergeLeft<Output>(newProps: object, target: object): Output;export function mergeLeft<Output>(newProps: object): (target: object) => Output;
export function mergeRight<A, B>(target: A, newProps: B): A & Bexport function mergeRight<Output>(target: any): (newProps: any) => Output;
export function mergeWith(fn: (x: any, z: any) => any, a: Record<string, unknown>, b: Record<string, unknown>): Record<string, unknown>;export function mergeWith<Output>(fn: (x: any, z: any) => any, a: Record<string, unknown>, b: Record<string, unknown>): Output;export function mergeWith(fn: (x: any, z: any) => any, a: Record<string, unknown>): (b: Record<string, unknown>) => Record<string, unknown>;export function mergeWith<Output>(fn: (x: any, z: any) => any, a: Record<string, unknown>): (b: Record<string, unknown>) => Output;export function mergeWith(fn: (x: any, z: any) => any): <U, V>(a: U, b: V) => Record<string, unknown>;export function mergeWith<Output>(fn: (x: any, z: any) => any): <U, V>(a: U, b: V) => Output;
export function min<T extends Ord>(x: T, y: T): T;export function min<T extends Ord>(x: T): (y: T) => T;
export function minBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T;export function minBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;export function minBy<T>(compareFn: (input: T) => Ord): (x: T) => (y: T) => T;
export function modify<T extends object, K extends keyof T, P>( prop: K, fn: (a: T[K]) => P, obj: T,): Omit<T, K> & Record<K, P>;export function modify<K extends string, A, P>( prop: K, fn: (a: A) => P,): <T extends Record<K, A>>(target: T) => Omit<T, K> & Record<K, P>;
export function modifyPath<T extends Record<string, unknown>>(path: Path, fn: (x: any) => unknown, object: Record<string, unknown>): T;export function modifyPath<T extends Record<string, unknown>>(path: Path, fn: (x: any) => unknown): (object: Record<string, unknown>) => T;export function modifyPath<T extends Record<string, unknown>>(path: Path): (fn: (x: any) => unknown) => (object: Record<string, unknown>) => T;
export function modulo(x: number, y: number): number;export function modulo(x: number): (y: number) => number;
export function move<T>(fromIndex: number, toIndex: number, list: T[]): T[];export function move(fromIndex: number, toIndex: number): <T>(list: T[]) => T[];export function move(fromIndex: number): { <T>(toIndex: number, list: T[]): T[]; (toIndex: number): <T>(list: T[]) => T[];};
export function multiply(x: number, y: number): number;export function multiply(x: number): (y: number) => number;
export function negate(x: number): number;
export function none<T>(predicate: (x: T) => boolean, list: T[]): boolean;export function none<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
export function not(input: any): boolean;
export function nth(index: number, input: string): string; export function nth<T>(index: number, input: T[]): T | undefined; export function nth(n: number): { <T>(input: T[]): T | undefined; (input: string): string;};
export function objOf<T, K extends string>(key: K, value: T): Record<K, T>;export function objOf<K extends string>(key: K): <T>(value: T) => Record<K, T>;
export function of<T>(x: T): T[];
export function omit<T, K extends string>(propsToOmit: K[], obj: T): Omit<T, K>;export function omit<K extends string>(propsToOmit: K[]): <T>(obj: T) => Omit<T, K>;export function omit<T, U>(propsToOmit: string, obj: T): U;export function omit<T, U>(propsToOmit: string): (obj: T) => U;export function omit<T>(propsToOmit: string, obj: object): T;export function omit<T>(propsToOmit: string): (obj: object) => T;
export function on<T, U, R>(binaryFn: (a: U, b: U) => R, unaryFn: (value: T) => U, a: T, b: T): R;export function on<T, U, R>(binaryFn: (a: U, b: U) => R, unaryFn: (value: T) => U, a: T): (b: T) => R;export function on<T, U, R>(binaryFn: (a: U, b: U) => R, unaryFn: (value: T) => U): { (a: T, b: T): R; (a: T): (b: T) => R;};
export function once<T extends AnyFunction>(func: T): T;
export function or<T, U>(a: T, b: U): T | U;export function or<T>(a: T): <U>(b: U) => T | U;
export function over<S, A>(lens: Lens<S, A>): { (fn: (a: A) => A): (value: S) => S; (fn: (a: A) => A, value: S): S;};export function over<S, A>(lens: Lens<S, A>, fn: (a: A) => A): (value: S) => S;export function over<S, A>(lens: Lens<S, A>, fn: (a: A) => A, value: S): S;
export function partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T;export function partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0, V1]): (x2: V2) => T;export function partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0]): (x1: V1, x2: V2) => T;export function partial<V0, V1, V2, V3, T>( fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1, V2],): (x2: V3) => T;export function partial<V0, V1, V2, V3, T>( fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1],): (x2: V2, x3: V3) => T;export function partial<V0, V1, V2, V3, T>( fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0],): (x1: V1, x2: V2, x3: V3) => T;export function partial<T>(fn: (...a: any[]) => T, args: any[]): (...a: any[]) => T;
export function partialObject<Input, PartialInput, Output>( fn: (input: Input) => Output, partialInput: PartialInput,): (input: Pick<Input, Exclude<keyof Input, keyof PartialInput>>) => Output;
export function partition<T>( predicate: Predicate<T>, input: T[]): [T[], T[]];export function partition<T>( predicate: Predicate<T>): (input: T[]) => [T[], T[]];export function partition<T>( predicate: (x: T, prop?: string) => boolean, input: { [key: string]: T}): [{ [key: string]: T}, { [key: string]: T}];export function partition<T>( predicate: (x: T, prop?: string) => boolean): (input: { [key: string]: T}) => [{ [key: string]: T}, { [key: string]: T}];
export function path<S, K0 extends keyof S = keyof S>(path: [K0], obj: S): S[K0];export function path<S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0]>(path: [K0, K1], obj: S): S[K0][K1];export function path< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1]>(path: [K0, K1, K2], obj: S): S[K0][K1][K2];export function path< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1], K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2],>(path: [K0, K1, K2, K3], obj: S): S[K0][K1][K2][K3];export function path< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1], K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2], K4 extends keyof S[K0][K1][K2][K3] = keyof S[K0][K1][K2][K3],>(path: [K0, K1, K2, K3, K4], obj: S): S[K0][K1][K2][K3][K4];export function path< S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0], K2 extends keyof S[K0][K1] = keyof S[K0][K1], K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2], K4 extends keyof S[K0][K1][K2][K3] = keyof S[K0][K1][K2][K3], K5 extends keyof S[K0][K1][K2][K3][K4] = keyof S[K0][K1][K2][K3][K4],>(path: [K0, K1, K2, K3, K4, K5], obj: S): S[K0][K1][K2][K3][K4][K5];export function path<T>(pathToSearch: string, obj: any): T | undefined;export function path<T>(pathToSearch: string): (obj: any) => T | undefined;export function path<T>(pathToSearch: RamdaPath): (obj: any) => T | undefined;export function path<T>(pathToSearch: RamdaPath, obj: any): T | undefined;
export function pathEq(pathToSearch: Path, target: any, input: any): boolean;export function pathEq(pathToSearch: Path, target: any): (input: any) => boolean;export function pathEq(pathToSearch: Path): (target: any) => (input: any) => boolean;
export function pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T;export function pathOr<T>(defaultValue: T, pathToSearch: Path): (obj: any) => T;export function pathOr<T>(defaultValue: T): (pathToSearch: Path) => (obj: any) => T;
export function pathSatisfies<T, U>(pred: (val: T) => boolean, path: Path): (obj: U) => boolean;export function pathSatisfies<T, U>(pred: (val: T) => boolean, path: Path, obj: U): boolean;
export function paths<Input, T>(pathsToSearch: Path[], obj: Input): (T | undefined)[];export function paths<Input, T>(pathsToSearch: Path[]): (obj: Input) => (T | undefined)[];export function paths<T>(pathsToSearch: Path[], obj: any): (T | undefined)[];export function paths<T>(pathsToSearch: Path[]): (obj: any) => (T | undefined)[];
export function pick<T, K extends string | number | symbol>(propsToPick: K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;export function pick<K extends string | number | symbol>(propsToPick: K[]): <T>(input: T) => Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;export function pick<T, U>(propsToPick: string, input: T): U;export function pick<T, U>(propsToPick: string): (input: T) => U;export function pick<T>(propsToPick: string, input: object): T;export function pick<T>(propsToPick: string): (input: object) => T;
export function pickAll<T, K extends keyof T>(propsToPicks: K[], input: T): Pick<T, K>;export function pickAll<T, U>(propsToPicks: string[], input: T): U;export function pickAll(propsToPicks: string[]): <T, U>(input: T) => U;export function pickAll<T, U>(propsToPick: string, input: T): U;export function pickAll<T, U>(propsToPick: string): (input: T) => U;
export function pickBy<T>(pred: ObjPred<T>): <U, V extends T>(obj: V) => U;export function pickBy<T, U>(pred: ObjPred<T>, obj: T): U;
export function pipe<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7, TResult>( ...funcs: [ f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array<(a: any) => any>, fnLast: (a: any) => TResult ]): (...args: TArgs) => TResult; export function pipe<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7>( f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: TArgs) => R7;export function pipe<TArgs extends any[], R1, R2, R3, R4, R5, R6>( f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: TArgs) => R6;export function pipe<TArgs extends any[], R1, R2, R3, R4, R5>( f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: TArgs) => R5;export function pipe<TArgs extends any[], R1, R2, R3, R4>( f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: TArgs) => R4;export function pipe<TArgs extends any[], R1, R2, R3>( f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: TArgs) => R3;export function pipe<TArgs extends any[], R1, R2>( f1: (...args: TArgs) => R1, f2: (a: R1) => R2): (...args: TArgs) => R2;export function pipe<TArgs extends any[], R1>( f1: (...args: TArgs) => R1): (...args: TArgs) => R1;
export function pluck<K extends keyof T, T>(property: K, list: T[]): T[K][];export function pluck<T>(property: number, list: { [k: number]: T }[]): T[];export function pluck<P extends string>(property: P): <T>(list: Record<P, T>[]) => T[];export function pluck(property: number): <T>(list: { [k: number]: T }[]) => T[];
export function prepend<T>(xToPrepend: T, iterable: T[]): T[];export function prepend<T, U>(xToPrepend: T, iterable: IsFirstSubtypeOfSecond<T, U>[]) : U[];export function prepend<T>(xToPrepend: T): <U>(iterable: IsFirstSubtypeOfSecond<T, U>[]) => U[];export function prepend<T>(xToPrepend: T): (iterable: T[]) => T[];
export function product(list: number[]): number;
export function prop<_, P extends keyof never, T>(p: P, value: T): Prop<T, P>;export function prop<V>(p: keyof never, value: unknown): V;export function prop<_, P extends keyof never>(p: P): <T>(value: T) => Prop<T, P>;export function prop<V>(p: keyof never): (value: unknown) => V;
export function propEq<K extends string | number>(valueToMatch: any, propToFind: K, obj: Record<K, any>): boolean;export function propEq<K extends string | number>(valueToMatch: any, propToFind: K): (obj: Record<K, any>) => boolean;export function propEq(valueToMatch: any): { <K extends string | number>(propToFind: K, obj: Record<K, any>): boolean; <K extends string | number>(propToFind: K): (obj: Record<K, any>) => boolean;};
export function propIs<C extends AnyFunction, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>;export function propIs<C extends AnyConstructor, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, InstanceType<C>>;export function propIs<C extends AnyFunction, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, ReturnType<C>>;export function propIs<C extends AnyConstructor, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, InstanceType<C>>;export function propIs<C extends AnyFunction>(type: C): { <K extends keyof any>(name: K, obj: any): obj is Record<K, ReturnType<C>>; <K extends keyof any>(name: K): (obj: any) => obj is Record<K, ReturnType<C>>;};
export function propOr<T, P extends string>(defaultValue: T, property: P, obj: Partial<Record<P, T>> | undefined): T;export function propOr<T, P extends string>(defaultValue: T, property: P): (obj: Partial<Record<P, T>> | undefined) => T;export function propOr<T>(defaultValue: T): { <P extends string>(property: P, obj: Partial<Record<P, T>> | undefined): T; <P extends string>(property: P): (obj: Partial<Record<P, T>> | undefined) => T;}
export function propSatisfies<T>(predicate: Predicate<T>, property: string, obj: Record<string, T>): boolean;export function propSatisfies<T>(predicate: Predicate<T>, property: string): (obj: Record<string, T>) => boolean;
export function props<P extends string, T>(propsToPick: P[], obj: Record<P, T>): T[];export function props<P extends string>(propsToPick: P[]): <T>(obj: Record<P, T>) => T[];export function props<P extends string, T>(propsToPick: P[]): (obj: Record<P, T>) => T[];
export function range(startInclusive: number, endExclusive: number): number[];export function range(startInclusive: number): (endExclusive: number) => number[];
export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: T[]): TResult;export function reduce<T, TResult>(reducer: (prev: TResult, current: T) => TResult, initialValue: TResult, list: T[]): TResult;export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult): (initialValue: TResult, list: T[]) => TResult;export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult): (list: T[]) => TResult;
export function reduceBy<T, TResult>( valueFn: (acc: TResult, elem: T) => TResult,): (a: TResult, b: (elem: T) => string, c: T[]) => { [index: string]: TResult }export function reduceBy<T, TResult>( valueFn: (acc: TResult, elem: T) => TResult, acc: TResult,): (a: (elem: T) => string, b: T[]) => { [index: string]: TResult }export function reduceBy<T, TResult>( valueFn: (acc: TResult, elem: T) => TResult, acc: TResult, keyFn: (elem: T) => string,): (list: T[]) => { [index: string]: TResult };export function reduceBy<T, TResult>( valueFn: (acc: TResult, elem: T) => TResult, acc: TResult, keyFn: (elem: T) => string, list: T[],): { [index: string]: TResult };
export function reject<T>(predicate: Predicate<T>, list: T[]): T[];export function reject<T>(predicate: Predicate<T>): (list: T[]) => T[];export function reject<T>(predicate: Predicate<T>, obj: Dictionary<T>): Dictionary<T>;export function reject<T, U>(predicate: Predicate<T>): (obj: Dictionary<T>) => Dictionary<T>;
export function removeIndex<T>(index: number, list: T[]): T[];export function removeIndex(index: number): <T>(list: T[]) => T[];
export function repeat<T>(x: T): (timesToRepeat: number) => T[];export function repeat<T>(x: T, timesToRepeat: number): T[];
export function replace(strOrRegex: RegExp | string, replacer: RegExpReplacer, str: string): string;export function replace(strOrRegex: RegExp | string, replacer: RegExpReplacer): (str: string) => string;export function replace(strOrRegex: RegExp | string): (replacer: RegExpReplacer) => (str: string) => string;
export function reverse<T>(input: T[]): T[];export function reverse(input: string): string;
export function set<S, A>(lens: Lens<S, A>): { (a: A): (obj: S) => S (a: A, obj: S): S};export function set<S, A>(lens: Lens<S, A>, a: A): (obj: S) => S;export function set<S, A>(lens: Lens<S, A>, a: A, obj: S): S;
export function slice(from: number, to: number, input: string): string;export function slice<T>(from: number, to: number, input: T[]): T[];export function slice(from: number, to: number): { (input: string): string; <T>(input: T[]): T[];};export function slice(from: number): { (to: number, input: string): string; <T>(to: number, input: T[]): T[];};
export function sort<T>(sortFn: (a: T, b: T) => number, list: T[]): T[];export function sort<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
export function sortBy<T>(sortFn: (a: T) => Ord, list: T[]): T[];export function sortBy<T>(sortFn: (a: T) => Ord): (list: T[]) => T[];export function sortBy(sortFn: (a: any) => Ord): <T>(list: T[]) => T[];
export function sortWith<T>(fns: Array<(a: T, b: T) => number>): (list: T[]) => T[];export function sortWith<T>(fns: Array<(a: T, b: T) => number>, list: T[]): T[];
export function split(separator: string | RegExp): (str: string) => string[];export function split(separator: string | RegExp, str: string): string[];
export function splitAt<T>(index: number, input: T[]): [T[], T[]];export function splitAt(index: number, input: string): [string, string];export function splitAt(index: number): { <T>(input: T[]): [T[], T[]]; (input: string): [string, string];};
export function splitEvery<T>(sliceLength: number, input: T[]): (T[])[];export function splitEvery(sliceLength: number, input: string): string[];export function splitEvery(sliceLength: number): { (input: string): string[]; <T>(input: T[]): (T[])[];};
export function splitWhen<T, U>(predicate: Predicate<T>, list: U[]): (U[])[];export function splitWhen<T>(predicate: Predicate<T>): <U>(list: U[]) => (U[])[];
export function startsWith<T extends string>(question: T, input: string): boolean;export function startsWith<T extends string>(question: T): (input: string) => boolean;export function startsWith<T>(question: T[], input: T[]): boolean;export function startsWith<T>(question: T[]): (input: T[]) => boolean;
export function subtract(x: number, y: number): number;export function subtract(x: number): (y: number) => number;
export function sum(list: number[]): number;
export function swap(indexA: number, indexB: number): <T>(list: T[]) => T[];export function swap<T>(indexA: number, indexB: number, list: T[]): T[];
export function symmetricDifference<T>(x: T[], y: T[]): T[];export function symmetricDifference<T>(x: T[]): <T>(y: T[]) => T[];
export function tail<T extends unknown[]>(input: T): T extends [any, ...infer U] ? U : [...T];export function tail(input: string): string;
export function take<T>(howMany: number, input: T[]): T[];export function take(howMany: number, input: string): string;export function take<T>(howMany: number): { <T>(input: T[]): T[]; (input: string): string;};
export function takeLast<T>(howMany: number, input: T[]): T[];export function takeLast(howMany: number, input: string): string;export function takeLast<T>(howMany: number): { <T>(input: T[]): T[]; (input: string): string;};
export function takeLastWhile(predicate: (x: string) => boolean, input: string): string;export function takeLastWhile(predicate: (x: string) => boolean): (input: string) => string;export function takeLastWhile<T>(predicate: (x: T) => boolean, input: T[]): T[];export function takeLastWhile<T>(predicate: (x: T) => boolean): <T>(input: T[]) => T[];
export function takeWhile(fn: Predicate<string>, iterable: string): string;export function takeWhile(fn: Predicate<string>): (iterable: string) => string;export function takeWhile<T>(fn: Predicate<T>, iterable: T[]): T[];export function takeWhile<T>(fn: Predicate<T>): (iterable: T[]) => T[];
export function tap<T>(fn: (x: T) => void, input: T): T;export function tap<T>(fn: (x: T) => void): (input: T) => T;
export function test(regExpression: RegExp): (str: string) => boolean;export function test(regExpression: RegExp, str: string): boolean;
export function times<T>(fn: (i: number) => T, howMany: number): T[];export function times<T>(fn: (i: number) => T): (howMany: number) => T[];
export function toLower<S extends string>(str: S): Lowercase<S>;export function toLower(str: string): string;
export function toPairs<O extends object, K extends Extract<keyof O, string | number>>(obj: O): Array<{ [key in K]: [`${key}`, O[key]] }[K]>;export function toPairs<S>(obj: Record<string | number, S>): Array<[string, S]>;
export function toString(x: unknown): string;
export function toUpper<S extends string>(str: S): Uppercase<S>;export function toUpper(str: string): string;
export function transpose<T>(list: (T[])[]): (T[])[];
export function trim(str: string): string;
export function tryCatch<T, U>( fn: (input: T) => U, fallback: U): (input: T) => U;export function tryCatch<T, U>( fn: (input: T) => U, fallback: (input: T) => U): (input: T) => U;export function tryCatch<T>( fn: (input: any) => Promise<any>, fallback: T): (input: any) => Promise<T>;export function tryCatch<T>( fn: (input: any) => Promise<any>, fallback: (input: any) => Promise<any>,): (input: any) => Promise<T>;
export function type(x: any): RambdaTypes;
export function unapply<T = any>(fn: (args: any[]) => T): (...args: any[]) => T;
export function union<T>(x: T[], y: T[]): T[];export function union<T>(x: T[]): (y: T[]) => T[];
export function uniq<T>(list: T[]): T[];
export function uniqBy<T, U>(fn: (a: T) => U, list: T[]): T[];export function uniqBy<T, U>(fn: (a: T) => U): (list: T[]) => T[];
export function uniqWith<T, U>(predicate: (x: T, y: T) => boolean, list: T[]): T[];export function uniqWith<T, U>(predicate: (x: T, y: T) => boolean): (list: T[]) => T[];
export function unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, x: T): T | U;export function unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U): (x: T) => T | U;export function unless<T>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => T, x: T): T;export function unless<T>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => T): (x: T) => T;
export function unnest(list: unknown[]): unknown[];export function unnest<T>(list: unknown[]): T;
export function unwind<T, U>(prop: keyof T, obj: T): U[];export function unwind<T, U>(prop: keyof T): (obj: T) => U[];
export function update<T>(index: number, newValue: T, list: T[]): T[];export function update<T>(index: number, newValue: T): (list: T[]) => T[];
export function values<T extends object, K extends keyof T>(obj: T): T[K][];
export function view<S, A>(lens: Lens<S, A>): (obj: S) => A;export function view<S, A>(lens: Lens<S, A>, obj: S): A;
export function when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): T | U;export function when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U): (input: T) => T | U;export function when<T, U>(predicate: (x: T) => boolean): ((whenTrueFn: (a: T) => U) => (input: T) => T | U);
export function where<T, U>(conditions: T, input: U): boolean;export function where<T>(conditions: T): <U>(input: U) => boolean;export function where<ObjFunc2, U>(conditions: ObjFunc2, input: U): boolean;export function where<ObjFunc2>(conditions: ObjFunc2): <U>(input: U) => boolean;
export function whereAny<T, U>(conditions: T, input: U): boolean;export function whereAny<T>(conditions: T): <U>(input: U) => boolean;export function whereAny<ObjFunc2, U>(conditions: ObjFunc2, input: U): boolean;export function whereAny<ObjFunc2>(conditions: ObjFunc2): <U>(input: U) => boolean;
export function whereEq<T, U>(condition: T, input: U): boolean;export function whereEq<T>(condition: T): <U>(input: U) => boolean;
export function without<T>(matchAgainst: T[], source: T[]): T[];export function without<T>(matchAgainst: T[]): (source: T[]) => T[];
export function xor(x: boolean, y: boolean): boolean;export function xor(y: boolean): (y: boolean) => boolean;
export function zip<K, V>(x: K[], y: V[]): KeyValuePair<K, V>[];export function zip<K>(x: K[]): <V>(y: V[]) => KeyValuePair<K, V>[];
export function zipObj<T, K extends string>(keys: K[], values: T[]): { [P in K]: T };export function zipObj<K extends string>(keys: K[]): <T>(values: T[]) => { [P in K]: T };export function zipObj<T, K extends number>(keys: K[], values: T[]): { [P in K]: T };export function zipObj<K extends number>(keys: K[]): <T>(values: T[]) => { [P in K]: T };
export function zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: T[], list2: U[]): TResult[];export function zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: T[]): (list2: U[]) => TResult[];export function zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult): (list1: T[], list2: U[]) => TResult[];