export declare const serve: {
  (): <E, R>(httpApp: App.Default<E, R>) => Layer.Layer<never, never, HttpServer | Exclude<R, any>>
  <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>
  <E, R>(httpApp: App.Default<E, R>): Layer.Layer<never, never, HttpServer | Exclude<R, any>>
  <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>
}

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

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 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