export * from 'fluenture';
import { FutureInstance, Cancel } from 'fluture';
/**
 * TODO: Offer these type definitions for inclusion in the fluenture package
 */
export declare type Future<A, B> = FutureInstance<A, B> | Fluenture<A, B>;
export declare type Fluent<A, B> = Fluenture<A, B> & FutureInstance<A, B>;
export declare function fluent<A, B>(future: Future<A, B>): Fluent<A, B>;
export declare function functional<A, B>(future: Future<A, B>): FutureInstance<A, B>;
export declare class Fluenture<A, B> {
    pipe<T>(fn: (self: Fluent<A, B>) => T): T extends Future<infer C, infer D> ? Fluent<C, D> : T;
    alt<C, D>(future: Future<C, D>): Fluent<C, B | D>;
    and<C, D>(future: Future<C, D>): Fluent<A | C, D>;
    ap<C>(future: Future<A, (value: B) => C>): Fluent<A, C>;
    bimap<C, D>(withLeft: (left: A) => C, withRight: (right: B) => D): Fluent<C, D>;
    both<C, D>(future: Future<C, D>): Fluent<A | C, [D, B]>;
    cache(): this;
    chain<C>(fn: (value: B) => Future<A, C>): Fluent<A, C>;
    chainRej<C>(fn: (reason: A) => Future<C, B>): Fluent<C, B>;
    coalesce<C>(withLeft: (left: A) => C, withRight: (right: B) => C): Fluent<never, C>;
    lastly<C>(future: Future<C, any>): Fluent<A | C, B>;
    map<C>(fn: (value: B) => C): Fluent<A, C>;
    mapRej<C>(fn: (reason: A) => C): Fluent<C, B>;
    race<C, D>(future: Future<C, D>): Fluent<A | C, B | D>;
    swap(): Fluent<B, A>;
    done(fn: (value: A) => any): Cancel;
    fork(withLeft: (reason: A) => any, withRight: (value: B) => any): Cancel;
    forkCatch(withError: (error: any) => any, withLeft: (reason: A) => any, withRight: (value: B) => any): Cancel;
    promise(): Promise<B>;
    value(withRight: (value: B) => any): Cancel;
}
//# sourceMappingURL=fluenture.d.ts.map