export declare const merge: {
  <R1, E1, R2, E2, A1 extends ApiEndpoint.ApiEndpoint.Any, A2 extends ApiEndpoint.ApiEndpoint.Any>(
    builder1: RouterBuilder<A1, E1, R1>,
    builder2: RouterBuilder<A2, E2, R2>
  ): RouterBuilder<RouterBuilder.MergeApiEndpoints<A1, A2>, E1 | E2, R1 | R2>
  <R2, E2, A2 extends ApiEndpoint.ApiEndpoint.Any>(
    builder2: RouterBuilder<A2, E2, R2>
  ): <R1, E1, A1 extends ApiEndpoint.ApiEndpoint.Any>(
    builder1: RouterBuilder<A1, E1, R1>
  ) => RouterBuilder<RouterBuilder.MergeApiEndpoints<A1, A2>, E1 | E2, R1 | R2>
}

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

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

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

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

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

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

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

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

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

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

export interface Variance<A extends ApiEndpoint.ApiEndpoint.Any, E, R> {
  readonly [TypeId]: {
    readonly _A: Types.Covariant<A>
    readonly _E: Types.Covariant<E>
    readonly _R: Types.Contravariant<R>
  }
}

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

export type MergeApiEndpoints<A, B> =
  A extends ApiEndpoint.ApiEndpoint<
    infer Id1,
    ApiRequest.ApiRequest.Any,
    ApiResponse.ApiResponse.Any,
    Security.Security.Any
  >
    ? B extends ApiEndpoint.ApiEndpoint<
        infer Id2,
        ApiRequest.ApiRequest.Any,
        ApiResponse.ApiResponse.Any,
        Security.Security.Any
      >
      ? Id1 extends Id2
        ? A
        : never
      : never
    : never

export declare const isRouterBuilder: (u: unknown) => u is RouterBuilder.Any

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId