export declare class FunctionX0<R> {
    private fn;
    /**
     * @hidden
     */
    constructor(fn: () => R);
    apply(): R;
}
declare type THead<T extends any[]> = T extends [infer R, ...any[]] ? R : T extends [] ? undefined : never;
declare type TTail<T extends any[]> = ((...args: T) => void) extends ((first: any, ...rest: infer S1) => void) ? S1 : T extends [infer S2] ? [] : T extends [] ? [] : never;
declare type TLast<T extends any[]> = T extends [] ? never : T extends [infer T1] ? T1 : {
    0: TTail<T>;
    1: never;
}[T extends [infer T1, infer S] ? 0 : 1];
declare type TInit<T extends any[]> = {
    0: ((...args: T) => void) extends ((first: infer T1, ...rest: infer T2) => void) ? (((a: T1, ...rest: TInit<T2>) => void) extends ((...all: infer AP) => void) ? AP : never) : never;
    1: [];
}[T extends [] | [any] ? 1 : 0];
declare type TReverse<T extends any[]> = {
    2: [];
    3: ((a: TLast<T>, ...args: TReverse<TInit<T>>) => void) extends ((...all: infer AP) => void) ? AP : never;
}[T extends [] ? 2 : 3];
declare type Apply1ReturnType<P, R> = P extends [infer T1, infer T2, ...any[]] ? (((...args: P) => void) extends ((first: any, ...rest: infer S1) => void) ? FunctionX<T1, S1, R> : never) : FunctionX0<R>;
declare type CurryReturnType<T, P extends any[], R> = {
    0: FunctionX<T, [], R>;
    1: FunctionX<T, [], CurryReturnType<THead<P>, TTail<P>, R>>;
}[P extends [infer T1, ...any[]] ? 1 : 0];
export declare class FunctionX<T, P extends any[], R> {
    private fn;
    private constructor();
    static of<R>(fn: () => R): FunctionX0<R>;
    static of<T, P extends any[], R>(fn: (p1: T, ...p: P) => R): FunctionX<T, P, R>;
    apply(p1: T, ...rest: P): R;
    apply1(p: T): Apply1ReturnType<P, R>;
    curried(): CurryReturnType<T, P, R>;
    tupled(): ((a: T, ...args: P) => R) extends ((...allP: infer AP) => infer R1) ? FunctionX<AP, [], R> : never;
    flipped(): FunctionX<TTail<P>, TTail<TReverse<P>>, R>;
}
export {};