import { Function1, Predicate, Lazy } from 'fp-ts/lib/function';
import { Option } from 'fp-ts/lib/Option';
/**
 * Curried map on Option types.
 */
export declare const mapO: <A, B>(f: Function1<A, B>) => (x: Option<A>) => Option<B>;
/**
 * Curried map on lists.
 */
export declare const mapL: <A, B>(f: Function1<A, B>) => (xs: A[]) => B[];
/**
 * Curried map onto es6 Promises.
 */
export declare const mapP: <A, B>(f: Function1<A, B>) => (x: Promise<A>) => Promise<B>;
/**
 * Monadic bind for es6 promises.
 *
 * (They handle it internally, but this just helps keep type signatures clear)
 */
export declare const bindP: <A, B>(f: Function1<A, Promise<B>>) => (x: Promise<A>) => Promise<B>;
/**
 * Given a collection of objects of the same type, merge them. Duplicate keys
 * will be overridden such that the right-most is favoured.
 */
export declare const merge: <T>(...xs: T[]) => T;
/**
 * Given two object create a new (shallow clone) object that combines the
 * properties of both. Duplicate keys will be overridden in preference of `b`.
 */
export declare const extend: <A, B>(a: A, b: B) => A & B;
/**
 * Bind a function to a specific context, preserving the type of the orginal
 * function.
 */
export declare const bind: <T extends Function>(context: any, f: T) => T;
/**
 * Debounce a lazy execution context such that it won't run until it hasn't
 * been called for `wait` milliseconds.
 */
export declare const debounce: <T>(f: Lazy<T>, wait?: number, context?: any) => () => void;
/**
 * Check is a predicate evaluates to true for any elements of a list.
 */
export declare const anyTrue: <T>(xs: T[], f: Predicate<T>) => boolean;
/**
 * Check is a predicate evaluates to true for all elements of a list.
 */
export declare const allTrue: <T>(xs: T[], f: Predicate<T>) => boolean;
/**
 * Given a collection of elements of the same type, combine them into a map of
 * lists of like objects, keyed on the chosen property value.
 */
export declare const group: <T, K extends keyof T>(xs: T[], prop: K) => Map<T[K], T[]>;
/**
 * Find the first element in a list that matches a predicate.
 */
export declare const find: <T>(f: Predicate<T>) => (xs: T[]) => Option<T>;
/**
 * Extract the value from an Option, throwing an exception if it's None.
 *
 * Can be used inside Promise chains to either get a value or reject.
 */
export declare const getOrThrow: (message: string) => <T>(x: Option<T>) => T;