/** @module functor-helpers.ts */
import { HKT, Type, URIS } from 'fp-ts/lib/HKT';
import { Append, Concat, Concattable, Function1, Functor, Predicate, Prepend, Pushable, ValueOf } from './helper-types';
interface ConcatCurried<A extends [any, ...any[]]> {
    <B extends [any, ...any[]]>(item: B): Concat<A, B>;
    <B extends any>(item: B): B extends any[] ? Array<ValueOf<A> | ValueOf<B>> : Concat<A, [B]>;
    <B extends any[]>(item: B): Array<ValueOf<A> | ValueOf<B>>;
}
export declare function concat<A extends [any, ...any[]], B extends [any, ...any[]]>(acc: A, item: B): Concat<A, B>;
export declare function concat<A extends [any, ...any[]]>(acc: A): ConcatCurried<A>;
export declare function concat<A extends [any, ...any[]], B extends any>(acc: A, item: B): B extends any[] ? Array<ValueOf<A> | ValueOf<B>> : Concat<A, [B]>;
export declare function concat<A extends [any, ...any[]]>(acc: A): ConcatCurried<A>;
export declare function concat<A extends [any, ...any[]], B extends any[]>(acc: A, item: B): Array<ValueOf<A> | ValueOf<B>>;
export declare function concat<A extends [any, ...any[]]>(acc: A): ConcatCurried<A>;
export declare function concat<A extends any[], B extends any[]>(acc: A, item: B): Array<ValueOf<A> | ValueOf<B>>;
export declare function concat<A extends any[], B extends any[]>(acc: A): (item: B) => Array<ValueOf<A> | ValueOf<B>>;
export declare function concat<A>(acc: ConcatArray<A>, item: A): ConcatArray<A>;
export declare function concat<A>(acc: ConcatArray<A>): (item: A) => ConcatArray<A>;
export declare function concat<A>(acc: Concattable<A>, item: A): Concattable<A>;
export declare function concat<A>(acc: Concattable<A>): (item: A) => Concattable<A>;
export declare function concat<A>(arr: A[], item: A): A[];
export declare function concat<A>(arr: A[]): (item: A) => A[];
export declare function concat<A extends Array<{}>, B extends any>(arr: A): (item: B) => Array<A & B>;
/**
 * Flips the order of parameters of `concat` which calls `concat`
 * on an array or a concattable. Also typed to work well with tuples.
 * @param item
 * @param arr
 */
