import "@effect-ts/system/Operator";
import * as Chunk from "@effect-ts/core/Collections/Immutable/Chunk";
import * as Tp from "@effect-ts/core/Collections/Immutable/Tuple";
import * as T from "@effect-ts/core/Effect";
import { _A, _E, _R } from "@effect-ts/core/Effect";
import * as E from "@effect-ts/core/Either";
import type { Has, Tag } from "@effect-ts/core/Has";
import * as O from "@effect-ts/core/Option";
import type { URI } from "@effect-ts/core/Prelude";
import * as P from "@effect-ts/core/Prelude";
import * as DSL from "@effect-ts/core/Prelude/DSL";
import type { _A as _GetA, _E as _GetE } from "@effect-ts/core/Utils";
import * as C from "@effect-ts/system/Cause";
import * as CL from "@effect-ts/system/Clock";
import { NoSuchElementException } from "@effect-ts/system/GlobalExceptions";
import * as CH from "../Cache/index.js";
import type { DataSource } from "../DataSource/index.js";
import type { DataSourceAspect } from "../DataSourceAspect/index.js";
import type { QueryContext } from "../Internal/QueryContext/index.js";
import * as RES from "../Internal/Result/index.js";
import type { Request } from "../Request/index.js";
/**
 * A `ZQuery[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.
 *
 * {{{
 * val getAllUserIds: ZQuery[Any, Nothing, List[Int]]         = ???
 * def getUserNameById(id: Int): ZQuery[Any, Nothing, String] = ???
 *
 * for {
 *   userIds   <- getAllUserIds
 *   userNames <- ZQuery.forEachPar(userIds)(getUserNameById)
 * } yield userNames
 * }}}
 *
 * This would normally require N + 1 queries, one for `getAllUserIds` and one
 * for each call to `getUserNameById`. In contrast, `ZQuery` 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. [[http://simonmar.github.io/bib/papers/haxl-icfp14.pdf]]
 */
export declare class Query<R, E, A> {
    readonly step: T.Effect<readonly [R, QueryContext], E, RES.Result<R, E, A>>;
    readonly _tag = "Query";
    readonly [_R]: (r: R) => void;
    readonly [_E]: () => E;
    readonly [_A]: () => A;
    constructor(step: T.Effect<readonly [R, QueryContext], E, RES.Result<R, E, A>>);
}
/**
 * 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.
 */
export declare function chain_<R, E, R1, E1, A, B>(self: Query<R, E, A>, f: (a: A) => Query<R1, E1, B>): Query<R & R1, E | E1, B>;
/**
 * 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.
 * @ets_data_first chain_
 */
export declare function chain<R1, E1, A, B>(f: (a: A) => Query<R1, E1, B>): <R, E>(self: Query<R, E, A>) => Query<R & R1, E1 | E, B>;
/**
 * 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.
 */
export declare function either<R, E, A>(self: Query<R, E, A>): Query<R, never, E.Either<E, A>>;
/**
 * 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 `fold`.
 */
export declare function fold_<R, E, A, B>(self: Query<R, E, A>, failure: (e: E) => B, success: (a: A) => B): Query<R, never, B>;
/**
 * 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 `fold`.
 * @ets_data_first fold_
 */
export declare function fold<B, E, A>(failure: (e: E) => B, success: (a: A) => B): <R>(self: Query<R, E, A>) => Query<R, never, B>;
/**
 * A more powerful version of `foldM` that allows recovering from any type
 * of failure except interruptions.
 */
export declare function foldCauseM_<R, E, A, R2, E2, A2, R3, E3, A3>(self: Query<R, E, A>, failure: (cause: C.Cause<E>) => Query<R2, E2, A2>, success: (a: A) => Query<R3, E3, A3>): Query<R & R2 & R3, E2 | E3, A2 | A3>;
/**
 * A more powerful version of `foldM` that allows recovering from any type
 * of failure except interruptions.
 * @ets_data_first foldCauseM_
 */
