utils

export type MatchInput<P extends string, S extends Schema.Schema.All, A = never, E = never, R = never> =
  | Route.Route<P, S>
  | RouteGuard.RouteGuard<Route.Route<P, S>, A, E, R>

export type Any = MatchInput<any, any, any, any, any> | MatchInput<any, never, any, any, any>

export type Concat<L extends MatchInput.Any, R extends MatchInput.Any> = [
  MatchInput.Schema<L>,
  MatchInput.Schema<R>
] extends [infer LSchema, infer RSchema]
  ? MatchInput<
      _Path.PathJoin<[MatchInput.Path<L>, MatchInput.Path<R>]>,
      Schema.Schema<
        Types.Simplify<Schema.Schema.Type<LSchema> & Schema.Schema.Type<RSchema>>,
        Types.Simplify<Schema.Schema.Encoded<LSchema> & Schema.Schema.Encoded<RSchema>>,
        Schema.Schema.Context<LSchema> | Schema.Schema.Context<RSchema>
      >,
      MatchInput.Success<R>,
      | Exclude<MatchInput.Error<L> | MatchInput.Error<R>, Route.RouteDecodeError<any>>
      | Route.RouteDecodeError<Route.Route.Concat<MatchInput.Route<L>, MatchInput.Route<R>>>,
      MatchInput.Context<L> | MatchInput.Context<R>
    >
  : never

export type Context<T> =
  T extends Route.Route<infer _P, infer _S>
    ? Route.Route.Context<T>
    : T extends RouteGuard.RouteGuard<Route.Route<infer _P, infer _S>, infer _A, infer _E, infer R>
      ? R
      : never

export type Error<T> =
  T extends Route.Route<infer _P, infer _S>
    ? Route.RouteDecodeError<T>
    : T extends RouteGuard.RouteGuard<Route.Route<infer _P, infer _S>, infer _A, infer E, infer _R>
      ? E
      : never

export type HasParams<T> = Route<T> extends Route.Route<infer P, infer _> ? _Path.HasParams<P> : false

export type HasPathParams<T> =
  Route<T> extends Route.Route<infer P, infer _>
    ? P extends `${infer P2}\\?${infer _}`
      ? _Path.HasParams<P2>
      : _Path.HasParams<P>
    : false

export type HasQueryParams<T> =
  Route<T> extends Route.Route<infer P, infer _>
    ? P extends `${infer _}\\?${infer P2}`
      ? _Path.HasParams<`\\?${P2}`>
      : false
    : false

export type ParamsOf<T> = Route.Route.Params<Route<T>>

export type Path<T> = _Path.PathJoin<[Route.Route.Path<Route<T>>]>

export type PathSchema<T> = Route.Route.PathSchema<MatchInput.Route<T>>

export type QuerySchema<T> = Route.Route.QuerySchema<MatchInput.Route<T>>

export type Route<T> =
  T extends Route.Route<any, any>
    ? T
    : T extends RouteGuard.RouteGuard<infer U, infer _A, infer _E, infer _R>
      ? U
      : never

export type Schema<T> = Route.Route.Schema<MatchInput.Route<T>>

export type Success<T> =
  T extends Route.Route<infer _P, infer _S>
    ? Route.Route.Type<T>
    : T extends RouteGuard.RouteGuard<Route.Route<infer _P, infer _S>, infer A, infer _E, infer _R>
      ? A
      : never

export declare function asRouteGuard<I extends MatchInput.Any>(
  input: I
): RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>

export declare function concat<L extends MatchInput.Any, R extends MatchInput.Any>(
  left: L,
  right: R
): RouteGuard.RouteGuard<
  Route.Route.Concat<MatchInput.Route<L>, MatchInput.Route<R>>,
  MatchInput.Success<L> & MatchInput.Success<R>,
  MatchInput.Error<L> | MatchInput.Error<R>,
  MatchInput.Context<L> | MatchInput.Context<R>
>

export declare const filter: {
  <I extends MatchInput.Any>(
    f: (a: MatchInput.Success<I>) => boolean
  ): (
    input: I
  ) => RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>
  <I extends MatchInput.Any>(
    input: I,
    f: (a: MatchInput.Success<I>) => boolean
  ): RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>
}

export declare const filterMap: {
  <I extends MatchInput.Any, A>(
    f: (a: MatchInput.Success<I>) => Option.Option<A>
  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
  <I extends MatchInput.Any, A>(
    input: I,
    f: (a: MatchInput.Success<I>) => Option.Option<A>
  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
}

export declare const flatMap: {
  <I extends MatchInput.Any, A, E2, R2>(
    guard: Guard<MatchInput.Success<I>, A, E2, R2>
  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
  <I extends MatchInput.Any, A, E2, R2>(
    input: I,
    guard: Guard<MatchInput.Success<I>, A, E2, R2>
  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
}

export declare function getPath<I extends MatchInput.Any>(input: I): MatchInput.Path<I>

export declare function getPathSchema<I extends MatchInput.Any>(input: I): MatchInput.PathSchema<I>

export declare function getQuerySchema<I extends MatchInput.Any>(input: I): MatchInput.QuerySchema<I>

export declare function getRoute<I extends MatchInput.Any>(input: I): MatchInput.Route<I>

export declare function getSchema<I extends MatchInput.Any>(input: I): MatchInput.Schema<I>

export declare const map: {
  <I extends MatchInput.Any, A>(
    f: (a: MatchInput.Success<I>) => A
  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
  <I extends MatchInput.Any, A>(
    input: I,
    f: (a: MatchInput.Success<I>) => A
  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
}

export declare const mapEffect: {
  <I extends MatchInput.Any, A, E2, R2>(
    f: (a: MatchInput.Success<I>) => Effect.Effect<A, E2, R2>
  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
  <I extends MatchInput.Any, A, E2, R2>(
    input: I,
    f: (a: MatchInput.Success<I>) => Effect.Effect<A, E2, R2>
  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
}