export declare function flipConcat<A extends [any, ...any[]], B extends [any, ...any[]]>(item: A, acc: B): Concat<B, A>;
export declare function flipConcat<A extends [any, ...any[]]>(item: A): <B extends [any, ...any[]]>(acc: B) => Concat<B, A>;
export declare function flipConcat<A extends any, B extends [any, ...any[]]>(item: A, acc: B): A extends any[] ? Array<ValueOf<A> | ValueOf<B>> : Concat<B, [A]>;
export declare function flipConcat<A extends any>(item: A): <B extends [any, ...any[]]>(acc: B) => A extends any[] ? Array<ValueOf<A> | ValueOf<B>> : Concat<B, [A]>;
export declare function flipConcat<A extends any[], B extends [any, ...any[]]>(item: A, acc: B): Array<ValueOf<A> | ValueOf<B>>;
export declare function flipConcat<A extends any[]>(item: A): <B extends [any, ...any[]]>(acc: B) => Array<ValueOf<A> | ValueOf<B>>;
export declare function flipConcat<A>(item: A, acc: ConcatArray<A>): ConcatArray<A>;
export declare function flipConcat<A>(item: A): (acc: ConcatArray<A>) => ConcatArray<A>;
export declare function flipConcat<A>(item: A, acc: Concattable<A>): Concattable<A>;
export declare function flipConcat<A>(item: A): (acc: Concattable<A>) => Concattable<A>;
export declare function flipConcat<A>(item: A, arr: A[]): A[];
export declare function flipConcat<A>(item: A): (arr: A[]) => A[];
export declare function flipConcat<A extends Array<{}>, B extends any>(item: B): (arr: A) => Array<A & B>;
declare module 'fp-ts/lib/HKT' {
    interface URI2HKT<A> {
        'Array': A[];
    }
}
export declare function push<A extends [any, ...any[]], B>(acc: A, item: B): Append<A, B>;
export declare function push<A extends [any, ...any[]]>(acc: A): <B>(item: B) => Append<A, B>;
export declare function push<A extends any[], B>(acc: A, item: B): Array<ValueOf<A> | B>;
export declare function push<A extends any[]>(acc: A): <B>(item: B) => Array<ValueOf<A> | B>;
export declare function push<A>(acc: Pushable<A>, item: A): Pushable<A>;
export declare function push<A>(acc: Pushable<A>): (item: A) => Pushable<A>;
export declare function unshift<A extends [any, ...any[]], B>(acc: A, item: B): Prepend<A, B>;
export declare function unshift<A extends [any, ...any[]]>(acc: A): <B>(item: B) => Prepend<A, B>;
export declare function unshift<A extends any[], B>(acc: A, item: B): Array<ValueOf<A> | B>;
export declare function unshift<A extends any[]>(acc: A): <B>(item: B) => Array<ValueOf<A> | B>;
interface IPrepend<B> {
    <A extends [any, ...any[]]>(acc: A): Prepend<A, B>;
    <A extends any[]>(acc: A): Array<ValueOf<A> | B>;
}
export declare function prepend<B, A extends [any, ...any[]]>(item: B, acc: A): Prepend<A, B>;
export declare function prepend<B, A extends any[]>(item: B, acc: A): Array<ValueOf<A> | B>;
export declare function prepend<B>(item: B): IPrepend<B>;
/**
 * Takes a function and a filterable and returns said filterable after transformation
 * (a -> bool) -> c a -> c a
 */
export declare function filter<A, F extends any[]>(fn: Predicate<A>, functor: F): F;
export declare function filter<A>(fn: Predicate<A>): <F extends any[]>(functor: F) => F;
/**
 * Takes a function and a functor and lifts function over values in functor
 * (a -> b) -> f a -> f b
 */
export declare function map<A, B, F extends URIS>(fn: Function1<A, B>, functor: HKT<F, A> & Functor<A>): Type<F, B>;
export declare function map<A, B, F extends URIS>(fn: Function1<A, B>): (functor: HKT<F, A> & Functor<A>) => Type<F, B>;
interface Reduce<A, V, F> {
    (initial: V): (functor: (HKT<F, A> & Functor<A>) | A[]) => V;
    (initial: V, functor: (HKT<F, A> & Functor<A>) | A[]): V;
}
export declare function reduce<A, V, F extends URIS>(fn: (acc: V, item: A) => V, initial: V, functor: (HKT<F, A> & Functor<A>) | A[]): V;
export declare function reduce<A, V, F extends URIS>(fn: (acc: V, item: A) => V, initial: V): (functor: (HKT<F, A> & Functor<A>) | A[]) => V;
export declare function reduce<A, V, F extends URIS>(fn: (acc: V, item: A) => V): Reduce<A, V, F>;
interface Fold<A, V, F> {
    (fn: (acc: V, item: A) => V): (functor: (HKT<F, A> & Functor<A>) | A[]) => V;
    (fn: (acc: V, item: A) => V, functor: (HKT<F, A> & Functor<A>) | A[]): V;
}
export declare function fold<A, V, F extends URIS>(initial: V, fn: (acc: V, item: A) => V, functor: (HKT<F, A> & Functor<A>) | A[]): V;
export declare function fold<A, V, F extends URIS>(initial: V, fn: (acc: V, item: A) => V): (functor: (HKT<F, A> & Functor<A>) | A[]) => V;
export declare function fold<A, V, F extends URIS>(initial: V): Fold<A, V, F>;
export {};