import type { IO } from "@effect-ts/core/Effect";
import * as T from "@effect-ts/core/Effect";
import { _A, _E, _R } from "@effect-ts/core/Effect";
import type * as E from "@effect-ts/core/Either";
import * as O from "@effect-ts/core/Option";
import type { _A as _GetA, _E as _GetE } from "@effect-ts/core/Utils";
import type * as C from "@effect-ts/system/Cause";
import * as REF from "@effect-ts/system/Ref";
import type { Cache } from "../../Cache/index.js";
import type { DataSource } from "../../DataSource/index.js";
import type { DataSourceAspect } from "../../DataSourceAspect/index.js";
import * as Q from "../../Query/index.js";
import type { Request } from "../../Request/index.js";
declare class Effect<R, E, A> {
    readonly query: Q.Query<R, E, A>;
    readonly _tag = "Effect";
    readonly [_R]: (r: R) => never;
    readonly [_E]: () => E;
    readonly [_A]: () => A;
    constructor(query: Q.Query<R, E, A>);
}
declare class Get<E, A> {
    readonly io: IO<E, A>;
    readonly _tag = "Get";
    readonly [_E]: () => E;
    readonly [_A]: () => A;
    constructor(io: IO<E, A>);
}
/**
 * A `Continue[R, E, A]` models a continuation of a blocked request that
 * requires an environment `R` and may either fail with an `E` or succeed with
 * an `A`. A continuation may either be a `Get` that merely gets the result of
 * a blocked request (potentially transforming it with pure functions) or an
 * `Effect` that may perform arbitrary effects. This is used by the library
 * internally to determine whether it is safe to pipeline two requests that
 * must be executed sequentially.
 */
export declare type Continue<R, E, A> = Effect<R, E, A> | Get<E, A>;
/**
 * Constructs a continuation from a request, a data source, and a `Ref` that
 * will contain the result of the request when it is executed.
 */
export declare function apply<R, A extends Request<any, any>>(request: A, dataSource: DataSource<R, A>, ref: REF.Ref<O.Option<E.Either<_GetE<A>, _GetA<A>>>>): Continue<R, _GetE<A>, _GetA<A>>;
/**
 * Constructs a continuation that may perform arbitrary effects.
 */
export declare function effect<R, E, A>(query: Q.Query<R, E, A>): Continue<R, E, A>;
/**
 * Constructs a continuation that merely gets the result of a blocked request
 * (potentially transforming it with pure functions).
 */
export declare function get<E, A>(io: IO<E, A>): Continue<unknown, E, A>;
/**
 * Purely folds over the failure and success types of this continuation.
 */
export declare function fold<E, A, B>(failure: (e: E) => B, success: (a: A) => B): <R>(cont: Continue<R, E, A>) => Continue<R, never, B>;
/**
 * Effectually folds over the failure and success types of this continuation.
 */
export declare function foldCauseM<E, A, R2, E2, A2, R3, E3, A3>(failure: (cause: C.Cause<E>) => Q.Query<R2, E2, A2>, success: (a: A) => Q.Query<R3, E3, A3>): <R>(self: Continue<R, E, A>) => Continue<R & R2 & R3, E2 | E3, A2 | A3>;
export declare function foldCauseM_<R, E, A, R2, E2, A2, R3, E3, A3>(self: Continue<R, E, A>, failure: (cause: C.Cause<E>) => Q.Query<R2, E2, A2>, success: (a: A) => Q.Query<R3, E3, A3>): Continue<R & R2 & R3, E2 | E3, A2 | A3>;
/**
 * Purely maps over the success type of this continuation.
 */
export declare function map<A, B>(f: (a: A) => B): <R, E>(self: Continue<R, E, A>) => Continue<R, E, B>;
export declare function map_<R, E, A, B>(self: Continue<R, E, A>, f: (a: A) => B): Continue<R, E, B>;
/**
 * Transforms all data sources with the specified data source aspect.
 */
export declare function mapDataSources_<R1, R, E, A>(self: Continue<R, E, A>, f: DataSourceAspect<R1>): Continue<R & R1, E, A>;
/**
 * Transforms all data sources with the specified data source aspect.
 */
export declare function mapDataSources<R1 extends R, R>(f: DataSourceAspect<R1>): <E, A>(self: Continue<R, E, A>) => Continue<R1, E, A>;
/**
 * Purely maps over the failure type of this continuation.
 */
export declare function mapError<E, E1>(f: (e: E) => E1): <R, A>(self: Continue<R, E, A>) => Continue<R, E1, A>;
/**
 * Effectually maps over the success type of this continuation.
 */
export declare function mapM<A, R1, E1, B>(f: (a: A) => Q.Query<R1, E1, B>): <R, E>(self: Continue<R, E, A>) => Continue<R1 & R, E1 | E, B>;
/**
 * Purely contramaps over the environment type of this continuation.
 */
export declare function provideSome<R0, R>(description: string, f: (a: R0) => R): <E, A>(self: Continue<R, E, A>) => Continue<R0, E, A>;
/**
 * Combines this continuation with that continuation using the specified
 * function, in sequence.
 */
export declare function zipWith<R1, E1, B, A, C>(that: Continue<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Continue<R, E, A>) => Continue<R & R1, E1 | E, C>;
/**
 * Combines this continuation with that continuation using the specified
 * function, in parallel.
 */
export declare function zipWithPar<R1, E1, B, A, C>(that: Continue<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Continue<R, E, A>) => Continue<R & R1, E1 | E, C>;
/**
 * Runs this continuation..
 */
export declare function runCache(cache: Cache): <R, E, A>(self: Continue<R, E, A>) => T.Effect<R, E, A>;
export {};
//# sourceMappingURL=index.d.ts.map