utils

export declare const BigInt: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: bigint }, { readonly [_ in Name]: string }, never>>

export declare const Order: Ord.Order<Route.Any>

export type QueryParamsFromObject<O extends Readonly<Record<string, Route.Any>>> = Path.QueryParams<
  U.ListOf<
    {
      readonly [K in keyof O]: `${Extract<K, string | number>}=${Route.Path<O[K]>}`
    }[keyof O]
  >
>

export type QueryParamsFromObjectSchema<O extends Readonly<Record<string, Route.Any>>> = Sch.Schema<
  Types.Simplify<
    Types.UnionToIntersection<
      {
        readonly [K in keyof O]: Route.Type<O[K]>
      }[keyof O]
    >
  >,
  Types.Simplify<
    Types.UnionToIntersection<
      {
        readonly [K in keyof O]: Route.Encoded<O[K]>
      }[keyof O]
    >
  >,
  Route.Context<O[keyof O]>
>

export interface Route<P extends string, S extends Sch.Schema.All = never> extends Pipeable {
  readonly [RouteTypeId]: Route.Variance<P, S>

  /**
   * @since 5.0.0
   */
  readonly routeAst: AST.AST

  /**
   * @since 5.0.0
   */
  readonly routeOptions: RouteOptions

  /**
   * @since 5.0.0
   */
  readonly path: Path.PathJoin<[P]>

  /**
   * @since 5.0.0
   */
  readonly schema: Route.SchemaFromInput<P, S>

  /**
   * @since 5.0.0
   */
  readonly pathSchema: Route.PathSchemaFromInput<P, S>

  /**
   * @since 5.0.0
   */
  readonly querySchema: Route.QuerySchemaFromInput<P, S>

  /**
   * @since 5.0.0
   */
  readonly match: (path: string) => Option.Option<Path.ParamsOf<P>>

  /**
   * @since 5.0.0
   */
  readonly interpolate: <P2 extends Path.ParamsOf<P>>(params: P2) => Path.Interpolate<P, P2>

  /**
   * @since 5.0.0
   */
  readonly concat: <R2 extends ReadonlyArray<Route.Any>>(...right: R2) => Route.ConcatAll<[Route<P, S>, ...R2]>

  /**
   * @since 5.0.0
   */
  readonly optional: () => Route<
    Path.Optional<P>,
    [S] extends [never]
      ? Sch.Schema<
          Types.Simplify<Optional<Sch.Schema.Type<Route.SchemaFromPath<Path.Optional<P>>>>>,
          Types.Simplify<Optional<Sch.Schema.Encoded<Route.SchemaFromPath<Path.Optional<P>>>>>,
          never
        >
      : Sch.Schema<
          Types.Simplify<Optional<Sch.Schema.Type<S>>>,
          Types.Simplify<Optional<Sch.Schema.Encoded<S>>>,
          Sch.Schema.Context<S>
        >
  >

  /**
   * @since 5.0.0
   */
  readonly oneOrMore: () => Route<
    Path.OneOrMore<P>,
    [S] extends [never]
      ? never
      : Sch.Schema<
          readonly [Types.Simplify<Sch.Schema.Type<S>>, ...Array<Types.Simplify<Sch.Schema.Type<S>>>],
          readonly [Types.Simplify<Sch.Schema.Encoded<S>>, ...Array<Types.Simplify<Sch.Schema.Encoded<S>>>],
          Sch.Schema.Context<S>
        >
  >

  /**
   * @since 5.0.0
   */
  readonly zeroOrMore: () => Route<
    Path.ZeroOrMore<P>,
    [S] extends [never]
      ? never
      : Sch.Schema<
          ReadonlyArray<Types.Simplify<Sch.Schema.Type<S>>>,
          ReadonlyArray<Types.Simplify<Sch.Schema.Encoded<S>>>,
          Sch.Schema.Context<S>
        >
  >

  /**
   * @since 5.0.0
   */
  readonly prefix: <P2 extends string>(prefix: P2) => Route<Path.Prefix<P2, P>, S>
}

export interface Variance<P extends string, S extends Sch.Schema.All> {
  readonly _P: Types.Covariant<P>
  readonly _S: Types.Covariant<S>
}

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

export type Concat<I extends Route.Any, I2 extends Route.Any> =
  Route<
    Path.PathJoin<[PathWithoutQuery<I>, PathWithoutQuery<I2>, ConcatQuery<Query<I>, Query<I2>>]>,
    ConcatSchemas<Schema<I>, Schema<I2>>
  > extends Route<infer P, infer S>
    ? Route<P, S>
    : never

export type ConcatAll<Routes extends ReadonlyArray<any>> = Routes extends readonly [infer Head extends Route.Any]
  ? Head extends Route.Any
    ? Head
    : never
  : Routes extends readonly [infer Head extends Route.Any, ...infer Tail]
    ? Concat<Head, ConcatAll<Tail> extends infer R2 extends Route.Any ? R2 : never> extends infer R extends Route.Any
      ? R
      : never
    : never

export type ConcatQuery<Q1 extends string, Q2 extends string> = [Q1, Q2] extends ["", ""]
  ? ""
  : [Q1] extends [""]
    ? `\\?${RemoveQuestionMark<Q2>}`
    : [Q2] extends [""]
      ? `\\?${RemoveQuestionMark<Q1>}`
      : `\\?${RemoveQuestionMark<Q1>}&${RemoveQuestionMark<Q2>}`

export type ConcatSchemas<S1 extends Sch.Schema.All, S2 extends Sch.Schema.All> = [S1] extends [never]
  ? S2
  : [S2] extends [never]
    ? S1
    : Sch.Schema<
        MergeSchemaTypes<Sch.Schema.Type<S1>, Sch.Schema.Type<S2>>,
        MergeSchemaTypes<Sch.Schema.Encoded<S1>, Sch.Schema.Encoded<S2>>,
        Sch.Schema.Context<S1> | Sch.Schema.Context<S2>
      >

export type Context<R extends Route.Any> = Sch.Schema.Context<R>

export type Encoded<R extends Route.Any> = Sch.Schema.Encoded<R["schema"]>

export type Interpolate<R extends Route.Any, P extends Route.Params<R>> = Path.Interpolate<Route.Path<R>, P>

export type Params<R extends Route.Any> = Path.ParamsOf<Route.Path<R>>

export type ParamsAreOptional<R extends Route.Any> = [keyof Params<R>] extends [never]
  ? true
  : KeysAreOptional<Params<R>>

export type ParamsList<R extends Route.Any> = Path.ParamsList<Route.Path<R>>

export type Path<T> = [T] extends [never] ? never : T extends Route<infer P, infer _> ? P : never

export type PathSchema<T> = [T] extends [never]
  ? never
  : T extends Route<infer P, infer S>
    ? PathSchemaFromInput<P, S>
    : never

export type PathSchemaFromInput<P extends string, S extends Sch.Schema.All = never> = [S] extends [never]
  ? PathSchema.ExtractKeys<
      SchemaFromPath<P>,
      PathSchema.GetPathTypeKeys<PathSchema.GetPath<P>>,
      PathSchema.GetPathEncodedKeys<PathSchema.GetPath<P>>
    >
  : PathSchema.ExtractKeys<
      S,
      PathSchema.GetPathTypeKeys<PathSchema.GetPath<P>>,
      PathSchema.GetPathEncodedKeys<PathSchema.GetPath<P>>
    >

export type PathWithoutQuery<T> = Path<T> extends `${infer P}\\?${infer _}` ? P : Path<T>

export type Query<T> =
  Path<T> extends `${string}\\?${infer Q}` ? `\\?${Q}` : Path<T> extends `${string}?${infer Q}` ? `?${Q}` : ""

export type QueryParams<R extends Route.Any> = Path.QueryParams<Route.Path<R>>

export type QuerySchema<T> = [T] extends [never]
  ? never
  : T extends Route<infer P, infer S>
    ? QuerySchemaFromInput<P, S>
    : never

export type QuerySchemaFromInput<P extends string, S extends Sch.Schema.All = never> = [S] extends [never]
  ? QuerySchema.ExtractKeys<
      SchemaFromPath<QuerySchema.GetQuery<P>>,
      QuerySchema.GetQueryTypeKeys<QuerySchema.GetQuery<P>>,
      QuerySchema.GetQueryEncodedKeys<QuerySchema.GetQuery<P>>
    >
  : QuerySchema.ExtractKeys<
      S,
      QuerySchema.GetQueryTypeKeys<QuerySchema.GetQuery<P>>,
      QuerySchema.GetQueryEncodedKeys<QuerySchema.GetQuery<P>>
    >

export type Schema<T> = [T] extends [never] ? never : T extends Route<infer P, infer S> ? SchemaFromInput<P, S> : never

export type SchemaFromInput<P extends string, S extends Sch.Schema.All = never> = [S] extends [never]
  ? SchemaFromPath<P>
  : S

export type SchemaFromPath<P extends string> = Sch.Schema<Path.ParamsOf<P>>

export type Type<R extends Route.Any> = Sch.Schema.Type<R["schema"]>

export type UpdatePath<T, P extends string> = T extends Route<infer _, infer S> ? Route<P, S> : never

export type UpdateSchema<T, S extends Sch.Schema.All> = T extends Route<infer P, infer _> ? Route<P, S> : never

export type ExtractKeys<S extends Sch.Schema.All, TK extends PropertyKey, EK extends PropertyKey> =
  Sch.Schema<
    Types.Simplify<Pick<Sch.Schema.Type<S>, TK>>,
    Types.Simplify<Pick<Sch.Schema.Encoded<S>, EK>>,
    Sch.Schema.Context<S>
  > extends Sch.Schema<infer A, infer I, infer R>
    ? Sch.Schema<A, I, R>
    : never

export type GetPath<P extends string> = P extends `${infer R}\\?${infer _}` ? R : P

export type GetPathEncodedKeys<P extends string> = keyof Sch.Schema.Encoded<SchemaFromPath<P>>

export type GetPathTypeKeys<P extends string> = keyof Sch.Schema.Type<SchemaFromPath<P>>

export type ExtractKeys<S extends Sch.Schema.All, TK extends PropertyKey, EK extends PropertyKey> = [
  Sch.Schema<
    Types.Simplify<Pick<Sch.Schema.Type<S>, TK>>,
    Types.Simplify<Pick<Sch.Schema.Encoded<S>, EK>>,
    Sch.Schema.Context<S>
  >
] extends [Sch.Schema<infer A, infer I, infer R>]
  ? Sch.Schema<A, I, R>
  : never

export type GetQuery<P extends string> = P extends `${infer _}\\?${infer R}` ? `\\?${R}` : never

export type GetQueryEncodedKeys<P extends string> = keyof Sch.Schema.Encoded<SchemaFromPath<P>>

export type GetQueryTypeKeys<P extends string> = keyof Sch.Schema.Type<SchemaFromPath<P>>

export declare class RouteDecodeError<R> {
  constructor(props: { readonly route: R; readonly issue: ParseIssue })
}

toJSON(): unknown

toString(): string

export declare class RouteEncodeError<R>

toJSON(): unknown

toString()

export type RouteFromQueryParamsObject<O extends Readonly<Record<string, Route.Any>>> =
  Route<QueryParamsFromObject<O>, QueryParamsFromObjectSchema<O>> extends Route<
    infer P,
    Sch.Schema<infer A, infer I, infer R>
  >
    ? Route<P, Sch.Schema<A, I, R>>
    : never

export interface RouteOptions {
  readonly end: boolean
}

export declare const RouteTypeId: typeof RouteTypeId

export type RouteTypeId = typeof RouteTypeId

export declare const addTag: {
  <const T extends string>(
    tag: T
  ): <R extends Route.Any>(
    route: R
  ) => Route.UpdateSchema<R, Sch.Schema<Route.Type<R> & { readonly _tag: T }, Route.Encoded<R>, Route.Context<R>>>
  <R extends Route.Any, const T extends string>(
    route: R,
    tag: T
  ): Route.UpdateSchema<R, Sch.Schema<Route.Type<R> & { readonly _tag: T }, Route.Encoded<R>, Route.Context<R>>>
}

export declare const attachPropertySignature: {
  <K extends string, V extends symbol | SchemaAST.LiteralValue>(
    key: K,
    value: V
  ): <R extends Route.Any>(
    route: R
  ) => Route.UpdateSchema<R, Sch.Schema<Route.Type<R> & { readonly [_ in K]: V }, Route.Encoded<R>, Route.Context<R>>>
  <R extends Route.Any, K extends string, V extends symbol | SchemaAST.LiteralValue>(
    route: R,
    key: K,
    value: V
  ): Route.UpdateSchema<R, Sch.Schema<Route.Type<R> & { readonly [_ in K]: V }, Route.Encoded<R>, Route.Context<R>>>
}

export declare const base64Url: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: Uint8Array }, { readonly [_ in Name]: string }, never>>

export declare const bigDecimal: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: BigDecimal }, { readonly [_ in Name]: string }, never>>

export declare const boolean: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: boolean }, { readonly [_ in Name]: string }, never>>

export declare const concat: {
  <R extends Route.Any>(right: R): <L extends Route.Any>(left: L) => Route.Concat<L, R>
  <L extends Route.Any, R extends Route.Any>(left: L, right: R): Route.Concat<L, R>
}

export declare const date: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: Date }, { readonly [_ in Name]: string }, never>>

export declare const decode: {
  (
    path: string
  ): <R extends Route.Any>(
    route: R
  ) => Effect.Effect<Route.Type<R>, NoSuchElementException | RouteDecodeError<R>, Route.Context<R>>
  <R extends Route.Any>(
    route: R,
    path: string
  ): Effect.Effect<Route.Type<R>, NoSuchElementException | RouteDecodeError<R>, Route.Context<R>>
}

export declare const decode_: {
  <R extends Route.Any>(
    route: R
  ): (path: string) => Effect.Effect<Route.Type<R>, NoSuchElementException | RouteDecodeError<R>, Route.Context<R>>
  <R extends Route.Any>(
    path: string,
    route: R
  ): Effect.Effect<Route.Type<R>, NoSuchElementException | RouteDecodeError<R>, Route.Context<R>>
}

export declare const encode: {
  <R extends Route.Any, O extends Route.Type<R>>(
    params: O
  ): (route: R) => Effect.Effect<Route.Interpolate<R, Route.Params<R>>, RouteEncodeError<R>, Route.Context<R>>
  <R extends Route.Any, O extends Route.Type<R>>(
    route: R,
    params: O
  ): Effect.Effect<Route.Interpolate<R, Route.Params<R>>, RouteEncodeError<R>, Route.Context<R>>
}

export declare const encode_: {
  <R extends Route.Any, O extends Route.Type<R>>(
    route: R
  ): (params: O) => Effect.Effect<Route.Interpolate<R, Route.Params<R>>, RouteEncodeError<R>, Route.Context<R>>
  <R extends Route.Any, O extends Route.Type<R>>(
    params: O,
    route: R
  ): Effect.Effect<Route.Interpolate<R, Route.Params<R>>, RouteEncodeError<R>, Route.Context<R>>
}

export declare const end: Route<"/", never>

export declare function getInterpolate<R extends Route.Any>(
  route: R
): <P extends Route.Params<R>>(params: P) => Route.Interpolate<R, P>

export declare function getMatch<R extends Route.Any>(
  route: R,
  options?: { end?: boolean }
): (path: string) => Option.Option<Route.Params<R>>

export declare const getPath: <R extends Route.Any>(route: R) => Route.Path<R>

export declare const home: Route<"/", never>

export declare const integer: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: number }, { readonly [_ in Name]: string }, never>>

export declare function isRoute(value: unknown): value is Route.Any

export declare const literal: <const L extends string>(literal: L, options?: Partial<RouteOptions>) => Route<L>

export declare const make: <P extends string, S extends Sch.Schema.All>(
  ast: AST.AST,
  options?: Partial<RouteOptions>
) => Route<P, S>

export declare const nanoId: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: NanoId }, { readonly [_ in Name]: string }, never>>

export declare const number: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: number }, { readonly [_ in Name]: string }, never>>

export declare const oneOrMore: <R extends Route<any, never>>(
  route: R
) => Route.UpdatePath<R, Path.OneOrMore<Route.Path<R>>>

export declare const optional: <R extends Route<any, never>>(
  route: R
) => Route.UpdatePath<R, Path.Optional<Route.Path<R>>>

export declare const param: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>>

export declare const paramWithSchema: {
  <A, R = never>(
    schema: Sch.Schema<A, string, R>,
    options?: Partial<RouteOptions>
  ): <const Name extends string>(
    name: Name
  ) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: A }, { readonly [_ in Name]: string }, R>>
  <const Name extends string, A, R = never>(
    name: Name,
    schema: Sch.Schema<A, string, R>,
    options?: Partial<RouteOptions>
  ): Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: A }, { readonly [_ in Name]: string }, R>>
}

export declare const parse: <const P extends string>(path: P, options?: Partial<RouteOptions>) => Route<P>

export declare const prefix: {
  <P extends string>(prefix: P): <R extends Route.Any>(route: R) => Route.UpdatePath<R, Path.Prefix<P, Route.Path<R>>>
  <R extends Route.Any, P extends string>(prefix: P, route: R): Route.UpdatePath<R, `{${P}${Route.Path<R>}}`>
}

export declare function queryParams<Params extends Readonly<Record<string, Route.Any>>>(
  params: Params
): RouteFromQueryParamsObject<Params>

export declare function sortRoutes<Routes extends ReadonlyArray<Route.Any>>(
  routes: Routes
): Routes extends ReadonlyArray<infer R> ? ReadonlyArray<R> : never

export declare const transform: {
  <R extends Route.Any, S extends Sch.Schema.Any>(
    toSchema: S,
    from: (o: Route.Type<R>) => Sch.Schema.Encoded<S>,
    to: (s: Sch.Schema.Encoded<S>) => Route.Type<R>
  ): (route: R) => Route.UpdateSchema<R, Sch.transform<Route.Schema<R>, S>>
  <R extends Route.Any, S extends Sch.Schema.Any>(
    route: R,
    toSchema: S,
    from: (o: Route.Type<R>) => Sch.Schema.Encoded<S>,
    to: (s: Sch.Schema.Encoded<S>) => Route.Type<R>
  ): Route.UpdateSchema<R, Sch.transform<Route.Schema<R>, S>>
}

export declare const transformOrFail: {
  <R extends Route.Any, S extends Sch.Schema.Any, R2>(
    toSchema: S,
    from: (o: Route.Type<R>) => Effect.Effect<Sch.Schema.Encoded<S>, ParseIssue, R2>,
    to: (s: Sch.Schema.Encoded<S>) => Effect.Effect<Route.Type<R>, ParseIssue, R2>
  ): (route: R) => Route.UpdateSchema<R, Sch.transformOrFail<Route.Schema<R>, S, R2>>
  <R extends Route.Any, S extends Sch.Schema.Any, R2>(
    route: R,
    toSchema: S,
    from: (o: Route.Type<R>) => Effect.Effect<Sch.Schema.Encoded<S>, ParseIssue, R2>,
    to: (s: Sch.Schema.Encoded<S>) => Effect.Effect<Route.Type<R>, ParseIssue, R2>
  ): Route.UpdateSchema<R, Sch.transformOrFail<Route.Schema<R>, S, R2>>
}

export declare const ulid: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: string }, { readonly [_ in Name]: string }, never>>

export declare const unnamed: Route<"(.*)", never>

export declare const updateSchema: {
  <R extends Route.Any, S extends Sch.Schema.Any>(f: (s: Route.Schema<R>) => S): (route: R) => Route.UpdateSchema<R, S>
  <R extends Route.Any, S extends Sch.Schema.Any>(route: R, f: (s: Route.Schema<R>) => S): Route.UpdateSchema<R, S>
}

export declare const uuid: <const Name extends string>(
  name: Name,
  options?: Partial<RouteOptions>
) => Route<Path.Param<Name>, Sch.Schema<{ readonly [_ in Name]: Uuid }, { readonly [_ in Name]: string }, never>>

export declare const withSchema: {
  <R extends Route.Any, S extends Sch.Schema<any, Path.ParamsOf<Route.Path<R>>, any>>(
    schema: S
  ): (route: R) => Route.UpdateSchema<R, S>
  <R extends Route.Any, S extends Sch.Schema<any, Path.ParamsOf<Route.Path<R>>, any>>(
    route: R,
    schema: S
  ): Route.UpdateSchema<R, S>
}

export declare const zeroOrMore: <R extends Route<any, never>>(
  route: R
) => Route.UpdatePath<R, Path.ZeroOrMore<Route.Path<R>>>