import { $ } from '.';
import { Functor } from './functor';
import { Apply } from './apply';
import { Cartesian } from './cartesian';
import { Applicative } from './applicative';
import { FlatMap } from './flatmap';
import { Monad } from './monad';
export declare class Id<A> {
    value: A;
    constructor(value: A);
    valueOf(): A;
}
export declare class IdFunctor implements Functor<"Id"> {
    map<A, B>(f: (a: A) => B, fb: $<"Id", A>): $<"Id", B>;
}
declare module '.' {
    interface _<A> {
        "Id": Id<A>;
    }
}
declare module './functor' {
    namespace Functor {
        let Id: IdFunctor;
    }
}
export declare class IdCartesian implements Cartesian<"Id"> {
    product<A, B>(fa: Id<A>, fb: Id<B>): Id<[A, B]>;
}
declare module './cartesian' {
    namespace Cartesian {
        let Id: IdCartesian;
    }
}
export declare class IdApply implements Apply<"Id"> {
    ap<A, B>(fab: Id<(a: A) => B>, fa: Id<A>): Id<B>;
    map: <A, B>(f: (a: A) => B, fb: Id<A>) => Id<B>;
    product: <A, B>(fa: Id<A>, fb: Id<B>) => Id<[A, B]>;
}
declare module './apply' {
    namespace Apply {
        let Id: IdApply;
    }
}
export declare class IdApplicative extends IdApply implements Applicative<"Id"> {
    pure<A>(a: A): Id<A>;
}
declare module './applicative' {
    namespace Applicative {
        let Id: IdApplicative;
    }
}
export declare class IdFlatMap extends IdApply implements FlatMap<"Id"> {
    flatMap<A, B>(f: (a: A) => Id<B>, fa: Id<A>): Id<B>;
}
declare module './flatmap' {
    namespace FlatMap {
        let Id: IdFlatMap;
    }
}
export declare class IdMonad extends IdApplicative implements Monad<"Id"> {
    flatMap: <A, B>(f: (a: A) => Id<B>, fa: Id<A>) => Id<B>;
}
declare module './monad' {
    namespace Monad {
        let Id: IdMonad;
    }
}