export declare const addEndpoint: <E2 extends ApiEndpoint.ApiEndpoint.Any>(
  endpoint: E2
) => <E1 extends ApiEndpoint.ApiEndpoint.Any>(api: Api<E1>) => Api<E1 | E2>

export declare const addGroup: <E2 extends ApiEndpoint.ApiEndpoint.Any>(
  group: ApiGroup.ApiGroup<E2>
) => <E1 extends ApiEndpoint.ApiEndpoint.Any>(api: Api<E1>) => Api<E1 | E2>

export declare const setOptions: (
  options: Partial<Options>
) => <A extends ApiEndpoint.ApiEndpoint.Any>(self: Api<A>) => Api<A>

export declare const delete: <Id extends ApiEndpoint.ApiEndpoint.AnyId>(id: Id, path: PathInput, options?: Partial<ApiEndpoint.Options>) => ApiEndpoint.ApiEndpoint.Default<Id>

export declare const endpoint: <Id extends ApiEndpoint.ApiEndpoint.AnyId>(
  method: HttpMethod,
  id: Id,
  path: PathInput,
  options?: Partial<ApiEndpoint.Options>
) => ApiEndpoint.ApiEndpoint.Default<Id>

export declare const get: <Id extends ApiEndpoint.ApiEndpoint.AnyId>(
  id: Id,
  path: PathInput,
  options?: Partial<ApiEndpoint.Options>
) => ApiEndpoint.ApiEndpoint.Default<Id>

export declare const make: (options?: Partial<Options>) => Api.Empty

export declare const patch: <Id extends ApiEndpoint.ApiEndpoint.AnyId>(
  id: Id,
  path: PathInput,
  options?: Partial<ApiEndpoint.Options>
) => ApiEndpoint.ApiEndpoint.Default<Id>

export declare const post: <Id extends ApiEndpoint.ApiEndpoint.AnyId>(
  id: Id,
  path: PathInput,
  options?: Partial<ApiEndpoint.Options>
) => ApiEndpoint.ApiEndpoint.Default<Id>

export declare const put: <Id extends ApiEndpoint.ApiEndpoint.AnyId>(
  id: Id,
  path: PathInput,
  options?: Partial<ApiEndpoint.Options>
) => ApiEndpoint.ApiEndpoint.Default<Id>

export declare const setRequest: <Request extends ApiRequest.Any>(
  request: Request
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  _ extends ApiRequest.Any,
  Response extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, _, Response, Security>
) => ApiEndpoint.ApiEndpoint<Id, Request, Response, Security>

export declare const getEndpoint: <A extends Api.Any, Id extends Api.Ids<A>>(api: A, id: Id) => Api.EndpointById<A, Id>

export interface Api<A extends ApiEndpoint.ApiEndpoint.Any> extends Pipeable.Pipeable, Api.Variance<A> {
  readonly groups: ReadonlyArray<ApiGroup.ApiGroup<A>>
  readonly options: Options
}

export interface Variance<A extends ApiEndpoint.ApiEndpoint.Any> {
  readonly [TypeId]: {
    readonly _A: Types.Covariant<A>
  }
}

export type Any = Api<ApiEndpoint.ApiEndpoint.Any>

export type Context<A> = [A] extends [Api<infer E>] ? ApiEndpoint.ApiEndpoint.Context<E> : never

export type Empty = Api<never>

export type EndpointById<A extends Any, Id extends ApiEndpoint.ApiEndpoint.AnyId> = [A] extends [Api<infer E>]
  ? E extends ApiEndpoint.ApiEndpoint<Id, any, any, any>
    ? E
    : never
  : never

export type Endpoints<A extends Any> = [A] extends [Api<infer E>] ? E : never

export type Ids<A extends Any> = [Endpoints<A>] extends [ApiEndpoint.ApiEndpoint<infer Id, any, any, any>] ? Id : never

export interface Options {
  readonly title: string
  readonly version: string
  readonly description?: string
  readonly servers?: ReadonlyArray<OpenApiTypes.OpenAPISpecServer | string>
  readonly license?: {
    readonly name: string
    readonly url?: string
  }
}

export declare const addResponse: <
  Status extends ApiResponse.AnyStatus,
  Body = ApiSchema.Ignored,
  Headers = ApiSchema.Ignored,
  R = never
>(
  response:
    | ApiResponse<Status, Body, Headers, R>
    | {
        readonly status: Status
        readonly body?: Schema.Schema<Body, any, R>
        readonly headers?: Schema.Schema<Headers, any, R>
      }
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  Request extends ApiRequest.Any,
  Response1 extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, Request, Response1, Security>
) => ApiEndpoint.ApiEndpoint<Id, Request, Response1 | ApiResponse<Status, Body, Headers, R>, Security>

