export declare const handle: {
  <R2, E2, RemainingEndpoints extends ApiEndpoint.ApiEndpoint.Any, Endpoint extends RemainingEndpoints>(
    handler: RouterBuilder.Handler<Endpoint, E2, R2>
  ): <R1, E1>(
    builder: RouterBuilder<R1, E1, RemainingEndpoints>
  ) => RouterBuilder<
    | Exclude<R2, Router.RouteContext | ServerRequest.ServerRequest>
    | Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>
    | ApiEndpoint.ApiEndpoint.Context<Endpoint>,
    E1 | Exclude<E2, HttpError.HttpError>,
    Exclude<RemainingEndpoints, Endpoint>
  >
  <
    R2,
    E2,
    RemainingEndpoints extends ApiEndpoint.ApiEndpoint.Any,
    Id extends ApiEndpoint.ApiEndpoint.Id<RemainingEndpoints>
  >(
    id: Id,
    fn: Route.HandlerFunction<ApiEndpoint.ApiEndpoint.ExtractById<RemainingEndpoints, Id>, R2, E2>
  ): <R1, E1>(
    builder: RouterBuilder<R1, E1, RemainingEndpoints>
  ) => RouterBuilder<
    | Exclude<R2, Router.RouteContext | ServerRequest.ServerRequest>
    | Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>
    | ApiEndpoint.ApiEndpoint.Context<ApiEndpoint.ApiEndpoint.ExtractById<RemainingEndpoints, Id>>,
    E1 | Exclude<E2, HttpError.HttpError>,
    ApiEndpoint.ApiEndpoint.ExcludeById<RemainingEndpoints, Id>
  >
}

export declare const handler: <R, E, A extends Api.Api.Any, Id extends Api.Api.Ids<A>>(
  api: A,
  id: Id,
  fn: Route.HandlerFunction<Api.Api.EndpointById<A, Id>, R, E>
) => RouterBuilder.Handler<Api.Api.EndpointById<A, Id>, E, R>

export declare const build: <R, E>(
  builder: RouterBuilder<R, E, never>
) => App.Default<E, SwaggerRouter.SwaggerFiles | R>

export declare const buildPartial: <R, E, RemainingEndpoints extends ApiEndpoint.ApiEndpoint.Any>(
  builder: RouterBuilder<R, E, RemainingEndpoints>
) => App.Default<E, SwaggerRouter.SwaggerFiles | R>

export declare const getRouter: <R, E>(builder: RouterBuilder<R, E, any>) => Router.Router<E, R>

export declare const handleRaw: <
  R2,
  E2,
  RemainingEndpoints extends ApiEndpoint.ApiEndpoint.Any,
  Id extends ApiEndpoint.ApiEndpoint.Id<RemainingEndpoints>
>(
  id: Id,
  handler: Router.Route.Handler<E2, R2>
) => <R1, E1>(
  builder: RouterBuilder<R1, E1, RemainingEndpoints>
) => RouterBuilder<
  | R1
  | ApiEndpoint.ApiEndpoint.Context<ApiEndpoint.ApiEndpoint.ExtractById<RemainingEndpoints, Id>>
  | Exclude<R2, Router.RouteContext | ServerRequest.ServerRequest | Scope.Scope>,
  E2 | E1 | ApiEndpoint.ApiEndpoint.Error<ApiEndpoint.ApiEndpoint.ExtractById<RemainingEndpoints, Id>>,
  ApiEndpoint.ApiEndpoint.ExcludeById<RemainingEndpoints, Id>
>

export declare const make: <A extends Api.Api.Any>(
  api: A,
  options?: Partial<Options>
) => RouterBuilder<never, never, Api.Api.Endpoints<A>>

export declare const mapRouter: <R1, R2, E1, E2, RemainingEndpoints extends ApiEndpoint.ApiEndpoint.Any>(
  fn: (router: Router.Router<E1, R1>) => Router.Router<E2, R2>
) => (builder: RouterBuilder<R1, E1, RemainingEndpoints>) => RouterBuilder<R2, E2, RemainingEndpoints>

export interface Options {
  readonly parseOptions: AST.ParseOptions
  readonly enableDocs: boolean
  readonly docsPath: `/${string}`
}

export interface RouterBuilder<R, E, RemainingEndpoints extends ApiEndpoint.ApiEndpoint.Any> extends Pipeable.Pipeable {
  readonly remainingEndpoints: ReadonlyArray<RemainingEndpoints>
  readonly api: Api.Api.Any
  readonly router: Router.Router<E, R>
  readonly options: Options
}

export interface Handler<Endpoint extends ApiEndpoint.ApiEndpoint.Any, E, R> {
  readonly handler: Route.HandlerFunction<Endpoint, R, E>
  readonly endpoint: Endpoint
}

export type Any = RouterBuilder<any, any, ApiEndpoint.ApiEndpoint.Any>