HttpServer

declare const serve: {
  (): <E, R>(httpApp: Default<E, R>) => Layer<never, never, HttpServer | Exclude<R, Scope | HttpServerRequest>>;
  <E, R, App extends Default<any, any>>(middleware: Applied<App, E, R>): (httpApp: Default<E, R>) => Layer<never, never, any>;
  <E, R>(httpApp: Default<E, R>): Layer<never, never, HttpServer | Exclude<R, Scope | HttpServerRequest>>;
  <E, R, App extends Default<any, any>>(httpApp: Default<E, R>, middleware: Applied<App, E, R>): Layer<never, never, any>;
}

declare const serveEffect: {
  (): <E, R>(httpApp: Default<E, R>) => Effect<void, never, Scope | HttpServer | Exclude<R, HttpServerRequest>>;
  <E, R, App extends Default<any, any>>(middleware: Applied<App, E, R>): (httpApp: Default<E, R>) => Effect<void, never, any>;
  <E, R>(httpApp: Default<E, R>): Effect<void, never, Scope | HttpServer | Exclude<R, HttpServerRequest>>;
  <E, R, App extends Default<any, any>>(httpApp: Default<E, R>, middleware: Applied<App, E, R>): Effect<void, never, any>;
}

type Address = UnixAddress | TcpAddress

declare const addressFormattedWith: <A, E, R>(effect: (address: string) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, HttpServer | R>

declare const addressWith: <A, E, R>(effect: (address: Address) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, HttpServer | R>

declare const formatAddress: (address: Address) => string

declare const logAddress: Effect.Effect<void, never, HttpServer>

interface TcpAddress {
  readonly _tag: "TcpAddress";
  readonly hostname: string;
  readonly port: number;
}

interface UnixAddress {
  readonly _tag: "UnixAddress";
  readonly path: string;
}

declare const withLogAddress: <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R | Exclude<HttpServer, A>>

declare const HttpServer: Tag<HttpServer, HttpServer>

declare const make: (options: {
  readonly address: Address;
  readonly serve: (httpApp: App.Default<unknown>, middleware?: Middleware.HttpMiddleware) => Effect.Effect<void, never, Scope.Scope>;
}) => HttpServer

declare const layerContext: Layer.Layer<HttpPlatform | FileSystem | Generator | Path>

declare const layerTestClient: Layer.Layer<Client.HttpClient, never, Client.HttpClient | HttpServer>

interface HttpServer {
  readonly [TypeId]: typeof TypeId;
  readonly address: Address;
  readonly serve: {
    <E, R>(httpApp: Default<E, R>): Effect<void, never, Scope | Exclude<R, HttpServerRequest>>;
    <E, R, App extends Default<any, any>>(httpApp: Default<E, R>, middleware: Applied<App, E, R>): Effect<void, never, Scope | Exclude<R, HttpServerRequest>>;
  };
}

interface ServeOptions {
  readonly respond: boolean;
}

declare const TypeId: unique symbol

type TypeId = typeof TypeId