export declare function compose<A, B, C>(f: (a: A) => B, g: (b: B) => C): (x: A) => C;
export declare function invoke<R>(f: (...args: any[]) => R, args: ArrayLike<unknown>): R;
/**
 * Pipe operator for functional composition.
 * Manually unrolled for performance optimization up to 12 arguments.
 * Falls back to loop for more than 12 arguments.
 */
export declare const op: Op;
export interface Op {
    <A>(a: A): A;
    <A, B>(a: A, ab: (_: A) => B): B;
    <A, B, C>(a: A, ab: (_: A) => B, bc: (_: B) => C): C;
    <A, B, C, D>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
    <A, B, C, D, E>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
    <A, B, C, D, E, F>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
    <A, B, C, D, E, F, G>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
    <A, B, C, D, E, F, G, H>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
    <A, B, C, D, E, F, G, H, I>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
    <A, B, C, D, E, F, G, H, I, J>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
    <A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
    <A, B, C, D, E, F, G, H, I, J, K, L>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
    <A, B, C, D, E, F, G, H, I, J, K, L, M>(a: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
}
export interface Curried2<A, B, C> {
    (): Curried2<A, B, C>;
    (a: A, b: B): C;
    (a: A): (b: B) => C;
}
export declare function curry2<A, B, C>(f: (a: A, b: B) => C): Curried2<A, B, C>;
export interface Curried3<A, B, C, D> {
    (): Curried3<A, B, C, D>;
    (a: A): Curried2<B, C, D>;
    (a: A, b: B): (c: C) => D;
    (a: A, b: B, c: C): D;
}
export declare function curry3<A, B, C, D>(f: (a: A, b: B, c: C) => D): Curried3<A, B, C, D>;
export interface Curried4<A, B, C, D, E> {
    (): Curried4<A, B, C, D, E>;
    (a: A): Curried3<B, C, D, E>;
    (a: A, b: B): Curried2<C, D, E>;
    (a: A, b: B, c: C): (d: D) => E;
    (a: A, b: B, c: C, d: D): E;
}
export declare function curry4<A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E): Curried4<A, B, C, D, E>;
/**
 * Function composition operator.
 * Composes functions from left to right for later application.
 * o(f, g, h)(x) === h(g(f(x)))
 */
export declare const o: O;
export interface O {
    (): <A>(a: A) => A;
    <A, B>(ab: (_: A) => B): (_: A) => B;
    <A, B, C>(ab: (_: A) => B, bc: (_: B) => C): (_: A) => C;
    <A, B, C, D>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): (_: A) => D;
    <A, B, C, D, E>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): (_: A) => E;
    <A, B, C, D, E, F>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): (_: A) => F;
    <A, B, C, D, E, F, G>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): (_: A) => G;
    <A, B, C, D, E, F, G, H>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): (_: A) => H;
    <A, B, C, D, E, F, G, H, I>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): (_: A) => I;
    <A, B, C, D, E, F, G, H, I, J>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): (_: A) => J;
    <A, B, C, D, E, F, G, H, I, J, K>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): (_: A) => K;
    <A, B, C, D, E, F, G, H, I, J, K, L>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): (_: A) => L;
    <A, B, C, D, E, F, G, H, I, J, K, L, M>(ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): (_: A) => M;
}