/**
 * @since 1.0.0
 */
import type * as Chunk from "@effect/data/Chunk";
import type * as Context from "@effect/data/Context";
import type * as Either from "@effect/data/Either";
import type * as Equal from "@effect/data/Equal";
import type * as Option from "@effect/data/Option";
import type * as Effect from "@effect/io/Effect";
import type * as CompletedRequestMap from "@effect/query/CompletedRequestMap";
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 DataSourceTypeId: unique symbol;
/**
 * @since 1.0.0
 * @category symbols
 */
export type DataSourceTypeId = typeof DataSourceTypeId;
/**
 * A `DataSource<R, A>` requires an environment `R` and is capable of executing
 * requests of type `A`.
 *
 * Data sources must implement the method `runAll` which takes a collection of
 * requests and returns an effect with a `CompletedRequestMap` containing a
 * mapping from requests to results. The type of the collection of requests is
 * a `Chunk<Chunk<A>>`. The outer `Chunk` represents batches of requests that
 * must be performed sequentially. The inner `Chunk` represents a batch of
 * requests that can be performed in parallel. This allows data sources to
 * introspect on all the requests being executed and optimize the query.
 *
 * Data sources will typically be parameterized on a subtype of `Request<A>`,
 * though that is not strictly necessarily as long as the data source can map
 * the request type to a `Request<A>`. Data sources can then pattern match on
 * the collection of requests to determine the information requested, execute
 * the query, and place the results into the `CompletedRequestMap` using
 * `CompletedRequestMap.empty` and `CompletedRequestMap.insert`. Data
 * sources must provide results for all requests received. Failure to do so
 * will cause a query to die with a `QueryFailure` when run.
 *
 * @since 1.0.0
 * @category models
 */
export interface DataSource<R, A> extends Equal.Equal {
    /**
     * The data source's identifier.
     */
    readonly identifier: string;
    /**
     * Execute a collection of requests. The outer `Chunk` represents batches
     * of requests that must be performed sequentially. The inner `Chunk`
     * represents a batch of requests that can be performed in parallel.
     */
    runAll(requests: Chunk.Chunk<Chunk.Chunk<A>>): Effect.Effect<R, never, CompletedRequestMap.CompletedRequestMap>;
}
/**
 * @since 1.0.0
 */
export declare namespace DataSource {
    /**
     * @since 1.0.0
     * @category models
     */
    interface Variance<R, A> {
        readonly [DataSourceTypeId]: {
            readonly _R: (_: never) => R;
            readonly _A: (_: never) => A;
        };
    }
}
/**
 * Returns `true` if the specified value is a `DataSource`, `false` otherwise.
 *
 * @since 1.0.0
 * @category refinements
 */
