HttpApp

declare function toHandled<E, R, _, EH, RH>(
  self: Default<E, R>,
  handleResponse: (request: HttpServerRequest, response: HttpServerResponse) => Effect<_, EH, RH>,
  middleware?: HttpMiddleware,
): Effect<void, never, HttpServerRequest | Exclude<R, Scope> | Exclude<RH, Scope>>;

declare function fromWebHandler(
  handler: (request: Request) => Promise<Response>,
): Default<HttpServerError>;

declare const toWebHandler: <E>(
  self: Default<E, Scope.Scope>,
  middleware?: HttpMiddleware,
) => (request: Request, context?: Context.Context<never>) => Promise<Response>;

declare function toWebHandlerLayer<E, R, RE>(
  self: Default<E, Scope | R>,
  layer: Layer<R, RE>,
  options?: {
    readonly memoMap?: MemoMap;
    readonly middleware?: HttpMiddleware;
  },
): {
  readonly dispose: () => Promise<void>;
  readonly handler: (request: Request, context?: Context<never>) => Promise<Response>;
};

declare function toWebHandlerLayerWith<E, R, RE, EX>(
  layer: Layer<R, RE>,
  options: {
    readonly memoMap?: MemoMap;
    readonly middleware?: HttpMiddleware;
    readonly toHandler: (
      runtime: Runtime<R>,
    ) => Effect<Effect<HttpServerResponse, E, Scope | HttpServerRequest | R>, EX>;
  },
): {
  readonly dispose: () => Promise<void>;
  readonly handler: (request: Request, context?: Context<never>) => Promise<Response>;
};

declare function toWebHandlerRuntime<R>(
  runtime: Runtime<R>,
): <E>(
  self: Default<E, Scope | R>,
  middleware?: HttpMiddleware,
) => (request: Request, context?: Context<never>) => Promise<Response>;

declare const appendPreResponseHandler: (handler: PreResponseHandler) => Effect.Effect<void>;

declare const currentPreResponseHandlers: FiberRef.FiberRef<Option.Option<PreResponseHandler>>;

declare const withPreResponseHandler: (handler: PreResponseHandler) => <A, E, R>(self: HttpApp<A, E, R>) => HttpApp<A, E, R> & <A, E, R>(self: HttpApp<A, E, R>, handler: PreResponseHandler) => HttpApp<A, E, R>

type Default<E = never, R = never> = HttpApp<ServerResponse.HttpServerResponse, E, R>;

type HttpApp<A = ServerResponse.HttpServerResponse, E = never, R = never> = Effect.Effect<
  A,
  E,
  R | ServerRequest.HttpServerRequest
>;

type PreResponseHandler = (
  request: ServerRequest.HttpServerRequest,
  response: ServerResponse.HttpServerResponse,
) => Effect.Effect<ServerResponse.HttpServerResponse, ServerError.ResponseError>;

declare function ejectDefaultScopeClose(scope: Scope): void;

declare function unsafeEjectStreamScope(response: HttpServerResponse): HttpServerResponse;