import { Functor, FunctorInstances } from './typeclasses/functor';
import { Cartesian } from './typeclasses/cartesian';
import { Apply } from './typeclasses/apply';
import { FlatMap } from './typeclasses/flatmap';
import { Semigroup, SemigroupInstanceType } from './typeclasses/semigroup';
import { Stream } from '../xs';
import { FantasyX } from './fantasyx';
import { State } from './state';
import { $ } from './typeclasses';
export declare class Xstream<S extends Stream, I, A> {
    streamS: State<$<S, I>, $<S, A>>;
    constructor(streamS: State<$<S, I>, $<S, A>>);
    filter(f: (a: A) => boolean): Xstream<S, I, A>;
    static fromIntent<F extends Stream, I>(): Xstream<F, I, I>;
    static fromEvent<F extends Stream>(type: string, name: string, defaultValue?: string): Xstream<F, Event, string>;
    static fromPromise<F extends Stream, I, A>(p: Promise<A>): Xstream<F, I, A>;
    static from<F extends Stream, I, A, G extends FunctorInstances>(p: $<G, A>): Xstream<F, I, A>;
    toFantasyX<St>(): FantasyX<S, I, St, A>;
}
declare module './typeclasses' {
    interface _<A> {
        "Xstream": Xstream<any, any, A>;
    }
}
declare module './typeclasses/functor' {
    namespace Functor {
        let Xstream: XstreamFunctor;
    }
}
export declare class XstreamFunctor implements Functor<"Xstream"> {
    map<A, B>(f: (a: A) => B, fa: Xstream<Stream, any, A>): Xstream<Stream, any, B>;
}
export declare class XstreamCartesian implements Cartesian<"Xstream"> {
    product<A, B, C extends Stream, D>(fa: Xstream<C, D, A>, fb: Xstream<C, D, B>): Xstream<C, D, [A, B]>;
}
declare module './typeclasses/cartesian' {
    namespace Cartesian {
        let Xstream: XstreamCartesian;
    }
}
export declare class XstreamApply implements Apply<"Xstream"> {
    ap<A, B, F extends Stream>(fab: Xstream<F, any, (a: A) => B>, fa: Xstream<F, any, A>): Xstream<F, any, B>;
    map: <A, B>(f: (a: A) => B, fa: Xstream<"ArrayStream" | "MostStream" | "RxStream", any, A>) => Xstream<"ArrayStream" | "MostStream" | "RxStream", any, B>;
    product: <A, B, C extends "ArrayStream" | "MostStream" | "RxStream", D>(fa: Xstream<C, D, A>, fb: Xstream<C, D, B>) => Xstream<C, D, [A, B]>;
}
declare module './typeclasses/apply' {
    namespace Apply {
        let Xstream: XstreamApply;
    }
}
export declare class XstreamFlatMap extends XstreamApply {
    flatMap<A, B>(f: (a: A) => Xstream<Stream, any, B>, fa: Xstream<Stream, any, A>): Xstream<Stream, any, B>;
}
declare module './typeclasses/flatmap' {
    namespace FlatMap {
        let Xstream: XstreamFlatMap;
    }
}
export declare class XstreamApplicative extends XstreamApply {
    pure<I, A>(v: A): Xstream<Stream, I, A>;
}
declare module './typeclasses/applicative' {
    namespace Applicative {
        let Xstream: XstreamApplicative;
    }
}
export declare class XstreamMonad extends XstreamApplicative implements FlatMap<"Xstream"> {
    flatMap: <A, B>(f: (a: A) => Xstream<"ArrayStream" | "MostStream" | "RxStream", any, B>, fa: Xstream<"ArrayStream" | "MostStream" | "RxStream", any, A>) => Xstream<"ArrayStream" | "MostStream" | "RxStream", any, B>;
}
declare module './typeclasses/monad' {
    namespace Monad {
        let Xstream: XstreamMonad;
    }
}
export declare class XstreamSemigroup implements Semigroup<Xstream<any, any, any>> {
    _T: Xstream<any, any, any>;
    concat<A extends SemigroupInstanceType>(fa: Xstream<any, any, A>, fb: Xstream<any, any, A>): Xstream<any, any, A>;
}
declare module './typeclasses/semigroup' {
    namespace Semigroup {
        let Xstream: XstreamSemigroup;
    }
}