import { pair, Partial } from './interfaces';
import { Functor } from './typeclasses/functor';
import { Cartesian } from './typeclasses/cartesian';
import { Apply } from './typeclasses/apply';
import { FlatMap } from './typeclasses/flatmap';
import { Applicative } from './typeclasses/applicative';
import { Monad } from './typeclasses/monad';
export declare const kind = "State";
export declare type kind = typeof kind;
declare module './typeclasses' {
    interface _<A> {
        'State': State<any, A>;
    }
}
export declare class State<S, A> {
    runState: (s: S) => pair<S, A>;
    constructor(runState: (s: S) => pair<S, A>);
    runA(state: S): A;
    runS(state: S): S;
    static pure<S, A>(a: A): State<S, A>;
    static get<S>(): State<S, S>;
    static put<S>(s: S): State<S, void>;
    static modify<S>(f: (s: S) => Partial<S>): State<S, void>;
    patch(f: (a: A, s: S) => Partial<S>): State<S, Partial<S>>;
}
export declare class StateFunctor implements Functor<kind> {
    map<A, B, C>(f: (a: A) => B, fa: State<C, A>): State<C, B>;
}
declare module './typeclasses/functor' {
    namespace Functor {
        let State: StateFunctor;
    }
}
export declare class StateCartesian implements Cartesian<kind> {
    product<A, B, S>(fa: State<S, A>, fb: State<S, B>): State<S, [A, B]>;
}
declare module './typeclasses/cartesian' {
    namespace Cartesian {
        let State: StateCartesian;
    }
}
export declare class StateApply implements Apply<kind> {
    ap<A, B, S>(fab: State<S, (a: A) => B>, fa: State<S, A>): State<S, B>;
    map: <A, B, C>(f: (a: A) => B, fa: State<C, A>) => State<C, B>;
    product: <A, B, S>(fa: State<S, A>, fb: State<S, B>) => State<S, [A, B]>;
}
declare module './typeclasses/apply' {
    namespace Apply {
        let State: StateApply;
    }
}
export declare class StateApplicative extends StateApply implements Applicative<kind> {
    pure: typeof State.pure;
}
declare module './typeclasses/applicative' {
    namespace Applicative {
        let State: StateApplicative;
    }
}
export declare class StateFlatMap extends StateApplicative implements FlatMap<kind> {
    flatMap<A, B, S>(f: (a: A) => State<S, B>, fa: State<S, A>): State<S, B>;
}
declare module './typeclasses/flatmap' {
    namespace FlatMap {
        let State: StateFlatMap;
    }
}
export declare class StateMonad extends StateApplicative implements Monad<kind> {
    flatMap: <A, B, S>(f: (a: A) => State<S, B>, fa: State<S, A>) => State<S, B>;
}
declare module './typeclasses/monad' {
    namespace Monad {
        let State: StateMonad;
    }
}