import { Curried2, Curried3, Curried4, Curried5, Curried6, Curried7, Curried8, Curried9, Function1, Function2, Function3, Function4, Function5, Function6, Function7, Function8, Function9, Function_21, Function_211, Function_2111, Function_31, Function_311, Function_41, Function_51, Function_61, Complement, PossiblyCurried } from './helper-types';
export declare const define: any;
export declare const defineFunctionProperties: <A>(fn: A, obj: object) => A;
/**
 * Functional pipe, chain applies functions starting from the left and moves right
 *
 * @example
 * const myFormula = pipe( multiply(2), add(5) )
 * myFormula(10) // 25
 *
 * :: f1 |> f2 |> f3 |> ... fn
 */
export declare function pipe<A, B>(ab: (a: A) => B): (a: A) => B;
export declare function pipe<A, B, C>(ab: (a: A) => B, bc: (b: B) => C): (a: A) => C;
export declare function pipe<A, B, C, D>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (a: A) => D;
export declare function pipe<A, B, C, D, E>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (a: A) => E;
export declare function pipe<A, B, C, D, E, F>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (a: A) => F;
export declare function pipe<A, B, C, D, E, F, G>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (a: A) => G;
export declare function pipe<A, B, C, D, E, F, G, H>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): (a: A) => H;
export declare function pipe<A, B, C, D, E, F, G, H, I>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (a: A) => I;
export declare function pipe<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (a: A) => J;
/**
 * Functional composition, chain applies functions starting from the end and moves left
 *
 * @example
 * const myFormula = compose( add(5), multiply(2) )
 * myFormula(10) // 25
 *
 * :: fn |> ... f3 |> f2 |> f1
 */
export declare function compose<A, B, C>(bc: (b: B) => C, ab: (a: A) => B): (a: A) => C;
export declare function compose<A, B, C, D>(cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => D;
export declare function compose<A, B, C, D, E>(de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => E;
export declare function compose<A, B, C, D, E, F>(ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => F;
export declare function compose<A, B, C, D, E, F, G>(fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => G;
export declare function compose<A, B, C, D, E, F, G, H>(gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => H;
export declare function compose<A, B, C, D, E, F, G, H, I>(hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => I;
export declare function compose<A, B, C, D, E, F, G, H, I, J>(ij: (i: I) => J, hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => J;
/**
 * A function similar to `pipe`, however, it starts with the input parameter first.
 *
 * @example
 * pipeline( 10, multiply(2), add(5) ) // 25
 * :: input |> f1 |> f2 |> f3 |> ...fn
 */
export declare function pipeline<A, B>(a: A, ab: (a: A) => B): B;
export declare function pipeline<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
export declare function pipeline<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
export declare function pipeline<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
export declare function pipeline<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
export declare function pipeline<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
export declare function pipeline<A, B, C, D, E, F, G, H>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
export declare function pipeline<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): L;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): M;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N): N;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O): O;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P): P;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q): Q;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R): R;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S): S;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T): T;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U): U;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V): V;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W): W;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X): X;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X, xy: (x: X) => Y): Y;
export declare function pipeline<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: G) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X, xy: (x: X) => Y, yz: (y: Y) => Z): Z;
/**
 * Curries a function.
 *
 * @example
 * add = curry( (a: number, b: number): number => a + b )
 * const increment = add(1)
 * increment( 10 ) // 11
 *
 * :: ( fn( a, b, ... c) -> x ) -> fn -> a -> b -> c -> x
 */
