HttpLayerRouter

declare class RouterConfig extends any {
  constructor();
}

declare function addHttpApi<Id extends string, Groups extends Any, E, R>(api: HttpApi<Id, Groups, E, R>, options?: {
  readonly openapiPath?: `/${string}`;
}): Layer<never, never, Generator | FileSystem | HttpPlatform | Path | HttpRouter | R | ToService<Id, Groups> | ErrorContext<Groups>>

declare function add<E, R>(method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "*", path: PathInput, handler: Effect<HttpServerResponse, E, R> | (request: HttpServerRequest) => Effect<HttpServerResponse, E, R>, options?: {
  readonly uninterruptible?: boolean;
}): Layer<never, never, HttpRouter | From<"Requires", Exclude<R, Provided>> | From<"Error", E>>

declare function addAll<Routes extends readonly Array<Route<any, any>>, EX = never, RX = never>(routes: Routes | Effect<Routes, EX, RX>, options?: {
  readonly prefix?: string;
}): Layer<never, EX, HttpRouter | Exclude<RX, Scope> | From<"Requires", Exclude<Context<Routes[number]>, Provided>> | From<"Error", Error<Routes[number]>>>

declare const HttpRouter: Tag<HttpRouter, HttpRouter>

interface HttpRouter {
  readonly [TypeId]: typeof TypeId;
  readonly add: <E, R>(method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "*", path: PathInput, handler: Effect<HttpServerResponse, E, R> | (request: HttpServerRequest) => Effect<HttpServerResponse, E, R>, options?: {
    readonly uninterruptible?: boolean;
  }) => Effect<void, never, From<"Requires", Exclude<R, Provided>> | From<"Error", E>>;
  readonly addAll: <Routes extends readonly Array<Route<any, any>>>(routes: Routes) => Effect<void, never, From<"Requires", Exclude<Context<Routes[number]>, Provided>> | From<"Error", Error<Routes[number]>>>;
  readonly addGlobalMiddleware: <E, R>(middleware: (effect: Effect<HttpServerResponse, unhandled>) => Effect<HttpServerResponse, E, R> & unhandled extends E ? unknown : "You cannot handle any errors") => Effect<void, never, From<"GlobalRequires", Exclude<R, GlobalProvided>> | From<"GlobalError", Exclude<E, unhandled>>>;
  readonly asHttpEffect: () => Effect<HttpServerResponse, unknown, Scope | HttpServerRequest>;
  readonly prefixed: (prefix: string) => HttpRouter;
}

declare const layer: Layer.Layer<HttpRouter>

declare const make: Effect<any, unknown, unknown>

declare function toHttpEffect<A, E, R>(appLayer: Layer<A, E, R>): Effect<Effect<HttpServerResponse, RouteNotFound | Only<"Error", R> | Only<"GlobalRequires", R>, Scope | HttpServerRequest | Only<"GlobalRequires", R> | Only<"Requires", R>>, Without<E>, Scope | Exclude<Without<R>, HttpRouter>>

declare const TypeId: unique symbol

type TypeId = typeof TypeId

declare function use<A, E, R>(f: (router: HttpRouter) => Effect<A, E, R>): Layer<never, E, HttpRouter | Exclude<R, Scope>>

declare function cors(options?: {
  readonly allowedHeaders?: readonly Array<string>;
  readonly allowedMethods?: readonly Array<string>;
  readonly allowedOrigins?: readonly Array<string> | Predicate<string>;
  readonly credentials?: boolean;
  readonly exposedHeaders?: readonly Array<string>;
  readonly maxAge?: number;
}): Layer<never, never, HttpRouter>

declare const disableLogger: Layer.Layer<never>

declare const middleware: middleware.Make<never, never> & <Config extends {
  handles?: any;
  provides?: any;
} = {}>() => middleware.Make<Config extends {
  provides: infer R;
} ? R : never, Config extends {
  handles: infer E;
} ? E : never>

interface Middleware<Config extends {
  error: any;
  handles: any;
  layerError: any;
  layerRequires: any;
  provides: any;
  requires: any;
}> {
  readonly [MiddlewareTypeId]: Config;
  readonly combine: <Config2 extends {
    error: any;
    handles: any;
    layerError: any;
    layerRequires: any;
    provides: any;
    requires: any;
  }>(other: Middleware<Config2>) => Middleware<{
    error: Config2["error"] | Exclude<Config["error"], Config2["handles"]>;
    handles: Config2["handles"] | Config["handles"];
    layerError: Config["layerError"] | Config2["layerError"];
    layerRequires: Config["layerRequires"] | Config2["layerRequires"];
    provides: Config["provides"] | Config2["provides"];
    requires: Exclude<Config["requires"], Config2["provides"]> | Config2["requires"];
  }>;
  readonly layer: [Config["requires"]] extends [never] ? Layer<From<"Requires", Config["provides"]>, Config["layerError"], Config["layerRequires"] | From<"Requires", any[any]> | From<"Error", Config["error"]>> : "Need to .combine(middleware) that satisfy the missing request dependencies";
}