export declare const isDataSource: (u: unknown) => u is DataSource<unknown, unknown>;
/**
 * Constructs a data source with the specified identifier and method to run
 * requests.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const make: <R, A>(identifier: string, runAll: (requests: Chunk.Chunk<Chunk.Chunk<A>>) => Effect.Effect<R, never, void>) => DataSource<Exclude<R, CompletedRequestMap.CompletedRequestMap>, A>;
/**
 * Constructs a data source from a function taking a collection of requests
 * and returning a `CompletedRequestMap`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const makeBatched: <R, A extends Request.Request<any, any>>(identifier: string, run: (requests: Chunk.Chunk<A>) => Effect.Effect<R, never, void>) => DataSource<Exclude<R, CompletedRequestMap.CompletedRequestMap>, A>;
/**
 * A data source aspect that executes requests 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, A>(self: DataSource<R, A>) => DataSource<R2 | R3 | R, A>;
    <R, A, R2, A2, R3, _>(self: DataSource<R, A>, before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): DataSource<R | R2 | R3, A>;
};
/**
 * Returns a data source that executes at most `n` requests in parallel.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const batchN: {
    (n: number): <R, A>(self: DataSource<R, A>) => DataSource<R, A>;
    <R, A>(self: DataSource<R, A>, n: number): DataSource<R, A>;
};
/**
 * Returns a new data source that executes requests of type `B` using the
 * specified function to transform `B` requests into requests that this data
 * source can execute.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const contramap: {
    <A extends Request.Request<any, any>, B extends Request.Request<any, any>>(f: Described.Described<(_: B) => A>): <R>(self: DataSource<R, A>) => DataSource<R, B>;
    <R, A extends Request.Request<any, any>, B extends Request.Request<any, any>>(self: DataSource<R, A>, f: Described.Described<(_: B) => A>): DataSource<R, B>;
};
/**
 * Provides this data source 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>>): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R0, A>;
    <R, A extends Request.Request<any, any>, R0>(self: DataSource<R, A>, f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): DataSource<R0, A>;
};
/**
 * Returns a new data source that executes requests of type `B` using the
 * specified effectual function to transform `B` requests into requests that
 * this data source can execute.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const contramapEffect: {
    <A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>): <R>(self: DataSource<R, A>) => DataSource<R2 | R, B>;
    <R, A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(self: DataSource<R, A>, f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>): DataSource<R | R2, B>;
};
/**
 * Returns a new data source that executes requests of type `C` using the
 * specified function to transform `C` requests into requests that either this
 * data source or that data source can execute.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const eitherWith: {
    <A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>, C extends Request.Request<any, any>>(that: DataSource<R2, B>, f: Described.Described<(_: C) => Either.Either<A, B>>): <R>(self: DataSource<R, A>) => DataSource<R2 | R, C>;
    <R, A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>, C extends Request.Request<any, any>>(self: DataSource<R, A>, that: DataSource<R2, B>, f: Described.Described<(_: C) => Either.Either<A, B>>): DataSource<R | R2, C>;
};
/**
 * Constructs a data source from a pure function.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunction: <A extends Request.Request<never, any>>(name: string, f: (request: A) => Request.Request.Success<A>) => DataSource<never, A>;
/**
 * Constructs a data source from a pure function that takes a list of requests
 * and returns a list of results of the same size. Each item in the result
 * list must correspond to the item at the same index in the request list.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionBatched: <A extends Request.Request<never, any>>(name: string, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<Request.Request.Success<A>>) => DataSource<never, A>;
/**
 * Constructs a data source from an effectual function that takes a list of
 * requests and returns a list of results of the same size. Each item in the
 * result list must correspond to the item at the same index in the request
 * list.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionBatchedEffect: <R, A extends Request.Request<any, any>>(name: string, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, Request.Request.Error<A>, Chunk.Chunk<Request.Request.Success<A>>>) => DataSource<R, A>;
/**
 * Constructs a data source from a pure function that takes a list of requests
 * and returns a list of optional results of the same size. Each item in the
 * result list must correspond to the item at the same index in the request
 * list.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionBatchedOption: <A extends Request.Request<never, any>>(name: string, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<Option.Option<Request.Request.Success<A>>>) => DataSource<never, A>;
/**
 * Constructs a data source from an effectual function that takes a list of
 * requests and returns a list of optional results of the same size. Each item
 * in the result list must correspond to the item at the same index in the
 * request list.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionBatchedOptionEffect: <R, A extends Request.Request<any, any>>(name: string, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, Request.Request.Error<A>, Chunk.Chunk<Option.Option<Request.Request.Success<A>>>>) => DataSource<R, A>;
/**
 * Constructs a data source from a function that takes a list of requests and
 * returns a list of results of the same size. Uses the specified function to
 * associate each result with the corresponding effect, allowing the function
 * to return the list of results in a different order than the list of
 * requests.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionBatchedWith: <A extends Request.Request<any, any>>(name: string, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<Request.Request.Success<A>>, g: (value: Request.Request.Success<A>) => Request.Request<never, Request.Request.Success<A>>) => DataSource<never, A>;
/**
 * Constructs a data source from an effectual function that takes a list of
 * requests and returns a list of results of the same size. Uses the specified
 * function to associate each result with the corresponding effect, allowing
 * the function to return the list of results in a different order than the
 * list of requests.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionBatchedWithEffect: <R, A extends Request.Request<any, any>>(name: string, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, Request.Request.Error<A>, Chunk.Chunk<Request.Request.Success<A>>>, g: (b: Request.Request.Success<A>) => Request.Request<Request.Request.Error<A>, Request.Request.Success<A>>) => DataSource<R, A>;
/**
 * Constructs a data source from an effectual function.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionEffect: <R, A extends Request.Request<any, any>>(name: string, f: (a: A) => Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>) => DataSource<R, A>;
/**
 * Constructs a data source from a pure function that may not provide results
 * for all requests received.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionOption: <A extends Request.Request<never, any>>(name: string, f: (a: A) => Option.Option<Request.Request.Success<A>>) => DataSource<never, A>;
/**
 * Constructs a data source from an effectual function that may not provide
 * results for all requests received.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromFunctionOptionEffect: <R, A extends Request.Request<any, any>>(name: string, f: (a: A) => Effect.Effect<R, Request.Request.Error<A>, Option.Option<Request.Request.Success<A>>>) => DataSource<R, A>;
/**
 * A data source that never executes requests.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const never: (_: void) => DataSource<never, never>;
/**
 * Provides this data source with its required context.
 *
 * @since 1.0.0
 * @category context
 */
export declare const provideContext: {
    <R>(context: Described.Described<Context.Context<R>>): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<never, A>;
    <R, A extends Request.Request<any, any>>(self: DataSource<R, A>, context: Described.Described<Context.Context<R>>): DataSource<never, A>;
};
/**
 * Returns a new data source that executes requests by sending them to this
 * data source and that data source, returning the results from the first data
 * source to complete and safely interrupting the loser.
 *
 * @since 1.0.0
 * @category combinators
 */
export declare const race: {
    <R2, A2 extends Request.Request<any, any>>(that: DataSource<R2, A2>): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R2 | R, A2 | A>;
    <R, A extends Request.Request<any, any>, R2, A2 extends Request.Request<any, any>>(self: DataSource<R, A>, that: DataSource<R2, A2>): DataSource<R | R2, A | A2>;
};
//# sourceMappingURL=DataSource.d.ts.map