/**
 * @since 1.0.0
 */
import type * as Chunk from "@effect/data/Chunk";
import type * as Context from "@effect/data/Context";
import type * as Debug from "@effect/data/Debug";
import type * as Duration from "@effect/data/Duration";
import type * as Either from "@effect/data/Either";
import type { LazyArg } from "@effect/data/Function";
import type * as Option from "@effect/data/Option";
import type * as Cause from "@effect/io/Cause";
import type * as Effect from "@effect/io/Effect";
import type * as Layer from "@effect/io/Layer";
import type * as Cache from "@effect/query/Cache";
import type * as DataSource from "@effect/query/DataSource";
import type * as Described from "@effect/query/Described";
import type * as Request from "@effect/query/Request";
/**
 * @since 1.0.0
 * @category symbols
 */
export declare const QueryTypeId: unique symbol;
/**
 * @since 1.0.0
 * @category symbols
 */
export type QueryTypeId = typeof QueryTypeId;
/**
 * A `Query<R, E, A>` is a purely functional description of an effectual query
 * that may contain requests from one or more data sources, requires an
 * environment `R`, and may fail with an `E` or succeed with an `A`.
 *
 * Requests that can be performed in parallel, as expressed by `zipWithPar` and
 * combinators derived from it, will automatically be batched. Requests that
 * must be performed sequentially, as expressed by `zipWith` and combinators
 * derived from it, will automatically be pipelined. This allows for aggressive
 * data source specific optimizations. Requests can also be deduplicated and
 * cached.
 *
 * This allows for writing queries in a high level, compositional style, with
 * confidence that they will automatically be optimized. For example, consider
 * the following query from a user service.
 *
 * ```ts
 * import * as Chunk from "@effect/data/Chunk"
 * import * as Query from "@effect/query/Query"
 *
 * declare const getAllUserIds: Query.Query<never, never, Chunk.Chunk<number>>
 * declare const getUserNameById: (id: number) => Query.Query<never, never, string>
 *
 * const userNames = pipe(
 *   getAllUserIds,
 *   Query.flatMap(Query.forEachPar(getUserNameById))
 * )
 * ```
 *
 * This would normally require `N + 1` queries, one for `getAllUserIds` and one
 * for each call to `getUserNameById`. In contrast, `Query` will automatically
 * optimize this to two queries, one for `userIds` and one for `userNames`,
 * assuming an implementation of the user service that supports batching.
 *
 * Based on "There is no Fork: an Abstraction for Efficient, Concurrent, and
 * Concise Data Access" by Simon Marlow, Louis Brandy, Jonathan Coens, and Jon
 * Purdy. {@link http://simonmar.github.io/bib/papers/haxl-icfp14.pdf}
 *
 * @since 1.0.0
 * @category models
 */
export interface Query<R, E, A> extends Query.Variance<R, E, A>, Effect.Effect<R, E, A> {
    traced(trace: Debug.Trace): Query<R, E, A>;
}
/**
 * @since 1.0.0
 */
export declare namespace Query {
    /**
     * @since 1.0.0
     * @category models
     */
    interface Variance<R, E, A> {
        readonly [QueryTypeId]: {
            readonly _R: (_: never) => R;
            readonly _E: (_: never) => E;
            readonly _A: (_: never) => A;
        };
    }
}
/**
 * Returns a query which submerges the error case of `Either` into the error
 * channel of the query
 *
 * The inverse of `Query.either`.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const absolve: <R, E, A>(self: Query<R, E, Either.Either<E, A>>) => Query<R, E, A>;
/**
 * Executes the requests for a query between two effects, `before` and `after`,
 * where the result of `before` can be used by `after`.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const around: {
    <R2, A2, R3, _>(before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R3 | R, E, A>;
    <R, E, A, R2, A2, R3, _>(self: Query<R, E, A>, before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): Query<R | R2 | R3, E, A>;
};
/**
 * Maps the success value of this query to the specified constant value.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const as: {
    <A2>(value: A2): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A2>;
    <R, E, A, A2>(self: Query<R, E, A>, value: A2): Query<R, E, A2>;
};
/**
 * Lifts the error channel into a `Some` value for composition with other
 * optional queries.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const asSomeError: <R, E, A>(self: Query<R, E, A>) => Query<R, Option.Option<E>, A>;
/**
 * Maps the success value of this query to unit.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const asUnit: <R, E, A>(self: Query<R, E, A>) => Query<R, E, void>;
/**
 * Enables caching for this query. Note that caching is enabled by default so
 * this will only be effective to enable caching in part of a larger query in
 * which caching has been disabled.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const cached: <R, E, A>(self: Query<R, E, A>) => Query<R, E, A>;
/**
 * Recovers from all expected errors.
 *
 * @since 1.0.0
 * @category error handling
 */
export declare const catchAll: {
    <E, R2, E2, A2>(f: (error: E) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>;
    <R, A, E, R2, E2, A2>(self: Query<R, E, A>, f: (error: E) => Query<R2, E2, A2>): Query<R | R2, E2, A | A2>;
};
/**
 * Recovers from all errors, both expected and unexpected, with provided
 * `Cause`.
 *
 * @since 1.0.0
 * @category error handling
 */
export declare const catchAllCause: {
    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (cause: Cause.Cause<E>) => Query<R2, E2, A2>): Query<R | R2, E2, A | A2>;
};
/**
 * Collects a collection of queries into a query returning a collection of
 * their results. Requests will be executed sequentially and will be
 * pipelined.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const collectAll: <R, E, A>(queries: Iterable<Query<R, E, A>>) => Query<R, E, Chunk.Chunk<A>>;
/**
 * Collects a collection of queries into a query returning a collection of
 * their results, batching requests to data sources.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const collectAllBatched: <R, E, A>(queries: Iterable<Query<R, E, A>>) => Query<R, E, Chunk.Chunk<A>>;
/**
 * Collects a collection of queries into a query returning a collection of
 * their results. Requests will be executed in parallel and will be batched.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const collectAllPar: <R, E, A>(queries: Iterable<Query<R, E, A>>) => Query<R, E, Chunk.Chunk<A>>;
/**
 * Accesses the whole context of the query.
 *
 * @since 1.0.0
 * @category context
 */
export declare const context: <R>(_: void) => Query<R, never, Context.Context<R>>;
/**
 * Accesses the context of the effect.
 *
 * @since 1.0.0
 * @category context
 */
export declare const contextWith: <R, A>(f: (context: Context.Context<R>) => A) => Query<R, never, A>;
/**
 * Effectfully accesses the context of the effect.
 *
 * @since 1.0.0
 * @category context
 */
export declare const contextWithEffect: <R, R2, E, A>(f: (context: Context.Context<R>) => Effect.Effect<R2, E, A>) => Query<R | R2, E, A>;
/**
 * Effectfully accesses the context of the effect.
 *
 * @since 1.0.0
 * @category context
 */
export declare const contextWithQuery: <R, R2, E, A>(f: (context: Context.Context<R>) => Query<R2, E, A>) => Query<R | R2, E, A>;
/**
 * Provides this query with part of its required context.
 *
 * @since 1.0.0
 * @category context
 */
export declare const contramapContext: {
    <R0, R>(f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E, A>;
    <R, E, A, R0>(self: Query<R, E, A>, f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): Query<R0, E, A>;
};
/**
 * Constructs a query that dies with the specified defect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const die: (defect: unknown) => Query<never, never, never>;
/**
 * Constructs a query that dies with the specified lazily evaluated defect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const dieSync: (evaluate: LazyArg<unknown>) => Query<never, never, never>;
/**
 * Returns a query whose failure and success have been lifted into an
 * `Either`. The resulting query cannot fail, because the failure case has
 * been exposed as part of the `Either` success case.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const either: <R, E, A>(self: Query<R, E, A>) => Query<R, never, Either.Either<E, A>>;
/**
 * Ensures that if this query starts executing, the specified query will be
 * executed immediately after this query completes execution, whether by
 * success or failure.
 *
 * @since 1.0.0
 * @category finalization
 */
export declare const ensuring: {
    <R2, E2, A2>(finalizer: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, finalizer: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
};
/**
 * Constructs a query that fails with the specified error.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fail: <E>(error: E) => Query<never, E, never>;
/**
 * Constructs a query that fails with the specified lazily evaluated error.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const failSync: <E>(evaluate: LazyArg<E>) => Query<never, E, never>;
/**
 * Constructs a query that fails with the specified cause.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const failCause: <E>(cause: Cause.Cause<E>) => Query<never, E, never>;
/**
 * Constructs a query that fails with the specified cause.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Query<never, E, never>;
/**
 * Returns a query that models execution of this query, followed by passing
 * its result to the specified function that returns a query. Requests
 * composed with `flatMap` or combinators derived from it will be executed
 * sequentially and will not be pipelined, though deduplication and caching of
 * requests may still be applied.
 *
 * @since 1.0.0
 * @category sequencing
 */
export declare const flatMap: {
    <A, R2, E2, A2>(f: (a: A) => Query<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (a: A) => Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
};
/**
 * Returns a query that performs the outer query first, followed by the inner
 * query, yielding the value of the inner query.
 *
 * This method can be used to "flatten" nested queries.
 *
 * @since 1.0.0
 * @category sequencing
 */
export declare const flatten: <R, E, R2, E2, A>(self: Query<R, E, Query<R2, E2, A>>) => Query<R | R2, E | E2, A>;
/**
 * Performs a query for each element in a collection, collecting the results
 * into a query returning a collection of their results. Requests will be
 * executed sequentially and will be pipelined.
 *
 * @since 1.0.0
 * @category traversing
 */
export declare const forEach: {
    <A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
    <A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>;
};
/**
 * Performs a query for each element in a collection, batching requests to
 * data sources and collecting the results into a query returning a collection
 * of their results.
 *
 * @since 1.0.0
 * @category traversing
 */
export declare const forEachBatched: {
    <A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
    <A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>;
};
/**
 * Performs a query for each element in a collection, collecting the results
 * into a query returning a collection of their results. Requests will be
 * executed in parallel and will be batched.
 *
 * @since 1.0.0
 * @category traversing
 */
export declare const forEachPar: {
    <A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
    <A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>;
};
/**
 * Constructs a query from an effect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Query<R, E, A>;
/**
 * Constructs a query from an `Either`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromEither: <E, A>(either: Either.Either<E, A>) => Query<never, E, A>;
/**
 * Constructs a query from an `Option`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromOption: <A>(option: Option.Option<A>) => Query<never, Option.Option<never>, A>;
/**
 * Constructs a query from a request and a data source. Queries will die with
 * a `QueryFailure` when run if the data source does not provide results for
 * all requests received. Queries must be constructed with `fromRequest` or
 * one of its variants for optimizations to be applied.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromRequest: <R, A extends Request.Request<any, any>, A2 extends A>(request: A, dataSource: DataSource.DataSource<R, A2>) => Query<R, Request.Request.Error<A>, Request.Request.Success<A>>;
/**
 * Constructs a query from a request and a data source but does not apply
 * caching to the query.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromRequestUncached: <R, A extends Request.Request<any, any>, A2 extends A>(request: A, dataSource: DataSource.DataSource<R, A2>) => Query<R, Request.Request.Error<A>, Request.Request.Success<A>>;
/**
 * This function returns `true` if the specified value is an `Query` value,
 * `false` otherwise.
 *
 * This function can be useful for checking the type of a value before
 * attempting to operate on it as an `Query` value. For example, you could
 * use `isQuery` to check the type of a value before using it as an
 * argument to a function that expects an `Query` value.
 *
 * @param u - The value to check for being an `Query` value.
 *
 * @returns `true` if the specified value is an `Query` value, `false`
 * otherwise.
 *
 * @since 1.0.0
 * @category refinements
 */
export declare const isQuery: (u: unknown) => u is Query<any, any, any>;
/**
 * "Zooms in" on the value in the `Left` side of an `Either`, moving the
 * possibility that the value is a `Right` to the error channel.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const left: <R, E, A, A2>(self: Query<R, E, Either.Either<A, A2>>) => Query<R, Either.Either<E, A2>, A>;
/**
 * Maps the specified function over the successful result of this query.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const map: {
    <A, B>(f: (a: A) => B): <R, E>(self: Query<R, E, A>) => Query<R, E, B>;
    <R, E, A, B>(self: Query<R, E, A>, f: (a: A) => B): Query<R, E, B>;
};
/**
 * Returns a query whose failure and success channels have been mapped by the
 * specified pair of functions, `f` and `g`.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapBoth: {
    <E, E2, A, A2>(f: (e: E) => E2, g: (a: A) => A2): <R>(self: Query<R, E, A>) => Query<R, E2, A2>;
    <R, E, E2, A, A2>(self: Query<R, E, A>, f: (e: E) => E2, g: (a: A) => A2): Query<R, E2, A2>;
};
/**
 * Transforms all data sources with the specified data source aspect.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapDataSources: {
    <R, A, R2>(f: (dataSource: DataSource.DataSource<R, A>) => DataSource.DataSource<R2, A>): <E>(self: Query<R, E, A>) => Query<R | R2, E, A>;
    <R, E, A, R2>(self: Query<R, E, A>, f: (dataSource: DataSource.DataSource<R, A>) => DataSource.DataSource<R2, A>): Query<R | R2, E, A>;
};
/**
 * Maps the specified function over the failed result of this query.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapError: {
    <E, E2>(f: (e: E) => E2): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
    <R, A, E, E2>(self: Query<R, E, A>, f: (e: E) => E2): Query<R, E2, A>;
};
/**
 * Returns a query with its full cause of failure mapped using the specified
 * function. This can be used to transform errors while preserving the
 * original structure of `Cause`.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapErrorCause: {
    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
    <R, E, A, E2>(self: Query<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Query<R, E2, A>;
};
/**
 * Maps the specified effectual function over the result of this query.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapEffect: {
    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, A2>): Query<R | R2, E | E2, A2>;
};
/**
 * Folds over the failed or successful result of this query to yield a query
 * that does not fail, but succeeds with the value returned by the left or
 * right function passed to `match`.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const match: {
    <E, Z, A>(onFailure: (error: E) => Z, onSuccess: (value: A) => Z): <R>(self: Query<R, E, A>) => Query<R, never, Z>;
    <R, E, A, Z>(self: Query<R, E, A>, onFailure: (error: E) => Z, onSuccess: (value: A) => Z): Query<R, never, Z>;
};
/**
 * A more powerful version of `foldQuery` that allows recovering from any type
 * of failure except interruptions.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const matchCauseQuery: {
    <E, R2, E2, A2, A, R3, E3, A3>(onFailure: (cause: Cause.Cause<E>) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>;
    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Query<R, E, A>, onFailure: (cause: Cause.Cause<E>) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): Query<R | R2 | R3, E2 | E3, A2 | A3>;
};
/**
 * Recovers from errors by accepting one query to execute for the case of an
 * error, and one query to execute for the case of success.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const matchQuery: {
    <E, R2, E2, A2, A, R3, E3, A3>(onFailure: (error: E) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>;
    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Query<R, E, A>, onFailure: (error: E) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): Query<R | R2 | R3, E2 | E3, A2 | A3>;
};
/**
 * Limits the query data sources to execute at most `n` requests in parallel.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const maxBatchSize: {
    (n: number): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A>;
    <R, E, A>(self: Query<R, E, A>, n: number): Query<R, E, A>;
};
/**
 * Constructs a query that never completes.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const never: (_: void) => Query<never, never, never>;
/**
 * Converts this query to one that returns `Some` if data sources return
 * results for all requests received and `None` otherwise.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const optional: <R, E, A>(self: Query<R, E, A>) => Query<R, E, Option.Option<A>>;
/**
 * Converts this query to one that dies if a query failure occurs.
 *
 * @since 1.0.0
 * @category error handling
 */
export declare const orDie: <R, E, A>(self: Query<R, E, A>) => Query<R, never, A>;
/**
 * Converts this query to one that dies if a query failure occurs, using the
 * specified function to map the error to a defect.
 *
 * @since 1.0.0
 * @category error handling
 */
export declare const orDieWith: {
    <E>(f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, never, A>;
    <R, E, A>(self: Query<R, E, A>, f: (error: E) => unknown): Query<R, never, A>;
};
/**
 * Performs a query for each element in a collection, collecting the results
 * into a collection of failed results and a collection of successful results.
 * Requests will be executed sequentially and will be pipelined.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const partitionQuery: {
    <A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
    <A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
};
/**
 * Performs a query for each element in a collection, collecting the results
 * into a collection of failed results and a collection of successful results.
 * Requests will be executed in parallel and will be batched.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const partitionQueryPar: {
    <A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
    <A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
};
/**
 * Provides this query with its required context.
 *
 * @since 1.0.0
 * @category context
 */
export declare const provideContext: {
    <R>(context: Described.Described<Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<never, E, A>;
    <R, E, A>(self: Query<R, E, A>, context: Described.Described<Context.Context<R>>): Query<never, E, A>;
};
/**
 * Provides a layer to this query, which translates it to another level.
 *
 * @since 1.0.0
 * @category context
 */
export declare const provideLayer: {
    <R0, E2, R>(layer: Described.Described<Layer.Layer<R0, E2, R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E2 | E, A>;
    <R, E, A, R0, E2>(self: Query<R, E, A>, layer: Described.Described<Layer.Layer<R0, E2, R>>): Query<R0, E | E2, A>;
};
/**
 * Splits the environment into two parts, providing one part using the
 * specified layer and leaving the remainder `R0`.
 *
 * @since 1.0.0
 * @category context
 */
export declare const provideSomeLayer: {
    <R2, E2, A2>(layer: Described.Described<Layer.Layer<R2, E2, A2>>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | Exclude<R, A2>, E2 | E, A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, layer: Described.Described<Layer.Layer<R2, E2, A2>>): Query<R2 | Exclude<R, A2>, E | E2, A>;
};
/**
 * Races this query with the specified query, returning the result of the
 * first to complete successfully and safely interrupting the other.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const race: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2 | A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A | A2>;
};
/**
 * Keeps some of the errors, and terminates the query with the rest.
 *
 * @since 1.0.0
 * @category error handling
 */
export declare const refineOrDie: {
    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
    <R, E, A, E2>(self: Query<R, E, A>, pf: (error: E) => Option.Option<E2>): Query<R, E2, A>;
};
/**
 * Keeps some of the errors, and terminates the query with the rest, using the
 * specified function to convert the `E` into a defect.
 *
 * @since 1.0.0
 * @category error handling
 */
export declare const refineOrDieWith: {
    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
    <R, E, A, E2>(self: Query<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Query<R, E2, A>;
};
/**
 * "Zooms in" on the value in the `Right` side of an `Either`, moving the
 * possibility that the value is a `Left` to the error channel.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const right: <R, E, A, A2>(self: Query<R, E, Either.Either<A, A2>>) => Query<R, Either.Either<A, E>, A2>;
/**
 * Returns an effect that models executing this query.
 *
 * @since 1.0.0
 * @category destructors
 */
export declare const run: <R, E, A>(self: Query<R, E, A>) => Effect.Effect<R, E, A>;
/**
 * Returns an effect that models executing this query with the specified
 * cache.
 *
 * @since 1.0.0
 * @category destructors
 */
export declare const runCache: {
    (cache: Cache.Cache): <R, E, A>(self: Query<R, E, A>) => Effect.Effect<R, E, A>;
    <R, E, A>(self: Query<R, E, A>, cache: Cache.Cache): Effect.Effect<R, E, A>;
};
/**
 * Returns an effect that models executing this query, returning the query
 * result along with the cache.
 *
 * @since 1.0.0
 * @category destructors
 */
export declare const runLog: <R, E, A>(self: Query<R, E, A>) => Effect.Effect<R, E, readonly [Cache.Cache, A]>;
/**
 * Expose the full cause of failure of this query.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const sandbox: <R, E, A>(self: Query<R, E, A>) => Query<R, Cause.Cause<E>, A>;
/**
 * Companion helper to `sandbox`. Allows recovery, and partial recovery, from
 * errors and defects alike, as in:
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const sandboxWith: {
    <R, E, A, R2, E2, A2>(f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>): (self: Query<R, E, A>) => Query<R | R2, E2, A | A2>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>): Query<R | R2, E2, A | A2>;
};
/**
 * Extracts a `Some` value into the value channel while moving the `None` into
 * the error channel for easier composition
 *
 * Inverse of `Query.unoption`.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const some: <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R, Option.Option<E>, A>;
/**
 * Extracts the optional value or succeeds with the given 'default' value.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const someOrElse: {
    <A, B>(def: LazyArg<B>): <R, E>(self: Query<R, E, Option.Option<A>>) => Query<R, E, A | B>;
    <R, E, A, B>(self: Query<R, E, Option.Option<A>>, def: LazyArg<B>): Query<R, E, A | B>;
};
/**
 * Extracts the optional value or executes the given 'default' query.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const someOrElseEffect: {
    <R2, E2, A2>(def: LazyArg<Query<R2, E2, A2>>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R2 | R, E2 | E, A2 | A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, Option.Option<A>>, def: LazyArg<Query<R2, E2, A2>>): Query<R | R2, E | E2, A | A2>;
};
/**
 * Extracts the optional value or fails with the given error `e`.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const someOrFail: {
    <E2>(error: LazyArg<E2>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R, E2 | E, A>;
    <R, E, A, E2>(self: Query<R, E, Option.Option<A>>, error: LazyArg<E2>): Query<R, E | E2, A>;
};
/**
 * Constructs a query that succeeds with the specified value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const succeed: <A>(value: A) => Query<never, never, A>;
/**
 * Constructs a query that succeds with the empty value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const succeedNone: (_: void) => Query<never, never, Option.Option<never>>;
/**
 * Constructs a query that succeeds with the optional value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const succeedSome: <A>(value: A) => Query<never, never, Option.Option<A>>;
/**
 * Summarizes a query by computing some value before and after execution, and
 * then combining the values to produce a summary, together with the result of
 * execution.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const summarized: {
    <R2, E2, B, C>(summary: Effect.Effect<R2, E2, B>, f: (start: B, end: B) => C): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [C, A]>;
    <R, E, A, R2, E2, B, C>(self: Query<R, E, A>, summary: Effect.Effect<R2, E2, B>, f: (start: B, end: B) => C): Query<R | R2, E | E2, readonly [C, A]>;
};
/**
 * Returns a lazily constructed query.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const suspend: <R, E, A>(evaluate: LazyArg<Query<R, E, A>>) => Query<R, E, A>;
/**
 * Constructs a query that succeeds with the specified lazily evaluated value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const sync: <A>(evaluate: LazyArg<A>) => Query<never, never, A>;
/**
 * Returns a new query that executes this one and times the execution.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const timed: <R, E, A>(self: Query<R, E, A>) => Query<R, E, readonly [Duration.Duration, A]>;
/**
 * Returns an effect that will timeout this query, returning `None` if the
 * timeout elapses before the query was completed.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const timeout: {
    (duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E, Option.Option<A>>;
    <R, E, A>(self: Query<R, E, A>, duration: Duration.Duration): Query<R, E, Option.Option<A>>;
};
/**
 * The same as `Query.timeout`, but instead of producing a `None` in the event
 * of timeout, it will produce the specified error.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const timeoutFail: {
    <E2>(error: LazyArg<E2>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>;
    <R, E, A, E2>(self: Query<R, E, A>, error: LazyArg<E2>, duration: Duration.Duration): Query<R, E | E2, A>;
};
/**
 * The same as `Query.timeout`, but instead of producing a `None` in the event
 * of timeout, it will produce the specified failure.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const timeoutFailCause: {
    <E2>(evaluate: LazyArg<Cause.Cause<E2>>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>;
    <R, E, A, E2>(self: Query<R, E, A>, evaluate: LazyArg<Cause.Cause<E2>>, duration: Duration.Duration): Query<R, E | E2, A>;
};
/**
 * Returns a query that will timeout this query, returning either the default
 * value if the timeout elapses before the query has completed or the result
 * of applying the function `f` to the successful result of the query.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const timeoutTo: {
    <B2, A, B>(def: B2, f: (a: A) => B, duration: Duration.Duration): <R, E>(self: Query<R, E, A>) => Query<R, E, B2 | B>;
    <R, E, A, B2, B>(self: Query<R, E, A>, def: B2, f: (a: A) => B, duration: Duration.Duration): Query<R, E, B2 | B>;
};
/**
 * Disables caching for this query.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const uncached: <R, E, A>(self: Query<R, E, A>) => Query<R, E, A>;
/**
 * The query that succeeds with the unit value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const unit: (_: void) => Query<never, never, void>;
/**
 * Converts a `Query<R, Either<E, B>, A>` into a `Query<R, E, Either<A, B>>`.
 *
 * The inverse of `left`.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const unleft: <R, E, E2, A>(self: Query<R, Either.Either<E, E2>, A>) => Query<R, E, Either.Either<A, E2>>;
/**
 * Converts an option on errors into an option on values.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const unoption: <R, E, A>(self: Query<R, Option.Option<E>, A>) => Query<R, E, Option.Option<A>>;
/**
 * Takes some fiber failures and converts them into errors.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const unrefine: {
    <E, E2>(pf: (defect: unknown) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E | E2, A>;
    <R, E, A, E2>(self: Query<R, E, A>, pf: (defect: unknown) => Option.Option<E2>): Query<R, E | E2, A>;
};
/**
 * Takes some fiber failures and converts them into errors, using the
 * specified function to convert the error.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const unrefineWith: {
    <E, E2, E3>(pf: (defect: unknown) => Option.Option<E2>, f: (error: E) => E3): <R, A>(self: Query<R, E, A>) => Query<R, E2 | E3, A>;
    <R, E, A, E2, E3>(self: Query<R, E, A>, pf: (defect: unknown) => Option.Option<E2>, f: (error: E) => E3): Query<R, E2 | E3, A>;
};
/**
 * Converts a `Query<R, Either<B, E>, A>` into a `Query<R, E, Either<B, A>>`.
 *
 * The inverse of `right`.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const unright: <R, E, E2, A>(self: Query<R, Either.Either<E, E2>, A>) => Query<R, E2, Either.Either<E, A>>;
/**
 * The inverse operation `Query.sandbox`.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const unsandbox: <R, E, A>(self: Query<R, Cause.Cause<E>, A>) => Query<R, E, A>;
/**
 * Unwraps a query that is produced by an effect.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const unwrap: <R, E, A>(effect: Effect.Effect<R, E, Query<R, E, A>>) => Query<R, E, A>;
/**
 * Returns a query that models the execution of this query and the specified
 * query sequentially, combining their results into a tuple.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zip: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query, batching requests to data sources and combining their results into a
 * tuple.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipBatched: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query, batching requests to data sources and returning the result of this
 * query.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipBatchedLeft: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query, batching requests to data sources and returning the result of the
 * specified query.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipBatchedRight: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query sequentially, returning the result of this query.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipLeft: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query sequentially, returning the result of the specified query.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipRight: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query in parallel, combining their results into a tuple.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipPar: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query in parallel, returning the result of this query.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipParLeft: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query in parallel, returning the result of the specified query.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipParRight: {
    <R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
    <R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query sequentially, combining their results with the specified function.
 * Requests composed with `zipWith` or combinators derived from it will
 * automatically be pipelined.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipWith: {
    <R2, E2, B, A, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
    <R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query, batching requests to data sources.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipWithBatched: {
    <A, R2, E2, B, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
    <R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>;
};
/**
 * Returns a query that models the execution of this query and the specified
 * query in parallel, combining their results with the specified function.
 * Requests composed with `zipWithPar` or combinators derived from it will
 * automatically be batched.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipWithPar: {
    <A, R2, E2, B, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
    <R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>;
};
//# sourceMappingURL=Query.d.ts.map