import type { Cache } from './Cache';
import type { DataSource } from './DataSource';
import type { DataSourceAspect } from './DataSourceAspect';
import type { Result } from './internal/Result';
import type { AnyRequest } from './Request';
import type { Has, Tag } from '@principia/base/Has';
import type { IO } from '@principia/base/IO';
import type { _A, _E } from '@principia/base/prelude';
import type * as P from '@principia/base/prelude';
import * as E from '@principia/base/Either';
import * as I from '@principia/base/IO';
import * as Ca from '@principia/base/IO/Cause';
import * as L from '@principia/base/Layer';
import * as M from '@principia/base/Maybe';
import { Described } from './Described';
import { QueryContext } from './internal/QueryContext';
export declare const QueryTypeId: unique symbol;
export declare 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 `map2Par` and
 * combinators derived from it, will automatically be batched. Requests that
 * must be performed sequentially, as expressed by `map2` 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.
 */
export declare class Query<R, E, A> {
    readonly step: IO<readonly [R, QueryContext], never, Result<R, E, A>>;
    readonly [QueryTypeId]: QueryTypeId;
    constructor(step: IO<readonly [R, QueryContext], never, Result<R, E, A>>);
}
export declare function isQuery(u: unknown): u is Query<unknown, unknown, unknown>;
/**
 * Returns an effect that models executing this query with the specified
 * context.
 */
export declare function runContext_<R, E, A>(ma: Query<R, E, A>, queryContext: QueryContext): I.IO<R, E, A>;
/**
 * Returns an effect that models executing this query with the specified
 * context.
 */
export declare function runContext(queryContext: QueryContext): <R, E, A>(ma: Query<R, E, A>) => I.IO<R, E, A>;
/**
 * Returns an effect that models executing this query with the specified
 * cache.
 */
export declare function runCache_<R, E, A>(ma: Query<R, E, A>, cache: Cache): I.IO<R, E, A>;
/**
 * Returns an effect that models executing this query with the specified
 * cache.
 */
export declare function runCache(cache: Cache): <R, E, A>(ma: Query<R, E, A>) => I.IO<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>(ma: Query<R, E, A>): I.IO<R, E, readonly [Cache, A]>;
export declare function run<R, E, A>(ma: Query<R, E, A>): I.IO<R, E, A>;
/**
 * Recovers from all errors with provided Cause.
 */
export declare function catchAllCause_<R, E, A, R1, E1, B>(ma: Query<R, E, A>, h: (cause: Ca.Cause<E>) => Query<R1, E1, B>): Query<R & R1, E1, A | B>;
/**
 * Recovers from all errors with provided Cause.
 */
export declare function catchAllCause<E, R1, E1, B>(h: (cause: Ca.Cause<E>) => Query<R1, E1, B>): <R, A>(ma: Query<R, E, A>) => Query<R & R1, E1, A | B>;
/**
 * Recovers from all errors.
 */
export declare function catchAll_<R, E, A, R1, E1, B>(ma: Query<R, E, A>, h: (e: E) => Query<R1, E1, B>): Query<R & R1, E1, A | B>;
/**
 * Recovers from all errors.
 */
export declare function catchAll<E, R1, E1, B>(h: (e: E) => Query<R1, E1, B>): <R, A>(ma: Query<R, E, A>) => Query<R & R1, E1, A | B>;
/**
 * A more powerful version of `matchM` that allows recovering from any type
 * of failure except interruptions.
 */
export declare function matchCauseQuery_<R, E, A, R1, E1, B, R2, E2, C>(ma: Query<R, E, A>, onFailure: (cause: Ca.Cause<E>) => Query<R1, E1, B>, onSuccess: (a: A) => Query<R2, E2, C>): Query<R & R1 & R2, E1 | E2, B | C>;
/**
 * A more powerful version of `matchM` that allows recovering from any type
 * of failure except interruptions.
 */
