import * as L from "@effect-ts/core/Collections/Immutable/List";
import * as T from "@effect-ts/core/Effect";
import { _R } from "@effect-ts/core/Effect";
import * as S from "@effect-ts/core/Sync";
import type { Cache } from "../../Cache/index.js";
import * as DS from "../../DataSource/index.js";
import type { DataSourceAspect } from "../../DataSourceAspect/index.js";
import type { BlockedRequest } from "../BlockedRequest/index.js";
import * as PL from "../Parallel/index.js";
import * as SQ from "../Sequential/index.js";
declare class Both<R> {
    readonly left: BlockedRequests<R>;
    readonly right: BlockedRequests<R>;
    readonly _tag = "Both";
    readonly [_R]: (r: R) => void;
    constructor(left: BlockedRequests<R>, right: BlockedRequests<R>);
}
declare class Empty<R> {
    readonly _tag = "Empty";
    readonly [_R]: (r: R) => void;
}
declare class Single<R> {
    readonly dataSource: DS.DataSource<R, unknown>;
    readonly blockedRequest: BlockedRequest<unknown>;
    readonly _tag = "Single";
    readonly [_R]: (r: R) => void;
    constructor(dataSource: DS.DataSource<R, unknown>, blockedRequest: BlockedRequest<unknown>);
}
declare class Then<R> {
    readonly left: BlockedRequests<R>;
    readonly right: BlockedRequests<R>;
    readonly _tag = "Then";
    readonly [_R]: (r: R) => void;
    constructor(left: BlockedRequests<R>, right: BlockedRequests<R>);
}
/**
 * `BlockedRequests` captures a collection of blocked requests as a data
 * structure. By doing this the library is able to preserve information about
 * which requests must be performed sequentially and which can be performed in
 * parallel, allowing for maximum possible batching and pipelining while
 * preserving ordering guarantees.
 */
export declare type BlockedRequests<R> = Both<R> | Empty<R> | Single<R> | Then<R>;
/**
 * Combines this collection of blocked requests with the specified collection
 * of blocked requests, in parallel.
 */
export declare function both<R>(that: BlockedRequests<R>): <R1>(self: BlockedRequests<R1>) => BlockedRequests<R & R1>;
export declare function both_<R1, R>(self: BlockedRequests<R1>, that: BlockedRequests<R>): Both<R & R1>;
/**
 * Combines this collection of blocked requests with the specified collection
 * of blocked requests, in sequence.
 */
export declare function then<R>(that: BlockedRequests<R>): <R1>(self: BlockedRequests<R1>) => BlockedRequests<R & R1>;
export declare function then_<R1, R>(self: BlockedRequests<R1>, that: BlockedRequests<R>): Then<R & R1>;
/**
 * Transforms all data sources with the specified data source aspect, which
 * can change the environment type of data sources but must preserve the
 * request type of each data source.
 */
export declare function mapDataSources<R1 extends R, R>(f: DataSourceAspect<R1>): (fa: BlockedRequests<R>) => BlockedRequests<R1>;
/**
 * Transforms all data sources with the specified data source aspect, which
 * can change the environment type of data sources but must preserve the
 * request type of each data source.
 */
export declare function mapDataSources_<R1, R>(fa: BlockedRequests<R>, f: DataSourceAspect<R1>): BlockedRequests<R & R1>;
/**
 * Provides each data source with part of its required environment.
 */
export declare function provideSome<R, R0>(description: string, f: (a: R0) => R): (fa: BlockedRequests<R>) => BlockedRequests<R0>;
/**
 * Provides each data source with part of its required environment.
 */
export declare function provideSomeSafe<R, R0>(description: string, f: (a: R0) => R): (fa: BlockedRequests<R>) => S.UIO<BlockedRequests<R0>>;
/**
 * The empty collection of blocked requests.
 */
export declare const empty: BlockedRequests<unknown>;
/**
 * Constructs a collection of blocked requests from the specified blocked
 * request and data source.
 */
export declare function single<R, K>(dataSource: DS.DataSource<R, K>, blockedRequest: BlockedRequest<K>): BlockedRequests<R>;
/**
 * Merges a collection of requests that must be executed sequentially with a
 * collection of requests that can be executed in parallel. If the
 * collections are both from the same single data source then the requests
 * can be pipelined while preserving ordering guarantees.
 */
export declare function merge<R>(sequential: L.List<SQ.Sequential<R>>, parallel: PL.Parallel<R>): L.List<SQ.Sequential<R>>;
/**
 * Flattens a collection of blocked requests into a collection of pipelined
 * and batched requests that can be submitted for execution.
 */
export declare function flatten<R>(blockedRequests: BlockedRequests<R>): L.List<SQ.Sequential<R>>;
/**
 * Takes one step in evaluating a collection of blocked requests, returning a
 * collection of blocked requests that can be performed in parallel and a
 * list of blocked requests that must be performed sequentially after those
 * requests.
 */
export declare function step<R>(c: BlockedRequests<R>): readonly [PL.Parallel<R>, L.List<BlockedRequests<R>>];
/**
 * Executes all requests, submitting requests to each data source in
 * parallel.
 */
export declare function run(cache: Cache): <R>(self: BlockedRequests<R>) => T.Effect<R, never, void>;
export {};
//# sourceMappingURL=index.d.ts.map