export declare function curry<A, B, C>(f: Function2<A, B, C>): (Curried2<A, B, C> & Function2<A, B, C>);
export declare function curry<A, B, C>(f: Function2<A[], B, C>): (Curried2<A, B, C> & Function2<A, B, C>);
export declare function curry<A, B, C>(f: Function2<A, B[], C>): (Curried2<A, B, C> & Function2<A, B, C>);
export declare function curry<A, B, C>(f: Function2<A[], B[], C>): (Curried2<A, B, C> & Function2<A, B, C>);
export declare function curry<A, B, C, D>(f: Function3<A, B, C, D>): (Curried3<A, B, C, D> & Function3<A, B, C, D> & Function_21<A, B, C, D>);
export declare function curry<A, B, C, D, E>(f: Function4<A, B, C, D, E>): (Curried4<A, B, C, D, E> & Function4<A, B, C, D, E> & Function_211<A, B, C, D, E> & Function_31<A, B, C, D, E>);
export declare function curry<A, B, C, D, E, F>(f: Function5<A, B, C, D, E, F>): (Curried5<A, B, C, D, E, F> & Function5<A, B, C, D, E, F> & Function_2111<A, B, C, D, E, F> & Function_311<A, B, C, D, E, F> & Function_41<A, B, C, D, E, F>);
export declare function curry<A, B, C, D, E, F, G>(f: Function6<A, B, C, D, E, F, G>): (Curried6<A, B, C, D, E, F, G> & Function6<A, B, C, D, E, F, G> & Function_51<A, B, C, D, E, F, G>);
export declare function curry<A, B, C, D, E, F, G, H>(f: Function7<A, B, C, D, E, F, G, H>): (Curried7<A, B, C, D, E, F, G, H> & Function7<A, B, C, D, E, F, G, H> & Function_61<A, B, C, D, E, F, G, H>);
export declare function curry<A, B, C, D, E, F, G, H, I>(f: Function8<A, B, C, D, E, F, G, H, I>): Curried8<A, B, C, D, E, F, G, H, I>;
export declare function curry<A, B, C, D, E, F, G, H, I, J>(f: Function9<A, B, C, D, E, F, G, H, I, J>): Curried9<A, B, C, D, E, F, G, H, I, J>;
/**
 * Curries a function. Untyped parameters, easily adapts to various situations, best coupled with typed signature
 *
 * @example
 * untypedCurry( (a: any, cb: Function) => cb(a) )
 *
 * :: ( fn( a, b, ... c) -> x ) -> fn -> a -> b -> c -> x
 */
export declare function untypedCurry(fn: Function, ...args: any[]): any;
/**
 * Takes array of functions, array of arguments, and returns array of functions with arguments applied.
 * :: (...f) -> (...a) -> [ f1(...a),f2(...a),...]
 */
export declare function parallel<Input, A>(...funcs: [Function1<Input, A>]): (arg: Input) => [A];
export declare function parallel<Input, A, B>(...funcs: [Function1<Input, A>, Function1<Input, B>]): (arg: Input) => [A, B];
export declare function parallel<Input, A, B, C>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>]): (arg: Input) => [A, B, C];
export declare function parallel<Input, A, B, C, D>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>]): (arg: Input) => [A, B, C, D];
export declare function parallel<Input, A, B, C, D, E>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>]): (arg: Input) => [A, B, C, D, E];
export declare function parallel<Input, A, B, C, D, E, F>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>]): (arg: Input) => [A, B, C, D, E, F];
export declare function parallel<Input, A, B, C, D, E, F, G>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>]): (arg: Input) => [A, B, C, D, E, F, G];
export declare function parallel<Input, A, B, C, D, E, F, G, H>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>]): (arg: Input) => [A, B, C, D, E, F, G, H];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>]): (arg: Input) => [A, B, C, D, E, F, G, H, I];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>, Function1<Input, T>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>, Function1<Input, T>, Function1<Input, U>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>, Function1<Input, T>, Function1<Input, U>, Function1<Input, V>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>, Function1<Input, T>, Function1<Input, U>, Function1<Input, V>, Function1<Input, W>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>, Function1<Input, T>, Function1<Input, U>, Function1<Input, V>, Function1<Input, W>, Function1<Input, X>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>, Function1<Input, T>, Function1<Input, U>, Function1<Input, V>, Function1<Input, W>, Function1<Input, X>, Function1<Input, Y>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y];
export declare function parallel<Input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>(...funcs: [Function1<Input, A>, Function1<Input, B>, Function1<Input, C>, Function1<Input, D>, Function1<Input, E>, Function1<Input, F>, Function1<Input, G>, Function1<Input, H>, Function1<Input, I>, Function1<Input, J>, Function1<Input, K>, Function1<Input, L>, Function1<Input, M>, Function1<Input, N>, Function1<Input, O>, Function1<Input, P>, Function1<Input, Q>, Function1<Input, R>, Function1<Input, S>, Function1<Input, T>, Function1<Input, U>, Function1<Input, V>, Function1<Input, W>, Function1<Input, X>, Function1<Input, Y>, Function1<Input, Z>]): (arg: Input) => [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z];
export declare function bindToInstance<T extends any, K extends keyof T>(obj: T, method: K): T[K];
export declare function bindToInstance<T extends any, K extends keyof T>(obj: T): (method: K) => T[K];
/**
 * A looser typed version of parallel
 * :: f[] -> a[] -> [ f1(...a),f2(...a),...]
 */
export declare const parallelLoose: (...funcs: Function[]) => (...args: any[]) => any[];
/**
 * Take a function, then its arguements, then return the boolean opposite of said function
 * :: (...args) -> (fn) -> boolean
 */
