export declare const serve: {
  (): <R, E>(httpApp: App.Default<E, R>) => Layer.Layer<never, never, Server | Exclude<R, any>>
  <R, E, App extends App.Default<any, any>>(
    middleware: Middleware.Middleware.Applied<App, E, R>
  ): (httpApp: App.Default<E, R>) => Layer.Layer<never, never, Server>
  <R, E>(httpApp: App.Default<E, R>): Layer.Layer<never, never, Server | Exclude<R, any>>
  <R, E, App extends App.Default<any, any>>(
    httpApp: App.Default<E, R>,
    middleware: Middleware.Middleware.Applied<App, E, R>
  ): Layer.Layer<never, never, Server>
}

export declare const serveEffect: {
  (): <R, E>(httpApp: App.Default<E, R>) => Effect.Effect<void, never, any>
  <R, E, App extends App.Default<any, any>>(
    middleware: Middleware.Middleware.Applied<App, E, R>
  ): (httpApp: App.Default<E, R>) => Effect.Effect<void, never, any>
  <R, E>(httpApp: App.Default<E, R>): Effect.Effect<void, never, any>
  <R, E, App extends App.Default<any, any>>(
    httpApp: App.Default<E, R>,
    middleware: Middleware.Middleware.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: <R, E, A>(
  effect: (address: string) => Effect.Effect<A, E, R>
) => Effect.Effect<A, E, Server | R>

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

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

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

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

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

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

export interface ServeOptions {
  readonly respond: boolean
}

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

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId