import { Stream, Subject } from '../xs';
import { State } from './state';
import { Actions, XcomponentClass, Update } from '../interfaces';
import { $ } from './typeclasses';
import { Functor } from './typeclasses/functor';
import { Cartesian } from './typeclasses/cartesian';
import { Apply } from './typeclasses/apply';
import * as React from 'react';
export declare class FantasyX<F extends Stream, I, S, A> {
    plan: State<Subject<F, I>, $<F, State<S, A>>>;
    constructor(plan: State<Subject<F, I>, $<F, State<S, A>>>);
    apply(WrappedComponent: XcomponentClass<F, I, S> | React.ComponentClass<any> | React.SFC<any>, actions?: Actions<I>): XcomponentClass<F, I, S>;
    toStream(intent$: Subject<F, I>): $<F, Update<S>>;
    map<B>(f: (a: A) => B): FantasyX<F, I, S, B>;
    foldS<B>(f: (s: S, a: A) => S): FantasyX<F, I, S, Partial<S>>;
    combine<C, B>(f: (a: A, b: B) => C, fB: FantasyX<F, I, S, B>): FantasyX<F, I, S, C>;
    merge<C, B>(fB: FantasyX<F, I, S, B>): FantasyX<F, I, S, A | B>;
}
declare module './typeclasses' {
    interface _<A> {
        "FantasyX": FantasyX<Stream, any, any, A>;
    }
}
export declare class FantasyXFunctor implements Functor<"FantasyX"> {
    map<A, B, I, S>(f: (a: A) => B, fa: FantasyX<Stream, I, S, A>): FantasyX<Stream, I, S, B>;
}
declare module './typeclasses/functor' {
    namespace Functor {
        let FantasyX: FantasyXFunctor;
    }
}
export declare class FantasyXCartesian implements Cartesian<"FantasyX"> {
    product<A, B, I, S>(fa: FantasyX<Stream, I, S, A>, fb: FantasyX<Stream, I, S, B>): FantasyX<Stream, I, S, [A, B]>;
}
declare module './typeclasses/cartesian' {
    namespace Cartesian {
        let FantasyX: FantasyXCartesian;
    }
}
export declare class FantasyXApply implements Apply<"FantasyX"> {
    ap<A, B, I, S>(fab: FantasyX<Stream, I, S, (a: A) => B>, fa: FantasyX<Stream, I, S, A>): FantasyX<Stream, I, S, B>;
    map: <A, B, I, S>(f: (a: A) => B, fa: FantasyX<"ArrayStream" | "MostStream" | "RxStream", I, S, A>) => FantasyX<"ArrayStream" | "MostStream" | "RxStream", I, S, B>;
    product: <A, B, I, S>(fa: FantasyX<"ArrayStream" | "MostStream" | "RxStream", I, S, A>, fb: FantasyX<"ArrayStream" | "MostStream" | "RxStream", I, S, B>) => FantasyX<"ArrayStream" | "MostStream" | "RxStream", I, S, [A, B]>;
}
declare module './typeclasses/apply' {
    namespace Apply {
        let FantasyX: FantasyXApply;
    }
}
export declare class FantasyXApplicative extends FantasyXApply {
    pure<I, A>(v: A): FantasyX<Stream, I, A, A>;
}
declare module './typeclasses/applicative' {
    namespace Applicative {
        let FantasyX: FantasyXApplicative;
    }
}