export declare const complement: <A>(f: (...args: A[]) => boolean) => (...args: A[]) => boolean;
/**
 * Take a function, then its arguements, then return the boolean opposite of said function.
 * Returns a curried function.
 * :: (...args) -> (fn) -> boolean
 */
export declare function complementCurry<A, B extends boolean>(f: Function1<A, B>): (Function1<A, Complement<B>>);
export declare function complementCurry<A, B, C extends boolean>(f: Function2<A, B, C>): (Curried2<A, B, Complement<C>> & Function2<A, B, Complement<C>>);
export declare function complementCurry<A, B, C extends boolean>(f: Function2<A[], B, C>): (Curried2<A, B, Complement<C>> & Function2<A, B, Complement<C>>);
export declare function complementCurry<A, B, C, D extends boolean>(f: Function3<A, B, C, D>): (Curried3<A, B, C, Complement<D>> & Function3<A, B, C, Complement<D>> & Function_21<A, B, C, Complement<D>>);
export declare function complementCurry<A, B, C, D, E extends boolean>(f: Function4<A, B, C, D, E>): (Curried4<A, B, C, D, Complement<E>> & Function4<A, B, C, D, Complement<E>> & Function_211<A, B, C, D, Complement<E>> & Function_31<A, B, C, D, Complement<E>>);
export declare function complementCurry<A, B, C, D, E, F extends boolean>(f: Function5<A, B, C, D, E, F>): (Curried5<A, B, C, D, E, Complement<F>> & Function5<A, B, C, D, E, Complement<F>> & Function_2111<A, B, C, D, E, Complement<F>> & Function_311<A, B, C, D, E, Complement<F>> & Function_41<A, B, C, D, E, Complement<F>>);
export declare function complementCurry<A, B, C, D, E, F, G extends boolean>(f: Function6<A, B, C, D, E, F, G>): (Curried6<A, B, C, D, E, F, Complement<G>> & Function6<A, B, C, D, E, F, Complement<G>> & Function_51<A, B, C, D, E, F, Complement<G>>);
export declare function complementCurry<A, B, C, D, E, F, G, H extends boolean>(f: Function7<A, B, C, D, E, F, G, H>): (Curried7<A, B, C, D, E, F, G, Complement<H>> & Function7<A, B, C, D, E, F, G, Complement<H>> & Function_61<A, B, C, D, E, F, G, Complement<H>>);
export declare function complementCurry<A, B, C, D, E, F, G, H, I extends boolean>(f: Function8<A, B, C, D, E, F, G, H, I>): Curried8<A, B, C, D, E, F, G, H, Complement<I>>;
export declare function complementCurry<A, B, C, D, E, F, G, H, I, J extends boolean>(f: Function9<A, B, C, D, E, F, G, H, I, J>): Curried9<A, B, C, D, E, F, G, H, I, Complement<J>>;
export declare function complementWithArity(fn: Function, arity: number, ...args: any[]): (...args: any[]) => boolean | Function;
export declare const not: <A extends boolean>(value: A) => Complement<A>;
/**
 * Constant / Kestrel. Returns the first value, ignores second.
 *
 * @example
 * const constant5 = always(5)
 * constant5() === 5 // true
 * :: a -> b -> a
 */
export declare const always: <A>(a: A) => (b: any) => A;
/**
 * Identity, returns same object given
 * @example
 * const one = identity(1) // 1
 */
export declare const identity: <A>(a: A) => A;
/**
 * Flip parameters of a function.
 * Takes a function and two parameters and flips the parameter order
 *
 * @example
 * const doubleThenAdd = flip( addThenDouble )
 *
 * :: f -> a -> b -> f(b)(a)
 */
export declare function flip<A, B, Z>(fn: Curried2<A, B, Z>, b: B, a: A): Z;
export declare function flip<A, B, Z>(fn: Curried2<A, B, Z>, b: B): (a: A) => Z;
export declare function flip<A, B, Z>(fn: Curried2<A, B, Z>): PossiblyCurried<A, B, Z>;
export declare function flip<A, B, Z>(fn: Function2<A, B, Z>, b: B, a: A): Z;
export declare function flip<A, B, Z>(fn: Function2<A, B, Z>, b: B): (a: A) => Z;
export declare function flip<A, B, Z>(fn: Function2<A, B, Z>): PossiblyCurried<A, B, Z>;
/**
 * A function for use with TypeScript to validate input types.
 * Function takes a given type for A and returns an identity function
 * expecting and returning data of type A
 * @example
 * ;[1,2,3]
 *   .map(toString)
 *   // check type incoming value to be of type `string`
 *   .map(type<string>())
 *   .join('-')
 * // => '1-2-3'
 */
export declare const type: <A>() => (a: A) => A;