export type RambdaTypes = "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "RegExp" | "NaN" | "Function" | "Undefined" | "Async" | "Promise" | "Symbol" | "Set" | "Error";
export 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 Path = string | (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;export type RamdaPath = (number | string)[];type CondPair<T extends any[], R> = [(...val: T) => boolean, (...val: T) => R]
type ValueOfRecord<R> = R extends Record<any, infer T> ? T : never;
interface KeyValuePair<K, V> extends Array<K | V> { 0: K; 1: V;}
export interface Lens { <T, U>(obj: T): U; set<T, U>(str: string, obj: T): U;}
type Arity1Fn = (x: any) => any;type Arity2Fn = (x: any, y: any) => any;
type Pred = (...x: any[]) => boolean;type SafePred<T> = (...x: T[]) => boolean;
export interface Dictionary<T> {[index: string]: T}type Partial<T> = { [P in keyof T]?: T[P]};
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 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>;}
interface IsValid { input: object; schema: Schema;}
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 add(a: number, b: number): number;export function add(a: number): (b: number) => number;
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 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 or<T, U>(a: T, b: U): T | U;export function or<T>(a: T): <U>(b: 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: SafePred<T>[]): SafePred<T>;
export function append<T>(x: T, list: T[]): T[];export function append<T>(x: T): <T>(list: T[]) => T[];
export function applySpec<Spec extends Record<string, (...args: any[]) => any>>( spec: Spec): ( ...args: Parameters<ValueOfRecord<Spec>>) => { [Key in keyof Spec]: ReturnType<Spec[Key]> };export function applySpec<T>(spec: any): (...args: any[]) => T;
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 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 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 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 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 curry(fn: (...args: any[]) => any): (...a: any[]) => any;
export function curryN(length: number, fn: (...args: any[]) => any): (...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 difference<T>(a: T[], b: T[]): T[];export function difference<T>(a: T[]): (b: T[]) => T[];
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 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 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 endsWith(target: string, iterable: string): boolean;export function endsWith(target: string): (iterable: string) => boolean;export function endsWith<T>(target: T[], list: T[]): boolean;export function endsWith<T>(target: T[]): (list: T[]) => boolean;
export function equals<T>(x: T, y: T): boolean;export function equals<T>(x: T): (y: T) => boolean;
export function F(): boolean;
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 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 has<T>(prop: string, obj: T): boolean;export function has(prop: string): <T>(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(input: string): string;export function head(emptyList: []): undefined;export function head<T>(input: T[]): T | undefined;
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<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(valueToFind: string, input: string[] | string): boolean;export function includes(valueToFind: string): (input: string[] | 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>(input: T[]): T[];export function init(input: string): string;
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 join<T>(glue: string, list: T[]): string;export function join<T>(glue: string): (list: T[]) => string;
export function keys<T extends object>(x: T): (keyof T)[];export function keys<T>(x: T): string[];
export function last(str: string): string;export function last(emptyList: []): undefined;export function last<T extends any>(list: T[]): T | undefined;
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<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
export function lensIndex(index: number): Lens;
export function lensPath(path: RamdaPath): Lens;export function lensPath(path: string): Lens;
export function lensProp(prop: string): { <T, U>(obj: T): U; set<T, U, V>(val: T, obj: U): V;};
export function over<T>(lens: Lens, fn: Arity1Fn, value: T): T;export function over<T>(lens: Lens, fn: Arity1Fn, value: T[]): T[];export function over(lens: Lens, fn: Arity1Fn): <T>(value: T) => T;export function over(lens: Lens, fn: Arity1Fn): <T>(value: T[]) => T[];export function over(lens: Lens): <T>(fn: Arity1Fn, value: T) => T;export function over(lens: Lens): <T>(fn: Arity1Fn, value: T[]) => T[];
export function set<T, U>(lens: Lens, replacer: U, obj: T): T;export function set<U>(lens: Lens, replacer: U): <T>(obj: T) => T;export function set(lens: Lens): <T, U>(replacer: U, obj: T) => T;
export function view<T, U>(lens: Lens): (target: T) => U;export function view<T, U>(lens: Lens, target: T): U;
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 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 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 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<T>(index: number, list: T[]): T | undefined; export function nth(index: number): <T>(list: T[]) => T | undefined;
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 once<T extends (...args: any[]) => any>(func: 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 of<T>(x: T): T[];
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[]): (...x: any[]) => T;
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<Input, T>(pathToSearch: Path, obj: Input): T | undefined;export function path<T>(pathToSearch: Path, obj: any): T | undefined;export function path<T>(pathToSearch: Path): (obj: any) => T | undefined;export function path<Input, T>(pathToSearch: Path): (obj: Input) => 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 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 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 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, U>(propsToPick: string[], 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 pickAll<T, U>(propsToPick: string): (input: 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>(x: T, input: T[]): T[];export function prepend<T>(x: T): (input: T[]) => T[];
export function product(list: number[]): number;
export function prop<P extends keyof T, T>(propToFind: P, obj: T): T[P];export function prop<P extends string | number>(p: P): <T>(propToFind: Record<P, T>) => T;export function prop<P extends keyof T, T>(p: P): (propToFind: Record<P, T>) => T;
export function propEq<K extends string | number>(propToFind: K, valueToMatch: any, obj: Record<K, any>): boolean;export function propEq<K extends string | number>(propToFind: K, valueToMatch: any): (obj: Record<K, any>) => boolean;export function propEq<K extends string | number>(propToFind: K): { (valueToMatch: any, obj: Record<K, any>): boolean; (valueToMatch: any): (obj: Record<K, any>) => boolean;};
export function propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>;export function propIs<C extends new (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, InstanceType<C>>;export function propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, ReturnType<C>>;export function propIs<C extends new (...args: any[]) => any, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, InstanceType<C>>;export function propIs<C extends (...args: any[]) => any>(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 propIs<C extends new (...args: any[]) => any>(type: C): { <K extends keyof any>(name: K, obj: any): obj is Record<K, InstanceType<C>>; <K extends keyof any>(name: K): (obj: any) => obj is Record<K, InstanceType<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 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 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 repeat<T>(x: T): (timesToRepeat: number) => T[];export function repeat<T>(x: T, timesToRepeat: number): T[];
export function replace(strOrRegex: RegExp | string, replacer: string, str: string): string;export function replace(strOrRegex: RegExp | string, replacer: string): (str: string) => string;export function replace(strOrRegex: RegExp | string): (replacer: string) => (str: string) => string;
export function reverse<T>(input: T[]): T[];export function reverse(input: string): string;
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 split(separator: string | RegExp): (str: string) => string[];export function split(separator: string | RegExp, str: 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 startsWith(target: string, str: string): boolean;export function startsWith(target: string): (str: string) => boolean;export function startsWith<T>(target: T[], list: T[]): boolean;export function startsWith<T>(target: T[]): (list: 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 symmetricDifference<T>(x: T[], y: T[]): T[];export function symmetricDifference<T>(x: T[]): <T>(y: T[]) => T[];
export function T(): boolean;
export function tail<T>(input: T[]): 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 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 toUpper<S extends string>(str: S): Uppercase<S>;export function toUpper(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 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 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 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 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 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 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 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 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[];
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 splitWhen<T, U>(predicate: Predicate<T>, list: U[]): (U[])[];export function splitWhen<T>(predicate: Predicate<T>): <U>(list: U[]) => (U[])[];
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 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 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 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 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 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 unapply<T = any>(fn: (args: any[]) => T): (...args: any[]) => 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 bind<F extends (...args: any[]) => any, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>;export function bind<F extends (...args: any[]) => any, T>(fn: F): (thisObj: T) => (...args: Parameters<F>) => ReturnType<F>;