import type { DataSourceAspect } from '../DataSourceAspect';
import type { Described } from '../Described';
import type { BlockedRequests } from './BlockedRequests';
import type { Continue } from './Continue';
import type { Cause } from '@principia/base/IO/Cause';
import * as E from '@principia/base/Either';
export declare class Blocked<R, E, A> {
    readonly blockedRequests: BlockedRequests<R>;
    readonly cont: Continue<R, E, A>;
    readonly _R: (_: R) => void;
    readonly _E: () => E;
    readonly _A: () => A;
    readonly _tag = "Blocked";
    constructor(blockedRequests: BlockedRequests<R>, cont: Continue<R, E, A>);
}
export declare class Done<A> {
    readonly value: A;
    readonly _R: (_: unknown) => void;
    readonly _E: () => never;
    readonly _A: () => A;
    readonly _tag = "Done";
    constructor(value: A);
}
export declare class Fail<E> {
    readonly cause: Cause<E>;
    readonly _R: (_: unknown) => void;
    readonly _E: () => E;
    readonly _A: () => never;
    readonly _tag = "Fail";
    constructor(cause: Cause<E>);
}
export declare type Result<R, E, A> = Blocked<R, E, A> | Done<A> | Fail<E>;
export declare function blocked<R, E, A>(blockedRequests: BlockedRequests<R>, cont: Continue<R, E, A>): Result<R, E, A>;
export declare function failCause<E>(cause: Cause<E>): Result<unknown, E, never>;
export declare function done<A>(value: A): Done<A>;
export declare function map_<R, E, A, B>(fa: Result<R, E, A>, f: (a: A) => B): Result<R, E, B>;
export declare function map<A, B>(f: (a: A) => B): <R, E>(fa: Result<R, E, A>) => Result<R, E, B>;
export declare function mapDataSources_<R, E, A, R1>(fa: Result<R, E, A>, f: DataSourceAspect<R1>): Result<R & R1, E, A>;
export declare function mapDataSources<R1>(f: DataSourceAspect<R1>): <R, E, A>(fa: Result<R, E, A>) => Result<R & R1, E, A>;
export declare function fromEither<E, A>(either: E.Either<E, A>): Result<unknown, E, A>;
export declare function gives_<R, E, A, R0>(ra: Result<R, E, A>, f: Described<(r0: R0) => R>): Result<R0, E, A>;
export declare function gives<R0, R>(f: Described<(r0: R0) => R>): <E, A>(ra: Result<R, E, A>) => Result<R0, E, A>;
//# sourceMappingURL=Result.d.ts.map