export declare function foldCauseM<E, A, R2, E2, A2, R3, E3, A3>(failure: (cause: C.Cause<E>) => Query<R2, E2, A2>, success: (a: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => 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.
 */
export declare function foldM_<R, E, A, R2, E2, A2, R3, E3, A3>(self: Query<R, E, A>, failure: (failure: E) => Query<R2, E2, A2>, success: (a: 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.
 * @ets_data_first foldM_
 */
export declare function foldM<E, A, R2, E2, A2, R3, E3, A3>(failure: (failure: E) => Query<R2, E2, A2>, success: (a: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => Query<R & R2 & R3, E2 | E3, A2 | A3>;
/**
 * Maps the specified function over the successful result of this query.
 */
export declare function map_<R, E, A, B>(self: Query<R, E, A>, f: (a: A) => B): Query<R, E, B>;
/**
 * Maps the specified function over the successful result of this query.
 * @ets_data_first map_
 */
export declare function map<A, B>(f: (a: A) => B): <R, E>(self: Query<R, E, A>) => Query<R, E, B>;
/**
 * Transforms all data sources with the specified data source aspect.
 */
export declare function mapDataSources_<R1, R, E, A>(self: Query<R, E, A>, f: DataSourceAspect<R1>): Query<R & R1, E, A>;
/**
 * Transforms all data sources with the specified data source aspect.
 * @ets_data_first mapDataSources_
 */
export declare function mapDataSources<R1, R>(f: DataSourceAspect<R1>): <E, A>(self: Query<R, E, A>) => Query<R & R1, E, A>;
/**
 * Maps the specified function over the failed result of this query.
 */
export declare function mapError_<R, E, A, E1>(self: Query<R, E, A>, f: (a: E) => E1): Query<R, E1, A>;
/**
 * Maps the specified function over the failed result of this query.
 * @ets_data_first mapError_
 */
export declare function mapError<E, E1>(f: (a: E) => E1): <R, A>(self: Query<R, E, A>) => Query<R, E1, A>;
/**
 * Returns a query whose failure and success channels have been mapped by the
 * specified pair of functions, `f` and `g`.
 */
export declare function bimap_<R, E, A, E1, B>(self: Query<R, E, A>, f: (e: E) => E1, g: (a: A) => B): Query<R, E1, B>;
/**
 * Returns a query whose failure and success channels have been mapped by the
 * specified pair of functions, `f` and `g`.
 * @ets_data_first bimap_
 */
export declare function bimap<E, E1, A, B>(f: (e: E) => E1, g: (a: A) => B): <R>(self: Query<R, E, A>) => Query<R, E1, B>;
/**
 * Provides this query with part of its required environment.
 */
export declare function provideSome_<R, E, A, R0>(self: Query<R, E, A>, description: string, f: (r: R0) => R): Query<R0, E, A>;
/**
 * Provides this query with part of its required environment.
 * @ets_data_first provideSome_
 */
export declare function provideSome<R, R0>(description: string, f: (r: R0) => R): <E, A>(self: Query<R, E, A>) => Query<R0, E, A>;
/**
 * Returns a query that models the execution of this query and the specified
 * query sequentially, combining their results into a tuple.
 */
export declare function zip_<R, R1, E, E1, A, B>(self: Query<R, E, A>, that: Query<R1, E1, B>): Query<R & R1, E | E1, Tp.Tuple<[A, B]>>;
/**
 * Returns a query that models the execution of this query and the specified
 * query sequentially, combining their results into a tuple.
 * @ets_data_first zip_
 */
export declare function zip<R1, E1, B>(that: Query<R1, E1, B>): <R, E, A>(self: Query<R, E, A>) => Query<R & R1, E1 | E, Tp.Tuple<[A, B]>>;
/**
 * 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.
 */
export declare function zipWith_<R, E, R1, E1, B, A, C>(self: Query<R, E, A>, that: Query<R1, E1, B>, f: (a: A, b: B) => C): Query<R & R1, E | E1, C>;
/**
 * 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.
 *
 * @ets_data_first zipWith_
 */
export declare function zipWith<R1, E1, B, A, C>(that: Query<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R & R1, E1 | E, 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.
 */
export declare function zipWithPar_<R, E, A, R1, E1, B, C>(self: Query<R, E, A>, that: Query<R1, E1, B>, f: (a: A, b: B) => C): Query<R & R1, E | E1, 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.
 *
 * @ets_data_first zipWithPar_
 */
export declare function zipWithPar<R1, E1, B, A, C>(that: Query<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R & R1, E1 | E, C>;
/**
 * 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.
 */
export declare function summarized_<R, E, A, R1, E1, B, C>(self: Query<R, E, A>, summary: T.Effect<R1, E1, B>, f: (a: B, b: B) => C): Query<R & R1, E | E1, readonly [C, 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.
 *
 * @ets_data_first summarized_
 */
export declare function summarized<A, R1, E1, B, C>(summary: T.Effect<R1, E1, B>, f: (a: B, b: B) => B): <R, E>(self: Query<R, E, A>) => Query<R & R1, E1 | E, readonly [B, A]>;
/**
 * Returns an effect that will timeout this query, returning `None` if the
 * timeout elapses before the query was completed.
 * @dataFirst timeout_
 */
export declare function timeout(duration: number): <R, E, A>(self: Query<R, E, A>) => Query<Has<CL.Clock> & R, E, O.Option<A>>;
/**
 * Returns an effect that will timeout this query, returning `None` if the
 * timeout elapses before the query was completed.
 */
export declare function timeout_<R, E, A>(self: Query<R, E, A>, duration: number): Query<Has<CL.Clock> & R, E, O.Option<A>>;
/**
 * The same as [[timeout]], but instead of producing a `None` in the event
 * of timeout, it will produce the specified error.
 */
export declare function timeoutFail_<R, E, A, E1>(self: Query<R, E, A>, error: E1, duration: number): Query<Has<CL.Clock> & R, E | E1, A>;
/**
 * The same as [[timeout]], but instead of producing a `None` in the event
 * of timeout, it will produce the specified failure.
 * @dataFirst timeoutFail_
 */
export declare function timeoutFail<E1>(error: E1, duration: number): <R, E, A>(self: Query<R, E, A>) => Query<Has<CL.Clock> & R, E1 | E, A>;
/**
 * The same as [[timeout]], but instead of producing a `None` in the event
 * of timeout, it will produce the specified failure.
 */
export declare function timeoutHalt_<R, E, A, E1>(self: Query<R, E, A>, error: C.Cause<E1>, duration: number): Query<Has<CL.Clock> & R, E | E1, A>;
/**
 * The same as [[timeout]], but instead of producing a `None` in the event
 * of timeout, it will produce the specified error.
 * @dataFirst timeoutHalt_
 */
export declare function timeoutHalt<E1>(error: C.Cause<E1>, duration: number): <R, E, A>(self: Query<R, E, A>) => Query<Has<CL.Clock> & R, E1 | E, A>;
export declare function timeoutTo_<R, E, A, B>(self: Query<R, E, A>, b: B, f: (a: A) => B, duration: number): Query<Has<CL.Clock> & R, E, B>;
/**
 * Constructs a query that fails with the specified cause.
 */
export declare function halt<E>(cause: C.Cause<E>): Query<unknown, E, never>;
/**
 * Constructs a query that never completes.
 */
export declare const never: Query<unknown, never, never>;
/**
 * Constructs a query that succeds with the empty value.
 */
export declare const none: Query<unknown, never, O.Option<never>>;
/**
 *  Constructs a query that succeeds with the specified value.
 */
export declare function succeed<A>(value: A): Query<unknown, never, A>;
/**
 *  Constructs a query that succeeds with the specified value.
 */
export declare function fail<E>(value: E): Query<unknown, E, never>;
/**
 * Constructs a query from an effect.
 */
export declare function fromEffect<R, E, A>(effect: T.Effect<R, E, A>): Query<R, E, A>;
/**
 * Returns a query which submerges the error case of `Either` into the error channel of the query
 *
 * The inverse of [[ZQuery.either]]
 */
export declare function absolve<R, E, A>(query: Query<R, E, E.Either<E, A>>): Query<R, E, 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.
 */
export declare function forEach_<R, E, A, B>(as: 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 sequentially and will be pipelined.
 *
 * @ets_data_first forEach_
 */
export declare function forEach<R, E, A, B>(f: (a: A) => Query<R, E, B>): (as: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
/**
 * Constructs a query from an either
 */
export declare function fromEither<E, A>(either: E.Either<E, A>): Query<unknown, E, A>;
/**
 * Constructs a query from an option
 */
export declare function fromOption<A>(option: O.Option<A>): Query<unknown, O.Option<never>, A>;
/**
 * Collects a collection of queries into a query returning a collection of
 * their results. Requests will be executed sequentially and will be
 * pipelined.
 */
export declare function collectAll<R, E, A>(as: Iterable<Query<R, E, A>>): Query<R, E, Chunk.Chunk<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.
 */
export declare function fromRequest<R, A extends Request<any, any>>(request: A, dataSource: DataSource<R, A>): Query<R, _GetE<A>, _GetA<A>>;
/**
 * Returns an effect that models executing this query with the specified
 * cache.
 */
export declare function runCache(cache: CH.Cache): <R, E, A>(self: Query<R, E, A>) => T.Effect<R, E, A>;
/**
 * Returns an effect that models executing this query.
 */
export declare function run<R, E, A>(query: Query<R, E, A>): T.Effect<R, E, A>;
/**
 * Returns an effect that models executing this query, returning the query
 * result along with the cache.
 */
export declare function runLog<R, E, A>(query: Query<R, E, A>): T.Effect<R, E, readonly [CH.Cache, 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 parallely and will be pipelined.
 */
export declare function forEachPar_<R, E, A, B>(as: 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 parallely and will be pipelined.
 *
 * @ets_data_first forEachPar_
 */
export declare function forEachPar<R, E, A, B>(f: (a: A) => Query<R, E, B>): (as: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
/**
 * Collects a collection of queries into a query returning a collection of
 * their results. Requests will be executed in parallel and will be batched.
 */
export declare function collectAllPar<R, E, A>(as: Iterable<Query<R, E, A>>): Query<R, E, Chunk.Chunk<A>>;
/**
 * Returns a new query that executes this one and times the execution.
 */
export declare function timed<R, E, A>(self: Query<R, E, A>): Query<R & Has<CL.Clock>, E, readonly [number, A]>;
/**
 * Converts this query to one that returns `Some` if data sources return
 * results for all requests received and `None` otherwise.
 */
export declare function optional<R, E, A>(self: Query<R, E, A>): Query<R, E, O.Option<A>>;
/**
 * Lifts the error channel into a `Some` value for composition with other optional queries
 *
 * @see [[ZQuery.some]]
 */
export declare function asSomeError<R, E, A>(self: Query<R, E, A>): Query<R, O.Option<E>, A>;
/**
 * Recovers from all errors.
 */
export declare function catchAll_<R, E, A, R1, E1, B>(self: Query<R, E, A>, h: (e: E) => Query<R1, E1, B>): Query<R & R1, E1, A | B>;
/**
 * Recovers from all errors.
 * @ets_data_first catchAll_
 */
export declare function catchAll<R, E, A, R1, E1, B>(h: (e: E) => Query<R1, E1, B>): (self: Query<R, E, A>) => Query<R & R1, E1, A | B>;
/**
 * Recovers from all errors with provided Cause.
 *
 * @see [[ZQuery.sandbox]] - other functions that can recover from defects
 */
export declare function catchAllCause_<R, E, A, R1, E1, A1>(self: Query<R, E, A>, h: (cause: C.Cause<E>) => Query<R1, E1, A1>): Query<R & R1, E1, A | A1>;
/**
 * Recovers from all errors with provided Cause.
 *
 * @see [[ZQuery.sandbox]] - other functions that can recover from defects
 * @ets_data_first catchAllCause_
 */
export declare function catchAllCause<R, E, A, R1, E1, A1>(h: (cause: C.Cause<E>) => Query<R1, E1, A1>): (self: Query<R, E, A>) => Query<R & R1, E1, A | A1>;
/**
 * 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.
 */
export declare function flatten<R, E, R1, E1, A1>(self: Query<R, E, Query<R1, E1, A1>>): Query<R & R1, E | E1, A1>;
/**
 * Returns a successful query if the value is `Left`, or fails with the error `None`.
 */
export declare function left<R, E, B, C>(self: Query<R, E, E.Either<B, C>>): Query<R, O.Option<E>, B>;
/**
 * Returns a successful query if the value is `Left`, or fails with the error e.
 */
export declare function leftOrFail_<R, E, B, C, E1>(self: Query<R, E, E.Either<B, C>>, e: E1): Query<R, E | E1, B>;
/**
 * Returns a successful query if the value is `Left`, or fails with the error e.
 * @ets_data_first leftOrFail_
 */
export declare function leftOrFail<R, E, B, C, E1>(e: E1): (self: Query<R, E, E.Either<B, C>>) => Query<R, E | E1, B>;
/**
 * Returns a successful query if the value is `Left`, or fails with the given error function 'e'.
 */
export declare function leftOrFailWith_<R, E, B, C, E1>(self: Query<R, E, E.Either<B, C>>, e: (c: C) => E1): Query<R, E | E1, B>;
/**
 * Returns a successful query if the value is `Left`, or fails with the given error function 'e'.
 * @ets_data_first leftOrFailWith_
 */
export declare function leftOrFailWith<R, E, B, C, E1>(e: (c: C) => E1): (self: Query<R, E, E.Either<B, C>>) => Query<R, E | E1, B>;
/**
 * 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`.
 *
 * @see [[sandbox]], [[catchAllCause]] - other functions for dealing with defects
 */
export declare function mapErrorCause_<R, E, A, E2>(self: Query<R, E, A>, h: (cause: C.Cause<E>) => C.Cause<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`.
 *
 * @see [[sandbox]], [[catchAllCause]] - other functions for dealing with defects
 * @ets_data_first mapErrorCause_
 */
export declare function mapErrorCause<R, E, A, E2>(h: (cause: C.Cause<E>) => C.Cause<E2>): (self: Query<R, E, A>) => Query<R, E2, A>;
/**
 * Converts this query to one that dies if a query failure occurs.
 */
export declare function 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 `Throwable`.
 */
export declare function orDieWith_<R, E, A>(self: Query<R, E, A>, f: (e: E) => unknown): 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 `Throwable`.
 * @ets_data_first orDieWith_
 */
export declare function orDieWith<R, E, A>(f: (e: E) => unknown): (self: Query<R, E, A>) => Query<R, never, A>;
/**
 * Constructs a query that dies with the specified error.
 */
export declare function die(cause: unknown): Query<unknown, never, void>;
/**
 * Provides this query with its required environment.
 */
export declare function provide_<R, E, A>(self: Query<R, E, A>, description: string, env: R): Query<unknown, E, A>;
/**
 * Provides this query with its required environment.
 * @ets_data_first provide_
 */
export declare function provide<R, E, A>(description: string, env: R): (self: Query<R, E, A>) => Query<unknown, E, A>;
/**
 * Effectfully accesses the environment of the query.
 */
export declare function access<R0, A>(fn: (env: R0) => A): Query<R0, never, A>;
/**
 * Effectfully accesses the environment of the query.
 */
export declare function accessM<R0, R, E, A>(fn: (env: R0) => Query<R, E, A>): Query<R0 & R, E, A>;
/**
 * Access a service with the required Service Entry
 */
export declare function accessService<T>(s: Tag<T>): <B>(f: (a: T) => B) => Query<Has<T>, never, B>;
/**
 * Access a service with the required Service Entry
 */
export declare function accessServiceM<T>(s: Tag<T>): <R, E, B>(f: (a: T) => Query<R, E, B>) => Query<R & Has<T>, E, B>;
/**
 * Extracts the optional value or fails with NoSuchElementException.
 */
export declare function getOrFail<A>(value: O.Option<A>): Query<unknown, NoSuchElementException, A>;
export declare const QueryURI = "@effect-ts/query/Query";
export declare type QueryURI = typeof QueryURI;
declare module "@effect-ts/core/Prelude/HKT" {
    interface URItoKind<FC, TC, K, Q, W, X, I, S, R, E, A> {
        [QueryURI]: Query<R, E, A>;
    }
}
export declare type V = P.V<"R", "-"> & P.V<"E", "+">;
export declare const Any: P.Any<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const AssociativeFlatten: P.AssociativeFlatten<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const AssociativeBoth: P.AssociativeBoth<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const Covariant: P.Covariant<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const IdentityFlatten: P.IdentityFlatten<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const IdentityBoth: P.IdentityBoth<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const Monad: P.Monad<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const Applicative: P.Applicative<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const Fail: P.FX.Fail<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const Run: P.FX.Run<[URI<"@effect-ts/query/Query", {}>], V>;
export declare const gen: <Eff extends P.GenHKT<Query<any, any, any>, any>, AEff>(f: (i: {
    <E, A>(_: O.Option<A>, onNone: () => E): P.GenHKT<Query<unknown, E, A>, A>;
    <A_1>(_: O.Option<A_1>): P.GenHKT<Query<unknown, NoSuchElementException, A_1>, A_1>;
    <A_2>(_: Tag<A_2>): P.GenHKT<Query<Has<A_2>, never, A_2>, A_2>;
    <E_1, A_3>(_: E.Either<E_1, A_3>): P.GenHKT<Query<unknown, E_1, A_3>, A_3>;
    <R, E_2, A_4>(_: T.Effect<R, E_2, A_4>): P.GenHKT<Query<R, E_2, A_4>, A_4>;
    <R_1, E_3, A_5>(_: Query<R_1, E_3, A_5>): P.GenHKT<Query<R_1, E_3, A_5>, A_5>;
}) => Generator<Eff, AEff, any>) => Query<P.Infer<[URI<"@effect-ts/query/Query", {}>], unknown, "R", Eff["effect"]>, P.Infer<[URI<"@effect-ts/query/Query", {}>], unknown, "E", Eff["effect"]>, AEff>;
export declare const bind: <K2, Q2, W2, X2, I2, S2, R2, E2, BK, BN extends string, BA>(tag: Exclude<BN, keyof BK>, f: (a: BK) => Query<R2, E2, BA>) => <K, Q, W, X, I, S, R, E>(fa: Query<R, E, BK>) => Query<R2 & R, E2, BK & { [k in BN]: BA; }>;
declare const let_: <BK, BN extends string, BA>(tag: Exclude<BN, keyof BK>, f: (a: BK) => BA) => <K, Q, W, X, I, S, R, E>(fa: Query<R, E, BK>) => Query<R, E, BK & { [k in BN]: BA; }>;
declare const do_: Query<unknown, never, {}>;
export { do_ as do, let_ as let };
export { branch as if, branch_ as if_ };
export declare const struct: <NER extends Record<string, Query<any, any, unknown>>, K = any, Q = any, W = any, X = any, I = any, S = any, R = unknown, E = never>(r: import("@effect-ts/system/Utils").EnforceNonEmptyRecord<NER> & Record<string, Query<any, any, unknown>>) => Query<P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "R", NER[keyof NER]>, P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "E", NER[keyof NER]>, { [K_1 in keyof NER]: P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "A", NER[K_1]>; }>;
/**
 * Matchers
 */
export declare const match: <N extends string>(tag: N) => P.MatchFn<[URI<"@effect-ts/query/Query", {}>], V, N>, matchIn: <N_1 extends string>(tag: N_1) => P.MatchInFn<[URI<"@effect-ts/query/Query", {}>], V, N_1>, matchMorph: <N_2 extends string, X extends { [tag in N_2]: string; }>(MorphADT: {
    tag: N_2;
    _A: X;
}) => P.MatchMorphFn<[URI<"@effect-ts/query/Query", {}>], V, N_2, X>, matchTag: P.MatchFn<[URI<"@effect-ts/query/Query", {}>], V, "_tag">, matchTagIn: P.MatchInFn<[URI<"@effect-ts/query/Query", {}>], V, "_tag">;
/**
 * Conditionals
 */
declare const branch: <X extends Query<any, any, any>, Y extends Query<any, any, any>>(onTrue: () => X, onFalse: () => Y) => (predicate: boolean) => Query<P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "R", X | Y>, P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "E", X | Y>, P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "A", X | Y>>;
declare const branch_: <X extends Query<any, any, any>, Y extends Query<any, any, any>>(predicate: boolean, onTrue: () => X, onFalse: () => Y) => Query<P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "R", X | Y>, P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "E", X | Y>, P.Infer<[URI<"@effect-ts/query/Query", {}>], V, "A", X | Y>>;
//# sourceMappingURL=index.d.ts.map