export declare const setEndpointOptions: (
  options: Partial<ApiEndpoint.Options>
) => <A extends ApiEndpoint.ApiEndpoint.Any>(endpoint: A) => A

export declare const setRequestBody: <B, R2>(
  schema: Schema.Schema<B, any, R2>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  _,
  P,
  Q,
  H,
  R1,
  Response extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, ApiRequest<_, P, Q, H, R1>, Response, Security>
) => ApiEndpoint.ApiEndpoint<Id, ApiRequest<B, P, Q, H, R1 | R2>, Response, Security>

export declare const setRequestHeaders: <H, I extends Readonly<Record<string, string | undefined>>, R2>(
  schema: Schema.Schema<H, I, R2>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  B,
  P,
  Q,
  _,
  R1,
  Response extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, ApiRequest<B, P, Q, _, R1>, Response, Security>
) => ApiEndpoint.ApiEndpoint<Id, ApiRequest<B, P, Q, H, R1 | R2>, Response, Security>

export declare const setRequestPath: <P, I extends Readonly<Record<string, string | undefined>>, R2>(
  schema: Schema.Schema<P, I, R2>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  B,
  _,
  Q,
  H,
  R1,
  Response extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, ApiRequest<B, _, Q, H, R1>, Response, Security>
) => ApiEndpoint.ApiEndpoint<Id, ApiRequest<B, P, Q, H, R1 | R2>, Response, Security>

export declare const setRequestQuery: <
  Q,
  I extends Readonly<Record<string, string | undefined | ReadonlyArray<string>>>,
  R2
>(
  schema: Schema.Schema<Q, I, R2>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  B,
  P,
  _,
  H,
  R1,
  Response extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, ApiRequest<B, P, _, H, R1>, Response, Security>
) => ApiEndpoint.ApiEndpoint<Id, ApiRequest<B, P, Q, H, R1 | R2>, Response, Security>

export declare const setResponse: <
  Status extends ApiResponse.AnyStatus,
  Body = ApiSchema.Ignored,
  Headers = ApiSchema.Ignored,
  R = never
>(
  response:
    | {
        readonly status: Status
        readonly body?: Schema.Schema<Body, any, R>
        readonly headers?: Schema.Schema<Headers, any, R>
      }
    | ApiResponse<Status, Body, Headers, R>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  Request extends ApiRequest.Any,
  _ extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, Request, _, Security>
) => ApiEndpoint.ApiEndpoint<Id, Request, ApiResponse<Status, Body, Headers, R>, Security>

export declare const setResponseBody: <B, R2>(
  schema: Schema.Schema<B, any, R2>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  Request extends ApiRequest.Any,
  S extends ApiResponse.AnyStatus,
  _,
  H,
  R1,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, Request, ApiResponse<S, _, H, R1>, Security>
) => ApiEndpoint.ApiEndpoint<Id, Request, ApiResponse<S, B, H, R1 | R2>, Security>

export declare const setResponseHeaders: <H, R2>(
  schema: Schema.Schema<H, any, R2>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  Request extends ApiRequest.Any,
  S extends ApiResponse.AnyStatus,
  B,
  _,
  R1,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, Request, ApiResponse<S, B, _, R1>, Security>
) => ApiEndpoint.ApiEndpoint<Id, Request, ApiResponse<S, B, H, R1 | R2>, Security>

export declare const setResponseRepresentations: (
  representations: NonEmptyReadonlyArray<Representation>
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  Request extends ApiRequest.Any,
  Response extends ApiResponse.Any,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, Request, Response, Security>
) => ApiEndpoint.ApiEndpoint<Id, Request, Response, Security>

export declare const setResponseStatus: <Status extends ApiResponse.AnyStatus>(
  status: Status
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  Request extends ApiRequest.Any,
  _ extends ApiResponse.AnyStatus,
  B,
  H,
  R,
  Security extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, Request, ApiResponse<_, B, H, R>, Security>
) => ApiEndpoint.ApiEndpoint<Id, Request, ApiResponse<Status, B, H, R>, Security>

export declare const setSecurity: <Security extends Security.Any>(
  security: Security
) => <
  Id extends ApiEndpoint.ApiEndpoint.AnyId,
  Request extends ApiRequest.Any,
  Response extends ApiResponse.Any,
  _ extends Security.Any
>(
  endpoint: ApiEndpoint.ApiEndpoint<Id, Request, Response, _>
) => ApiEndpoint.ApiEndpoint<Id, Request, Response, Security>

export declare const isApi: (u: unknown) => u is Api.Any

export declare const FormData: Schema.Schema<FormData, FormData, never>

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId