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;