utils

export interface CurrentParams<I extends Router.MatchInput.Any> {
  readonly params: Router.MatchInput.Success<I>
  readonly queryParams: URLSearchParams
}

export type Handler<Route extends Router.MatchInput.Any, E, R> = Effect.Effect<
  ServerResponse,
  E,
  R | Router.CurrentRoute | CurrentParams<Route> | Navigation.Navigation | ServerRequest
>

export interface RouteHandler<Route extends Router.MatchInput.Any, E, R> {
  readonly method: Method | "*"
  readonly route: Route
  readonly handler: Handler<Route, E, R>
}

export type Any = RouteHandler<Router.MatchInput.Any, any, any>

export type Context<T> =
  T extends RouteHandler<infer I, any, infer R>
    ? Exclude<Exclude<R, CurrentParams<I>> | Router.MatchInput.Context<I>, Navigation.Navigation>
    : never

export type Error<T> =
  T extends RouteHandler<infer I, infer E, any> ? E | Router.MatchInput.Error<I> | RouteNotMatched : never

export declare class RouteNotMatched

export declare const all: <I extends Router.MatchInput.Any, E, R>(
  route: I,
  handler: Handler<I, E, R>
) => RouteHandler<I, E, R>

export declare const catchAll: {
  <E2, E3, R3>(
    onError: (error: E2) => Effect.Effect<ServerResponse, E3, R3>
  ): <R extends Router.MatchInput.Any, R2>(handler: RouteHandler<R, E2, R2>) => RouteHandler<R, E3, R3 | R2>
  <R extends Router.MatchInput.Any, E2, R2, E3, R3>(
    handler: RouteHandler<R, E2, R2>,
    onError: (error: E2) => Effect.Effect<ServerResponse, E3, R3>
  ): RouteHandler<R, E3, R2 | R3>
}

export declare const catchAllCause: {
  <E2, E3, R3>(
    onCause: (cause: Cause.Cause<E2>) => Effect.Effect<ServerResponse, E3, R3>
  ): <R extends Router.MatchInput.Any, R2>(handler: RouteHandler<R, E2, R2>) => RouteHandler<R, E3, R3 | R2>
  <R extends Router.MatchInput.Any, E2, R2, E3, R3>(
    handler: RouteHandler<R, E2, R2>,
    onCause: (cause: Cause.Cause<E2>) => Effect.Effect<ServerResponse, E3, R3>
  ): RouteHandler<R, E3, R2 | R3>
}

export declare const catchTag: {
  <E2, const Tag extends E2 extends { readonly _tag: string } ? E2["_tag"] : never, E3, R3>(
    tag: Tag,
    onError: (error: Extract<E2, { readonly _tag: Tag }>) => Effect.Effect<ServerResponse, E3, R3>
  ): <R extends Router.MatchInput.Any, R2>(
    handler: RouteHandler<R, E2, R2>
  ) => RouteHandler<R, E3 | Exclude<E2, { readonly _tag: Tag }>, R3 | R2>
  <
    R extends Router.MatchInput.Any,
    E2,
    R2,
    const Tag extends E2 extends { readonly _tag: string } ? E2["_tag"] : never,
    E3,
    R3
  >(
    handler: RouteHandler<R, E2, R2>,
    tag: Tag,
    onError: (error: Extract<E2, { readonly _tag: Tag }>) => Effect.Effect<ServerResponse, E3, R3>
  ): RouteHandler<R, E3 | Exclude<E2, { readonly _tag: Tag }>, R2 | R3>
}

export declare function currentParamsLayer<I extends Router.MatchInput.Any>(
  params: CurrentParams<I>
): Layer.Layer<CurrentParams<I>>

export declare const delete: <I extends Router.MatchInput.Any, E, R>(route: I, handler: Handler<I, E, R>) => RouteHandler<I, E, R>

export declare const get: <I extends Router.MatchInput.Any, E, R>(
  route: I,
  handler: Handler<I, E, R>
) => RouteHandler<I, E, R>

export declare function getCurrentParams<I extends Router.MatchInput.Any>(
  _route: I
): Effect.Effect<CurrentParams<I>, never, CurrentParams<I>>

export declare const getCurrentParamsOption: Effect.Effect<
  Option.Option<CurrentParams<Router.MatchInput.Any>>,
  never,
  never
>

export declare function getUrlFromServerRequest(request: ServerRequest): URL

export declare const head: <I extends Router.MatchInput.Any, E, R>(
  route: I,
  handler: Handler<I, E, R>
) => RouteHandler<I, E, R>

export declare const make: (
  method: Method | "*"
) => <I extends Router.MatchInput.Any, E, R>(route: I, handler: Handler<I, E, R>) => RouteHandler<I, E, R>

export declare const options: <I extends Router.MatchInput.Any, E, R>(
  route: I,
  handler: Handler<I, E, R>
) => RouteHandler<I, E, R>

export declare const patch: <I extends Router.MatchInput.Any, E, R>(
  route: I,
  handler: Handler<I, E, R>
) => RouteHandler<I, E, R>

export declare const post: <I extends Router.MatchInput.Any, E, R>(
  route: I,
  handler: Handler<I, E, R>
) => RouteHandler<I, E, R>

export declare const put: <I extends Router.MatchInput.Any, E, R>(
  route: I,
  handler: Handler<I, E, R>
) => RouteHandler<I, E, R>

export declare function toHttpApp<I extends RouteHandler.Any>(
  { handler, route: input }: I,
  parent?: Router.CurrentRoute
): Default<RouteHandler.Error<I>, RouteHandler.Context<I>>

export declare function toPlatformRoute<I extends RouteHandler.Any>(
  handler: I
): <E, R>(
  self: PlatformRouter.Router<E, R>
) => PlatformRouter.Router<E | RouteHandler.Error<I>, R | RouteHandler.Context<I>>