import isPlainObject from 'is-plain-object';
export declare const mapOrElse: (value: any, mappingFunction: (...args: any[]) => any, orElseValue: any) => any;
export declare function identity<T>(val: T): T;
export declare const isFunction: (x: any) => x is Function;
export declare const noop: (..._args: any[]) => void;
export declare const falsy: (val: any) => boolean;
export declare const truthy: (val: any) => boolean;
export declare const eq: (a: any) => (b: any) => boolean;
export declare function pipe<A, B>(f1: (x1: A) => B): (initial: A) => B;
export declare function pipe<A, B, C>(f1: (x1: A) => B, f2: (x2: B) => C): (initial: A) => C;
export declare function pipe<A, B, C, D>(f1: (x1: A) => B, f2: (x2: B) => C, f3: (x3: C) => D): (initial: A) => D;
export declare function pipe<A, B, C, D, E>(f1: (x1: A) => B, f2: (x2: B) => C, f3: (x3: C) => D, f4: (x4: D) => E): (initial: A) => E;
export declare function pipe<A, B, C, D, E, F>(f1: (x1: A) => B, f2: (x2: B) => C, f3: (x3: C) => D, f4: (x4: D) => E, f5: (x5: E) => F): (initial: A) => F;
export declare function pipe<A, B, C, D, E, F, G>(f1: (x1: A) => B, f2: (x2: B) => C, f3: (x3: C) => D, f4: (x4: D) => E, f5: (x5: E) => F, f6: (x6: F) => G): (initial: A) => G;
export declare function pipe<A, B, C, D, E, F, G, H>(f1: (x1: A) => B, f2: (x2: B) => C, f3: (x3: C) => D, f4: (x4: D) => E, f5: (x5: E) => F, f6: (x6: F) => G, f7: (x7: G) => H): (initial: A) => H;
export declare function pipe<A, B, C, D, E, F, G, H, I>(f1: (x1: A) => B, f2: (x2: B) => C, f3: (x3: C) => D, f4: (x4: D) => E, f5: (x5: E) => F, f6: (x6: F) => G, f7: (x7: G) => H, f8: (x8: H) => I): (initial: A) => I;
export declare function pipe<A, B, C, D, E, F, G, H, I, J>(f1: (x1: A) => B, f2: (x2: B) => C, f3: (x3: C) => D, f4: (x4: D) => E, f5: (x5: E) => F, f6: (x6: F) => G, f7: (x7: G) => H, f8: (x8: H) => I, f9: (x9: I) => J): (initial: A) => J;
export declare const first: <T>(arr: T[]) => T;
export declare const last: <T>(arr: T[]) => T;
export declare const zip: <F, S>(xs: F[], ys: (S | undefined)[]) => [F, S][];
export declare const fst: <T>([f, _s]: [T, any]) => T;
export declare const snd: <T>([_f, s]: [any, T]) => T;
export declare function count<T>(items: T[], itemOrPredicate: T | ((x: T) => boolean)): number;
export declare const filterValues: <T extends {}>(obj: T, fn: <K extends keyof T>(val: T[K], key: string) => boolean) => {};
export declare const tryOrDefault: <T>(fn: () => T, fallback: T) => T;
export declare const not: (fn: (...args: any[]) => boolean) => (...args: any[]) => boolean;
export declare const range: (from: number, to: number, step?: number) => number[];
interface IIdLookup<T> {
    [index: string]: T;
}
export declare function dictionaryForIds<T extends {
    [key: string]: string | number;
} & any>(collection: T[], field: keyof T): IIdLookup<T>;
export declare const deepKeys: (obj: IObjectAny, diveIntoArrays?: boolean) => string[];
export declare type Equality<T> = (a: T, b: T) => boolean;
export declare const objectDiffBy: (equalsFn: Equality<any>, objA: IObjectAny, objB: IObjectAny) => {};
export declare const objectDiff: (objA?: IObjectAny, objB?: IObjectAny) => IObjectAny;
export declare const existsDeepDiffBy: (equalsFn: Equality<any>, objA: IObjectAny, objB: IObjectAny) => boolean;
export declare const existsDeepDiff: (objA: IObjectAny, objB: IObjectAny) => boolean;
export declare const deduplicateBy: <T>(key: keyof T, items: T[]) => T[];
export declare const valueOrNull: <T>(x: T) => T | null;
export declare const flatten: <T>(xss: T[][]) => T[];
export declare const flatMap: <T, S = T>(xs: T[], f: (x: T, index: number, arr: T[]) => S[]) => S[];
export declare const omit: <T, K extends keyof T>(o: T, ...keys: K[]) => Pick<T, Exclude<keyof T, K>>;
export declare const pick: <T, K extends keyof T>(o: T, ...keys: K[]) => Pick<T, K>;
export declare const isObject: typeof isPlainObject;
export declare const isEmpty: (x: any) => boolean;
export declare function groupBy<T, K extends string>(xs: T[], grouper: (x: T) => K): {
    [key: string]: T[];
};
export declare function groupBy<T, K extends number>(xs: T[], grouper: (x: T) => K): {
    [key: number]: T[];
};
declare type ILookup<K extends string | number, T> = K extends string ? {
    [key: string]: T;
} : {
    [key: number]: T;
};
export declare function mapValues<T, K extends string, R>(map: ILookup<K, T>, fn: (x: T, key?: string) => R): {
    [key: string]: R;
};
export declare function mapValues<T, K extends number, R>(map: ILookup<K, T>, fn: (x: T, key?: string) => R): {
    [key: number]: R;
};
export declare const isDeepEqual: (a: any, b: any) => boolean;
export declare const isEqual: <T>(xs?: T | undefined, ys?: T | undefined) => boolean;
export declare type Path = string | string[];
export declare const set: <T, K extends DeepKeyOf<T>>(x: T, path: K, value?: DeepTypeOf<T, K> | undefined) => T;
export declare const get: <T, K extends DeepKeyOf<T>>(x: T, path: K, fallback?: DeepTypeOf<T, K> | undefined) => DeepTypeOf<T, K> | undefined;
export declare const mapIfDefined: <T, R>(x: T | null | undefined, f: (a: T) => R) => R | null | undefined;
export declare const defaulting: <T>(value: T | null | undefined, fallback: T) => T;
export declare const mapOrDefault: <T, R>(x: T | null | undefined, f: (a: T) => R, fallback: R) => R;
export declare const takeWhile: <T>(xs: T[], p: (a: T) => boolean) => T[];
export declare const squashObject: <T>(x?: T | undefined) => T | undefined;
export declare const ensureSet: <T>(item: IObjectAny) => Set<T>;
export declare const concatUnique: <T>(xs: T[][]) => T[];
export declare const moveFromToIndex: <T>(xs: T[], i: number, j: number) => T[];
export declare const flattenName: <T>(name: T) => string;
export {};
