import { $type, HKT, TyK, TyVar } from '@fp4ts/core';
import { Eq } from '@fp4ts/cats-kernel';
import { SemigroupK } from '../../semigroup-k';
import { Functor } from '../../functor';
import { FunctorFilter } from '../../functor-filter';
import { Apply } from '../../apply';
import { Applicative } from '../../applicative';
import { ApplicativeError } from '../../applicative-error';
import { FlatMap } from '../../flat-map';
import { CoflatMap } from '../../coflat-map';
import { Monad } from '../../monad';
import { MonadError } from '../../monad-error';
import { Option } from '../option';
import { Either } from '../either';
import { Try as TryBase } from './algebra';
export type Try<A> = TryBase<A>;
export declare const Try: TryObj;
export declare const Success: <A>(a: A) => TryBase<A>;
export declare const Failure: (e: Error) => TryBase<never>;
interface TryObj {
    <A>(thunk: () => A): Try<A>;
    of<A>(thunk: () => A): Try<A>;
    success<A>(a: A): Try<A>;
    failure(e: Error): Try<never>;
    fromOption<A>(o: Option<A>): Try<A>;
    fromEither<A>(ea: Either<Error, A>): Try<A>;
    Eq<A>(EE: Eq<Error>, EA: Eq<A>): Eq<Try<A>>;
    readonly SemigroupK: SemigroupK<TryF>;
    readonly Functor: Functor<TryF>;
    readonly FunctorFilter: FunctorFilter<TryF>;
    readonly Apply: Apply<TryF>;
    readonly Applicative: Applicative<TryF>;
    readonly ApplicativeError: ApplicativeError<TryF, Error>;
    readonly FlatMap: FlatMap<TryF>;
    readonly CoflatMap: CoflatMap<TryF>;
    readonly Monad: Monad<TryF>;
    readonly MonadError: MonadError<TryF, Error>;
}
declare module './algebra' {
    interface Try<A> extends HKT<TryF, [A]> {
    }
}
/**
 * @category Type Constructor
 * @category Data
 */
export interface TryF extends TyK<[unknown]> {
    [$type]: Try<TyVar<this, 0>>;
}
export {};
//# sourceMappingURL=try.d.ts.map