import { _A, _E, _R } from "@effect-ts/core/Effect";
import * as Ex from "@effect-ts/core/Effect/Exit";
import * as E from "@effect-ts/core/Either";
import * as C from "@effect-ts/system/Cause";
import type { DataSourceAspect } from "../../DataSourceAspect/index.js";
import * as BRS from "../BlockedRequests/index.js";
import type { Continue } from "../Continue/index.js";
declare class Blocked<R, E, A> {
    readonly blockedRequests: BRS.BlockedRequests<R>;
    readonly cont: Continue<R, E, A>;
    readonly _tag = "Blocked";
    readonly [_R]: (r: R) => never;
    readonly [_E]: () => E;
    readonly [_A]: () => A;
    constructor(blockedRequests: BRS.BlockedRequests<R>, cont: Continue<R, E, A>);
}
declare class Done<A> {
    readonly value: A;
    readonly _tag = "Done";
    readonly [_A]: () => A;
    constructor(value: A);
}
declare class Fail<E> {
    readonly cause: C.Cause<E>;
    readonly _tag = "Fail";
    readonly [_E]: () => E;
    constructor(cause: C.Cause<E>);
}
export declare type Result<R, E, A> = Blocked<R, E, A> | Done<A> | Fail<E>;
/**
 * Folds over the successful or failed result.
 */
export declare function fold<E, A, B>(failure: (e: E) => B, success: (a: A) => B): <R>(fa: Result<R, E, A>) => Result<R, never, B>;
/**
 * Maps the specified function over the successful value of this result.
 */
export declare function map<A, B>(f: (a: A) => B): <R, E>(self: Result<R, E, A>) => Result<R, E, B>;
/**
 * Transforms all data sources with the specified data source aspect.
 */
export declare function mapDataSources<R1>(f: DataSourceAspect<R1>): <R, E, A>(self: Result<R, E, A>) => Result<R & R1, E, A>;
/**
 * Maps the specified function over the failed value of this result.
 */
export declare function mapError<E, E1>(f: (a: E) => E1): <R, A>(self: Result<R, E, A>) => Result<R, E1, A>;
/**
 * Constructs a result that is blocked on the specified requests with the
 * specified continuation.
 */
export declare function blocked<R, E, A>(blockedRequests: BRS.BlockedRequests<R>, cont: Continue<R, E, A>): Result<R, E, A>;
/**
 * Constructs a result that is done with the specified value.
 */
export declare function done<A>(value: A): Result<unknown, never, A>;
/**
 * Constructs a result that is failed with the specified `Cause`.
 */
export declare function fail<E>(cause: C.Cause<E>): Result<unknown, E, never>;
/**
 * Lifts an `Either` into a result.
 */
export declare function fromEither<E, A>(either: E.Either<E, A>): Result<unknown, E, A>;
/**
 * Lifts an `Exit` into a result.
 */
export declare function fromExit<E, A>(exit: Ex.Exit<E, A>): Result<unknown, E, A>;
/**
 * Provides this result with part of its required environment.
 */
export declare function provideSome<R, R0>(description: string, f: (r: R0) => R): <E, A>(self: Result<R, E, A>) => Result<R0, E, A>;
export {};
//# sourceMappingURL=index.d.ts.map