declare const MiddlewareTypeId: unique symbol

type MiddlewareTypeId = typeof MiddlewareTypeId

interface unhandled {
  readonly _: typeof _;
}

interface RouteContext {
  readonly [RouteContextTypeId]: typeof RouteContextTypeId;
  readonly params: Readonly<Record<string, string | undefined>>;
  readonly route: Route<unknown, unknown>;
}

type PathInput = `/${string}` | "*"

declare const prefixPath: {
  (prefix: string): (self: string) => string;
  (self: string, prefix: string): string;
}

declare const FindMyWay: any

type GlobalProvided = HttpServerRequest.HttpServerRequest | Scope.Scope

type Provided = HttpServerRequest.HttpServerRequest | Scope.Scope | HttpServerRequest.ParsedSearchParams | RouteContext

interface Request<Kind extends string, T> {
  readonly _: typeof _;
  readonly kind: Kind;
  readonly type: T;
}

declare const prefixRoute: {
  (prefix: string): <E, R>(self: Route<E, R>) => Route<E, R>;
  <E, R>(self: Route<E, R>, prefix: string): Route<E, R>;
}

declare function route<E, R>(method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "*", path: PathInput, handler: Effect<HttpServerResponse, E, R> | (request: HttpServerRequest) => Effect<HttpServerResponse, E, R>, options?: {
  readonly uninterruptible?: boolean;
}): Route<E, Exclude<R, Provided>>

interface Route<E = never, R = never> {
  readonly [RouteTypeId]: typeof RouteTypeId;
  readonly handler: Effect<HttpServerResponse, E, R>;
  readonly method: HttpMethod | "*";
  readonly path: PathInput;
  readonly prefix: Option<string>;
  readonly uninterruptible: boolean;
}

declare const RouteTypeId: unique symbol

type RouteTypeId = typeof RouteTypeId

declare const params: Effect.Effect<Readonly<Record<string, string | undefined>>, never, RouteContext>

declare const RouteContext: Tag<RouteContext, RouteContext>

declare const schemaJson: <R, I extends Partial<{
  readonly body: any;
  readonly cookies: Readonly<Record<string, string | undefined>>;
  readonly headers: Readonly<Record<string, string | undefined>>;
  readonly method: Method.HttpMethod;
  readonly pathParams: Readonly<Record<string, string | undefined>>;
  readonly searchParams: Readonly<Record<string, string | ReadonlyArray<string> | undefined>>;
  readonly url: string;
}>, A>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, RouteContext | R | ServerRequest.HttpServerRequest | ServerRequest.ParsedSearchParams>

declare const schemaNoBody: <R, I extends Partial<{
  readonly cookies: Readonly<Record<string, string | undefined>>;
  readonly headers: Readonly<Record<string, string | undefined>>;
  readonly method: Method.HttpMethod;
  readonly pathParams: Readonly<Record<string, string | undefined>>;
  readonly searchParams: Readonly<Record<string, string | ReadonlyArray<string> | undefined>>;
  readonly url: string;
}>, A>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext | ServerRequest.HttpServerRequest | ServerRequest.ParsedSearchParams>

declare const schemaParams: <A, I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext | ServerRequest.ParsedSearchParams>

declare const schemaPathParams: <A, I extends Readonly<Record<string, string | undefined>>, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext>

declare function serve<A, E, R, HE, HR = Only<"Requires", R> | Only<"GlobalRequires", R>>(appLayer: Layer<A, E, R>, options?: {
  readonly disableListenLog?: boolean;
  readonly disableLogger?: boolean;
  readonly middleware?: (effect: Effect<HttpServerResponse, RouteNotFound | Only<"Error", R> | Only<"GlobalError", R>, Scope | HttpServerRequest | Only<"Requires", R> | Only<"GlobalRequires", R>>) => Effect<HttpServerResponse, HE, HR>;
  readonly routerConfig?: any;
}): Layer<A, Without<E>, HttpServer | Exclude<Without<R>, HttpRouter> | Exclude<Exclude<HR, GlobalProvided>, HttpRouter>>

declare function toWebHandler<A, E, R extends HttpRouter | Request<"Requires", any> | Request<"GlobalRequires", any> | Request<"Error", any> | Request<"GlobalError", any>, HE, HR = Exclude<Only<"Requires", R>, A> | Exclude<Only<"GlobalRequires", R>, A>>(appLayer: Layer<A, E, R>, options?: {
  readonly disableLogger?: boolean;
  readonly memoMap?: MemoMap;
  readonly middleware?: (effect: Effect<HttpServerResponse, RouteNotFound | Only<"Error", R> | Only<"GlobalError", R>, Scope | HttpServerRequest | Only<"Requires", R> | Only<"GlobalRequires", R>>) => Effect<HttpServerResponse, HE, HR>;
  readonly routerConfig?: any;
}): {
  readonly dispose: () => Promise<void>;
  readonly handler: [HR] extends [never] ? (request: Request, context?: Context<never>) => Promise<Response> : (request: Request, context: Context<HR>) => Promise<Response>;
}