import { Option } from './option.js';
import { Either } from './either.js';
import { Mappable } from './mappable.js';
export interface TryMatch<T, R> {
    success: (result: T) => R;
    failure: (error: Error) => R;
}
export declare abstract class TryLike<T> implements Mappable<T> {
    abstract readonly toOption: Option<T>;
    abstract readonly toEither: Either<Error, T>;
    abstract map<B>(f: (x: T) => B): TryLike<B>;
    abstract readonly isFailure: boolean;
    abstract readonly isSuccess: boolean;
    abstract getOrElse(value: () => T): T;
    abstract getOrElseValue(value: T): T;
    abstract orElse(value: () => TryLike<T>): TryLike<T>;
    abstract readonly get: T;
    abstract match<R>(matcher: TryMatch<T, R>): R;
    abstract flatMap<U>(f: (value: T) => TryLike<U>): TryLike<U>;
    abstract filter(p: (value: T) => boolean): TryLike<T>;
    abstract readonly failed: TryLike<Error>;
    abstract fold<U>(fa: (e: Error) => U, fb: (result: T) => U): U;
    abstract recover(f: (e: Error) => any): TryLike<any>;
    abstract recoverWith(f: (e: Error) => TryLike<any>): TryLike<any>;
    abstract transform<U>(s: (value: T) => TryLike<U>, f: (e: Error) => TryLike<U>): TryLike<U>;
    mapPromise<B>(f: (v: T) => Promise<B>): Promise<TryLike<B>>;
    flatMapPromise<B>(f: (item: T) => Promise<TryLike<B>>): Promise<TryLike<B>>;
    foreach<U>(f: (value: T) => U): void;
    tapFailure(f: (e: Error) => void): TryLike<T>;
    toEitherWithLeft<L>(f: (e: Error) => L): Either<L, T>;
}
export declare class Success<T> extends TryLike<T> {
    private readonly result;
    readonly isSuccess = true;
    readonly isFailure = false;
    constructor(result: T);
    get toOption(): Option<T>;
    get toEither(): Either<Error, T>;
    map<B>(f: (x: T) => B): TryLike<B>;
    get get(): T;
    getOrElse(_: () => T): T;
    getOrElseValue(_: T): T;
    orElse(_: () => TryLike<T>): TryLike<T>;
    match<R>(matcher: TryMatch<T, R>): R;
    flatMap<U>(f: (value: T) => TryLike<U>): TryLike<U>;
    filter(p: (value: T) => boolean): TryLike<T>;
    get failed(): TryLike<Error>;
    fold<U>(fa: (e: Error) => U, fb: (result: T) => U): U;
    recover(_: (e: Error) => any): TryLike<any>;
    recoverWith(_: (e: Error) => TryLike<any>): TryLike<any>;
    transform<U>(s: (value: T) => TryLike<U>, _: (e: Error) => TryLike<U>): TryLike<U>;
}
export declare class Failure extends TryLike<any> {
    private readonly error;
    readonly isSuccess = false;
    readonly isFailure = true;
    constructor(error: Error);
    get toOption(): Option<any>;
    get toEither(): Either<Error, any>;
    map<B>(_: (x: any) => B): TryLike<any>;
    get get(): any;
    getOrElse<T>(value: () => T): T;
    getOrElseValue<T>(value: T): T;
    orElse<T>(value: () => TryLike<T>): TryLike<T>;
    match<R>(matcher: TryMatch<any, R>): R;
    flatMap<U>(_: (value: any) => TryLike<U>): TryLike<U>;
    filter(_: (value: any) => boolean): TryLike<any>;
    get failed(): TryLike<Error>;
    fold<U>(fa: (e: Error) => U, _: (result: any) => U): U;
    recover(f: (e: Error) => any): TryLike<any>;
    recoverWith(f: (e: Error) => TryLike<any>): TryLike<any>;
    transform<U>(s: (value: any) => TryLike<U>, f: (e: Error) => TryLike<U>): TryLike<U>;
}
export declare function Try<T>(block: () => T): TryLike<T>;
export declare namespace Try {
    function promise<T>(block: () => Promise<T>): Promise<TryLike<T>>;
}
export declare function success<T>(x: T): Success<T>;
export declare function failure(x: Error): Failure;