import * as Context from "../Context.ts";
import * as Effect from "../Effect.ts";
import * as Layer from "../Layer.ts";
import * as Scope from "../Scope.ts";
import { type HttpMiddleware } from "./HttpMiddleware.ts";
import { HttpServerError } from "./HttpServerError.ts";
import { HttpServerRequest } from "./HttpServerRequest.ts";
import type { HttpServerResponse } from "./HttpServerResponse.ts";
/**
 * Runs an HTTP server effect, sends the produced response with the supplied handler, and converts failures into HTTP responses.
 * On handler failure, the request scope closes with the original cause.
 * If the send handler returns an `HttpServerResponse`, such as the `101`
 * response of an upgraded request, middleware observes it in place of the
 * handler's response.
 *
 * @stability unstable
 * @category combinators
 * @since 4.0.0
 */
export declare const toHandled: <E, R, EH, RH>(self: Effect.Effect<HttpServerResponse, E, R>, handleResponse: (request: HttpServerRequest, response: HttpServerResponse) => Effect.Effect<unknown, EH, RH>, middleware?: HttpMiddleware | undefined) => Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>>;
/**
 * Disables automatic closing for an HTTP request scope.
 *
 * **Gotchas**
 *
 * Use only when another owner will close the scope; otherwise resources attached
 * to the request scope can leak.
 *
 * @stability unstable
 * @category resource management
 * @since 4.0.0
 */
export declare const scopeDisableClose: (scope: Scope.Scope) => void;
/**
 * Returns a streaming server response that closes the request scope when the body stream exits.
 *
 * @stability unstable
 * @category resource management
 * @since 4.0.0
 */
export declare const scopeTransferToStream: (response: HttpServerResponse) => HttpServerResponse;
/**
 * Function run with the current request and response just before the response is sent, allowing the response to be replaced or failing with `HttpServerError`.
 *
 * @stability unstable
 * @category handlers
 * @since 4.0.0
 */
export type PreResponseHandler = (request: HttpServerRequest, response: HttpServerResponse) => Effect.Effect<HttpServerResponse, HttpServerError>;
/**
 * Registers an additional pre-response handler for the current HTTP server request.
 *
 * @stability unstable
 * @category handlers
 * @since 4.0.0
 */
export declare const appendPreResponseHandler: (handler: PreResponseHandler) => Effect.Effect<void, never, HttpServerRequest>;
/**
 * Registers a pre-response handler for the HTTP server request that owns the
 * supplied fiber context. Does nothing outside a server request.
 *
 * @stability unstable
 * @category unsafe
 * @since 4.0.0
 */
export declare const appendPreResponseHandlerUnsafe: (context: Context.Context<never>, handler: PreResponseHandler) => void;
/**
 * Runs an effect after registering a pre-response handler for the current HTTP server request.
 *
 * @stability unstable
 * @category handlers
 * @since 4.0.0
 */
export declare const withPreResponseHandler: {
    /**
     * Runs an effect after registering a pre-response handler for the current HTTP server request.
     *
     * @stability unstable
     * @category handlers
     * @since 4.0.0
     */
    (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>;
    /**
     * Runs an effect after registering a pre-response handler for the current HTTP server request.
     *
     * @stability unstable
     * @category handlers
     * @since 4.0.0
     */
    <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R | HttpServerRequest>;
};
/**
 * Converts an HTTP server effect into a Web `Request` handler using the supplied base context and optional middleware.
 *
 * @stability unstable
 * @category converting
 * @since 4.0.0
 */
export declare const toWebHandlerWith: <Provided, R = never, ReqR = Exclude<R, Provided | Scope.Scope | HttpServerRequest>>(context: Context.Context<Provided>) => <E>(self: Effect.Effect<HttpServerResponse, E, R>, middleware?: HttpMiddleware | undefined) => [ReqR] extends [never] ? (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response> : (request: Request, context: Context.Context<ReqR>) => Promise<globalThis.Response>;
/**
 * Converts an HTTP server effect into a Web `Request` handler using an empty base context.
 *
 * @stability unstable
 * @category converting
 * @since 4.0.0
 */
export declare const toWebHandler: <E>(self: Effect.Effect<HttpServerResponse, E, HttpServerRequest | Scope.Scope>, middleware?: HttpMiddleware | undefined) => (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response>;
/**
 * Builds a Web `Request` handler from a layer and handler factory, returning the handler with a `dispose` function for the layer scope.
 *
 * **Details**
 *
 * Every call to `dispose` returns the same promise, which resolves once the
 * layer resources have been released.
 *
 * The layer is built immediately, so the cost is paid when the handler is
 * created rather than on the first request. A layer that performs asynchronous
 * work while building may still be in progress when the first request arrives,
 * in which case that request waits for the build to finish. If the build fails,
 * every request rejects with the build error.
 *
 * @stability unstable
 * @category converting
 * @since 4.0.0
 */
export declare const toWebHandlerLayerWith: <E, Provided, LE, R, ReqR = Exclude<R, Provided | Scope.Scope | HttpServerRequest>>(layer: Layer.Layer<Provided, LE>, options: {
    readonly toHandler: (context: Context.Context<Provided>) => Effect.Effect<Effect.Effect<HttpServerResponse, E, R>, LE>;
    readonly middleware?: HttpMiddleware | undefined;
    readonly memoMap?: Layer.MemoMap | undefined;
}) => {
    readonly dispose: () => Promise<void>;
    readonly handler: [ReqR] extends [never] ? (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response> : (request: Request, context: Context.Context<ReqR>) => Promise<globalThis.Response>;
};
/**
 * Builds a Web `Request` handler for an HTTP server effect using a layer to provide its services, returning the handler with a `dispose` function.
 *
 * **Details**
 *
 * The layer is built immediately, so the cost is paid when the handler is
 * created rather than on the first request. A layer that performs asynchronous
 * work while building may still be in progress when the first request arrives,
 * in which case that request waits for the build to finish. If the build fails,
 * every request rejects with the build error.
 *
 * @stability unstable
 * @category converting
 * @since 4.0.0
 */
export declare const toWebHandlerLayer: <E, R, Provided, LE, ReqR = Exclude<R, Provided | Scope.Scope | HttpServerRequest>>(self: Effect.Effect<HttpServerResponse, E, R>, layer: Layer.Layer<Provided, LE>, options?: {
    readonly middleware?: HttpMiddleware | undefined;
    readonly memoMap?: Layer.MemoMap | undefined;
} | undefined) => {
    readonly dispose: () => Promise<void>;
    readonly handler: [ReqR] extends [never] ? (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response> : (request: Request, context: Context.Context<ReqR>) => Promise<globalThis.Response>;
};
/**
 * Adapts a Web `Request` handler into an HTTP server effect for the current `HttpServerRequest`.
 *
 * @stability unstable
 * @category converting
 * @since 4.0.0
 */
export declare const fromWebHandler: (handler: (request: Request) => Promise<Response>) => Effect.Effect<HttpServerResponse, HttpServerError, HttpServerRequest>;
//# sourceMappingURL=HttpEffect.d.ts.map