export declare function matchCauseQuery<E, A, R1, E1, B, C>(onFailure: (cause: Ca.Cause<E>) => Query<R1, E1, B>, onSuccess: (a: A) => Query<R1, E1, C>): <R>(ma: Query<R, E, A>) => Query<R & R1, E1, B | C>;
/**
 * 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 matchQuery_<R, E, A, R1, E1, B, R2, E2, C>(ma: Query<R, E, A>, onFailure: (error: E) => Query<R1, E1, B>, onSuccess: (a: A) => Query<R2, E2, C>): Query<R & R1 & R2, E1 | E2, B | C>;
/**
 * 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 matchQuery<E, A, R1, E1, B, C>(onFailure: (error: E) => Query<R1, E1, B>, onSuccess: (a: A) => Query<R1, E1, C>): <R>(ma: Query<R, E, A>) => Query<R & R1, E1, B | C>;
/**
 * 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 match_<R, E, A, B, C>(ma: Query<R, E, A>, onFailure: (error: E) => B, onSuccess: (a: A) => C): Query<R, never, B | C>;
/**
 * 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 match<E, A, B, C>(onFailure: (error: E) => B, onSuccess: (a: A) => C): <R>(ma: Query<R, E, A>) => Query<R, never, B | C>;
export declare function ap_<R, E, A, R1, E1, B>(fab: Query<R, E, (a: A) => B>, fa: Query<R1, E1, A>): Query<R & R1, E | E1, B>;
export declare function ap<R, E, A>(fa: Query<R, E, A>): <R1, E1, B>(fab: Query<R1, E1, (a: A) => B>) => Query<R & R1, E | E1, B>;
export declare function crossFirst_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, A>;
export declare function crossFirst<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, A>;
export declare function crossSecond_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, B>;
export declare function crossSecond<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, B>;
export declare function crossWith_<R, E, A, R1, E1, B, C>(fa: Query<R, E, A>, fb: Query<R1, E1, B>, f: (a: A, b: B) => C): Query<R & R1, E | E1, C>;
export declare function crossWith<A, R1, E1, B, C>(fb: Query<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(fa: Query<R, E, A>) => Query<R & R1, E | E1, C>;
export declare function cross_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, readonly [A, B]>;
export declare function cross<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, readonly [A, B]>;
export declare function apC_<R, E, A, R1, E1, B>(fab: Query<R, E, (a: A) => B>, fa: Query<R1, E1, A>): Query<R & R1, E | E1, B>;
export declare function apC<R, E, A>(fa: Query<R, E, A>): <R1, E1, B>(fab: Query<R1, E1, (a: A) => B>) => Query<R & R1, E | E1, B>;
export declare function apFirstC_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, A>;
export declare function apFirstC<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, A>;
export declare function apSecondC_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, B>;
export declare function apSecondC<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, B>;
export declare function crossWithC_<R, E, A, R1, E1, B, C>(fa: Query<R, E, A>, fb: Query<R1, E1, B>, f: (a: A, b: B) => C): Query<R & R1, E | E1, C>;
export declare function crossWithC<A, R1, E1, B, C>(fb: Query<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(fa: Query<R, E, A>) => Query<R & R1, E | E1, C>;
export declare function crossC_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, readonly [A, B]>;
export declare function crossC<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, readonly [A, B]>;
export declare function apBatched_<R, E, A, R1, E1, B>(fab: Query<R, E, (a: A) => B>, fa: Query<R1, E1, A>): Query<R & R1, E | E1, B>;
export declare function apBatched<R, E, A>(fa: Query<R, E, A>): <R1, E1, B>(fab: Query<R1, E1, (a: A) => B>) => Query<R & R1, E | E1, B>;
export declare function apFirstBatched_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, A>;
export declare function apFirstBatched<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, A>;
export declare function apSecondBatched_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, B>;
export declare function apSecondBatched<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, B>;
export declare function crossWithBatched_<R, E, A, R1, E1, B, C>(fa: Query<R, E, A>, fb: Query<R1, E1, B>, f: (a: A, b: B) => C): Query<R & R1, E | E1, C>;
export declare function crossWithBatched<A, R1, E1, B, C>(fb: Query<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(fa: Query<R, E, A>) => Query<R & R1, E | E1, C>;
export declare function crossBatched_<R, E, A, R1, E1, B>(fa: Query<R, E, A>, fb: Query<R1, E1, B>): Query<R & R1, E | E1, readonly [A, B]>;
export declare function crossBatched<R1, E1, B>(fb: Query<R1, E1, B>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E | E1, readonly [A, B]>;
export declare function bimap_<R, E, A, E1, B>(pab: Query<R, E, A>, f: (e: E) => E1, g: (a: A) => B): Query<R, E1, B>;
export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B): <R>(pab: Query<R, E, A>) => Query<R, E1, B>;
export declare function mapError_<R, E, A, E1>(pab: Query<R, E, A>, f: (e: E) => E1): Query<R, E1, A>;
export declare function mapError<E, E1>(f: (e: E) => E1): <R, A>(pab: Query<R, E, A>) => Query<R, E1, A>;
export declare function mapErrorCause_<R, E, A, E1>(pab: Query<R, E, A>, h: (cause: Ca.Cause<E>) => Ca.Cause<E1>): Query<R, E1, A>;
export declare function mapErrorCause<E, E1>(h: (cause: Ca.Cause<E>) => Ca.Cause<E1>): <R, A>(pab: Query<R, E, A>) => Query<R, E1, A>;
export declare function subsumeEither<R, E, E1, A>(v: Query<R, E, E.Either<E1, A>>): Query<R, E | E1, A>;
export declare function either<R, E, A>(ma: Query<R, E, A>): Query<R, never, E.Either<E, A>>;
export declare function as_<R, E, A, B>(fa: Query<R, E, A>, b: B): Query<R, E, B>;
export declare function as<B>(b: B): <R, E, A>(fa: Query<R, E, A>) => Query<R, E, B>;
export declare function map_<R, E, A, B>(fa: Query<R, E, A>, f: (a: A) => B): Query<R, E, B>;
export declare function map<A, B>(f: (a: A) => B): <R, E>(fa: Query<R, E, A>) => Query<R, E, B>;
export declare function mapDataSources_<R, E, A, R1>(fa: Query<R, E, A>, f: DataSourceAspect<R1>): Query<R & R1, E, A>;
export declare function mapDataSources<R1>(f: DataSourceAspect<R1>): <R, E, A>(fa: Query<R, E, A>) => Query<R & R1, E, A>;
export declare function defer<R, E, A>(query: () => Query<R, E, A>): Query<R, E, A>;
export declare function halt(error: unknown): Query<unknown, never, never>;
export declare function fail<E>(error: E): Query<unknown, E, never>;
export declare function fromIO<R, E, A>(effect: IO<R, E, A>): Query<R, E, A>;
export declare function fromEither<E, A>(either: E.Either<E, A>): Query<unknown, E, A>;
export declare function fromOption<A>(option: M.Maybe<A>): Query<unknown, M.Maybe<never>, A>;
export declare function fromRequest<R, A extends AnyRequest>(request: A, dataSource: DataSource<R, A>): Query<R, _E<A>, _A<A>>;
export declare function fromRequestUncached<R, A extends AnyRequest>(request: A, dataSource: DataSource<R, A>): Query<R, _E<A>, _A<A>>;
export declare function failCause<E>(cause: Ca.Cause<E>): Query<unknown, E, never>;
export declare const never: Query<unknown, never, never>;
export declare function nothing<A = never>(): Query<unknown, never, M.Maybe<A>>;
export declare function succeed<A>(value: A): Query<unknown, never, A>;
export declare function just<A>(a: A): Query<unknown, never, M.Maybe<A>>;
export declare function chain_<R, E, A, R1, E1, B>(ma: Query<R, E, A>, f: (a: A) => Query<R1, E1, B>): Query<R & R1, E | E1, B>;
export declare function chain<A, R1, E1, B>(f: (a: A) => Query<R1, E1, B>): <R, E>(ma: Query<R, E, A>) => Query<R & R1, E | E1, B>;
export declare function flatten<R, E, R1, E1, A>(mma: Query<R, E, Query<R1, E1, A>>): Query<R & R1, E | E1, A>;
export declare function ask<R>(): Query<R, never, R>;
export declare function asks<R, A>(f: (_: R) => A): Query<R, never, A>;
export declare function asksQuery<R0, R, E, A>(f: (_: R0) => Query<R, E, A>): Query<R0 & R, E, A>;
export declare function gives_<R, E, A, R0>(ra: Query<R, E, A>, f: Described<(r0: R0) => R>): Query<R0, E, A>;
export declare function gives<R, R0>(f: Described<(r0: R0) => R>): <E, A>(ra: Query<R, E, A>) => Query<R0, E, A>;
export declare function give_<R, E, A>(ra: Query<R, E, A>, r: Described<R>): Query<unknown, E, A>;
export declare function give<R>(r: Described<R>): <E, A>(ra: Query<R, E, A>) => Query<unknown, E, A>;
export declare function giveSome_<E, A, R = unknown, R0 = unknown>(ra: Query<R & R0, E, A>, r: Described<R>): Query<R0, E, A>;
export declare function giveSome<R>(r: Described<R>): <E, A, R0 = unknown>(ra: Query<R & R0, E, A>) => Query<R0, E, A>;
export declare function giveSomeLayer_<R, E, A, R1, E1, A1>(ra: Query<R & A1, E, A>, layer: Described<L.Layer<R1, E1, A1>>): Query<R & R1, E | E1, A>;
export declare function giveSomeLayer<R1, E1, A1>(layer: Described<L.Layer<R1, E1, A1>>): <R, E, A>(ra: Query<R & A1, E, A>) => Query<R & R1, E | E1, A>;
export declare function giveServiceIO_<T>(_: Tag<T>): <R, E, A, R1, E1>(ma: Query<R & Has<T>, E, A>, f: Described<IO<R1, E1, T>>) => Query<R & R1, E | E1, A>;
export declare function giveServiceIO<T>(_: Tag<T>): <R, E>(f: Described<IO<R, E, T>>) => <R1, E1, A1>(ma: Query<R1 & Has<T>, E1, A1>) => Query<R & R1, E | E1, A1>;
export declare function giveService_<T>(_: Tag<T>): <R, E, A>(ma: Query<R & Has<T>, E, A>, f: Described<T>) => Query<R, E, A>;
export declare function giveService<T>(_: Tag<T>): (f: Described<T>) => <R1, E1, A1>(ma: Query<R1 & Has<T>, E1, A1>) => Query<R1, E1, A1>;
export declare function partitionQuery_<A, R, E, B>(as: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, never, readonly [ReadonlyArray<E>, ReadonlyArray<B>]>;
export declare function partitionQuery<A, R, E, B>(f: (a: A) => Query<R, E, B>): (as: Iterable<A>) => Query<R, never, readonly [ReadonlyArray<E>, ReadonlyArray<B>]>;
export declare function partitonParQuery_<A, R, E, B>(as: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, never, readonly [ReadonlyArray<E>, ReadonlyArray<B>]>;
export declare function partitionParQuery<A, R, E, B>(f: (a: A) => Query<R, E, B>): (as: Iterable<A>) => Query<R, never, readonly [ReadonlyArray<E>, ReadonlyArray<B>]>;
export declare function cached<R, E, A>(ma: Query<R, E, A>): Query<R, E, A>;
export declare function ensuring_<R, E, A, R1>(ma: Query<R, E, A>, finalizer: Query<R, never, any>): Query<R & R1, E, A>;
export declare function foreach_<A, R, E, B>(as: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, ReadonlyArray<B>>;
export declare function foreach<A, R, E, B>(f: (a: A) => Query<R, E, B>): (as: Iterable<A>) => Query<R, E, ReadonlyArray<B>>;
export declare function foreachC_<A, R, E, B>(as: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, ReadonlyArray<B>>;
export declare function foreachC<A, R, E, B>(f: (a: A) => Query<R, E, B>): (as: Iterable<A>) => Query<R, E, ReadonlyArray<B>>;
export declare function foreachBatched_<A, R, E, B>(as: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, ReadonlyArray<B>>;
export declare function foreachBatched<A, R, E, B>(f: (a: A) => Query<R, E, B>): (as: Iterable<A>) => Query<R, E, ReadonlyArray<B>>;
export declare function getError<R, E, A>(ma: Query<R, M.Maybe<E>, A>): Query<R, E, M.Maybe<A>>;
export declare function get<R, E, A>(ma: Query<R, E, M.Maybe<A>>): Query<R, M.Maybe<E>, A>;
export declare function getOrFail_<R, E, A, E1>(ma: Query<R, E, M.Maybe<A>>, e: E1): Query<R, E | E1, A>;
export declare function getOrFail<E1>(e: E1): <R, E, A>(ma: Query<R, E, M.Maybe<A>>) => Query<R, E | E1, A>;
export declare function left<R, E, A, B>(ma: Query<R, E, E.Either<A, B>>): Query<R, M.Maybe<E>, A>;
export declare function right<R, E, A, B>(ma: Query<R, E, E.Either<A, B>>): Query<R, M.Maybe<E>, B>;
export declare function leftOrFail_<R, E, A, B, E1>(ma: Query<R, E, E.Either<A, B>>, e: E1): Query<R, E | E1, A>;
export declare function leftOrFail<E1>(e: E1): <R, E, A, B>(ma: Query<R, E, E.Either<A, B>>) => Query<R, E | E1, A>;
export declare function leftOrFailWith_<R, E, A, B, E1>(ma: Query<R, E, E.Either<A, B>>, f: (right: B) => E1): Query<R, E | E1, A>;
export declare function leftOrFailWith<B, E1>(f: (right: B) => E1): <R, E, A>(ma: Query<R, E, E.Either<A, B>>) => Query<R, E | E1, A>;
export declare function optional<R, E, A>(ma: Query<R, E, A>): Query<R, E, M.Maybe<A>>;
export declare function orHaltWith_<R, E, A>(ma: Query<R, E, A>, f: (e: E) => unknown): Query<R, never, A>;
export declare function orHaltWith<E>(f: (e: E) => unknown): <R, A>(ma: Query<R, E, A>) => Query<R, never, A>;
export declare function orHalt<R, E, A>(ma: Query<R, E, A>): Query<R, never, A>;
export declare function refineOrHalt_<R, E, A, E1>(ma: Query<R, E, A>, pf: (e: E) => M.Maybe<E1>): Query<R, E1, A>;
export declare function refineOrHalt<E extends Error, E1>(pf: (e: E) => M.Maybe<E1>): <R, A>(ma: Query<R, E, A>) => Query<R, E1, A>;
export declare function refineOrHaltWith_<R, E, A, E1>(ma: Query<R, E, A>, pf: (e: E) => M.Maybe<E1>, f: (e: E) => unknown): Query<R, E1, A>;
export declare function refineOrHaltWith<E, E1>(pf: (e: E) => M.Maybe<E1>, f: (e: E) => unknown): <R, A>(ma: Query<R, E, A>) => Query<R, E1, A>;
export declare function rightOrFail_<R, E, A, B, E1>(ma: Query<R, E, E.Either<A, B>>, e: E1): Query<R, E | E1, B>;
export declare function rightOrFail<E1>(e: E1): <R, E, A, B>(ma: Query<R, E, E.Either<A, B>>) => Query<R, E | E1, B>;
export declare function rightOrFailWith_<R, E, A, B, E1>(ma: Query<R, E, E.Either<A, B>>, f: (left: A) => E1): Query<R, E | E1, B>;
export declare function rightOrFailWith<A, E1>(f: (left: A) => E1): <R, E, B>(ma: Query<R, E, E.Either<A, B>>) => Query<R, E | E1, B>;
export declare function sandbox<R, E, A>(ma: Query<R, E, A>): Query<R, Ca.Cause<E>, A>;
export declare function unsandbox<R, E, A>(v: Query<R, Ca.Cause<E>, A>): Query<R, E, A>;
export declare function sandboxWith_<R, E, A, R1, E1, B>(ma: Query<R, E, A>, f: (query: Query<R, Ca.Cause<E>, A>) => Query<R1, Ca.Cause<E1>, B>): Query<R & R1, E | E1, B>;
export declare function sandboxWith<R, E, A, R1, E1, B>(f: (query: Query<R, Ca.Cause<E>, A>) => Query<R1, Ca.Cause<E1>, B>): (ma: Query<R, E, A>) => Query<R & R1, E | E1, B>;
export declare function summarized_<R, E, A, R1, E1, B, C>(ma: Query<R, E, A>, summary: I.IO<R1, E1, B>, f: (start: B, end: B) => C): Query<R & R1, E | E1, readonly [C, A]>;
export declare function summarized<R1, E1, B, C>(summary: I.IO<R1, E1, B>, f: (start: B, end: B) => C): <R, E, A>(ma: Query<R, E, A>) => Query<R & R1, E | E1, readonly [C, A]>;
export declare function unrefineWith_<R, E, A, E1>(ma: Query<R, E, A>, pf: (error: unknown) => M.Maybe<E1>, f: (e: E) => E1): Query<R, E1, A>;
export declare function unrefineWith<E, E1>(pf: (error: unknown) => M.Maybe<E1>, f: (e: E) => E1): <R, A>(ma: Query<R, E, A>) => Query<R, E1, A>;
export declare function unrefine_<R, E, A>(ma: Query<R, E, A>, pf: (error: unknown) => M.Maybe<E>): Query<R, E, A>;
export declare function unrefine<E>(pf: (error: unknown) => M.Maybe<E>): <R, A>(ma: Query<R, E, A>) => Query<R, E, A>;
export declare class GenQuery<R, E, A> {
    readonly Q: Query<R, E, A>;
    readonly _R: (_: R) => void;
    readonly _E: () => E;
    readonly _A: () => A;
    constructor(Q: Query<R, E, A>);
    [Symbol.iterator](): Generator<GenQuery<R, E, A>, A, any>;
}
export declare function gen<T extends GenQuery<any, any, any>, A>(f: (i: {
    <R, E, A>(_: Query<R, E, A>): GenQuery<R, E, A>;
    <R, E, A>(_: IO<R, E, A>): GenQuery<R, E, A>;
}) => Generator<T, A, any>): Query<P._R<T>, P._E<T>, A>;
//# sourceMappingURL=Query.d.ts.map