export declare const serve: {
  (): <E, R>(
    httpApp: App.Default<E, R>
  ) => Layer.Layer<never, never, HttpServer | Exclude<R, ServerRequest.HttpServerRequest | Scope.Scope>>
  <E, R, App extends App.Default<any, any>>(
    middleware: Middleware.HttpMiddleware.Applied<App, E, R>
  ): (
    httpApp: App.Default<E, R>
  ) => Layer.Layer<
    never,
    never,
    HttpServer | Exclude<Effect.Effect.Context<App>, ServerRequest.HttpServerRequest | Scope.Scope>
  >
  <E, R>(
    httpApp: App.Default<E, R>
  ): Layer.Layer<never, never, HttpServer | Exclude<R, ServerRequest.HttpServerRequest | Scope.Scope>>
  <E, R, App extends App.Default<any, any>>(
    httpApp: App.Default<E, R>,
    middleware: Middleware.HttpMiddleware.Applied<App, E, R>
  ): Layer.Layer<
    never,
    never,
    HttpServer | Exclude<Effect.Effect.Context<App>, ServerRequest.HttpServerRequest | Scope.Scope>
  >
}

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

export type Address = UnixAddress | TcpAddress

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

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

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

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

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

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

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

export declare const HttpServer: Context.Tag<HttpServer, HttpServer>

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

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

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

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

export interface ServeOptions {
  readonly respond: boolean
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId