export declare const annotate: {
  <I, S>(tag: Context.Tag<I, S>, value: S): <A extends HttpApi.Any>(self: A) => A
  <A extends HttpApi.Any, I, S>(self: A, tag: Context.Tag<I, S>, value: S): A
}

export declare const annotateMerge: {
  <I>(context: Context.Context<I>): <A extends HttpApi.Any>(self: A) => A
  <A extends HttpApi.Any, I>(self: A, context: Context.Context<I>): A
}

export declare const addGroup: {
  <Group extends HttpApiGroup.HttpApiGroup.Any>(
    group: Group
  ): <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR>(
    self: HttpApi<Groups, Error, ErrorR>
  ) => HttpApi<Groups | Group, Error, ErrorR>
  <Group extends HttpApiGroup.HttpApiGroup.Any>(
    path: HttpRouter.PathInput,
    group: Group
  ): <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR>(
    self: HttpApi<Groups, Error, ErrorR>
  ) => HttpApi<Groups | Group, Error, ErrorR>
  <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, Group extends HttpApiGroup.HttpApiGroup.Any>(
    self: HttpApi<Groups, Error, ErrorR>,
    group: Group
  ): HttpApi<Groups | Group, Error, ErrorR>
  <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, Group extends HttpApiGroup.HttpApiGroup.Any>(
    self: HttpApi<Groups, Error, ErrorR>,
    path: HttpRouter.PathInput,
    group: Group
  ): HttpApi<Groups | Group, Error, ErrorR>
}

export declare const empty: HttpApi<never, never, never>

export declare const addError: {
  <A, I, R>(
    schema: Schema.Schema<A, I, R>,
    annotations?: { readonly status?: number | undefined }
  ): <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR>(
    self: HttpApi<Groups, Error, ErrorR>
  ) => HttpApi<Groups, Error | A, ErrorR | R>
  <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, A, I, R>(
    self: HttpApi<Groups, Error, ErrorR>,
    schema: Schema.Schema<A, I, R>,
    annotations?: { readonly status?: number | undefined }
  ): HttpApi<Groups, Error | A, ErrorR | R>
}

export declare const isHttpApi: (u: unknown) => u is HttpApi<any, any>

export interface HttpApi<
  out Groups extends HttpApiGroup.HttpApiGroup.Any = never,
  in out Error = never,
  out ErrorR = never
> extends Pipeable {
  new (_: never): {}
  readonly [TypeId]: TypeId
  readonly groups: Chunk.Chunk<Groups>
  readonly errorSchema: Schema.Schema<Error, unknown, ErrorR>
  readonly annotations: Context.Context<never>
}

export interface Any extends Pipeable {
  new (_: never): {}
  readonly [TypeId]: TypeId
  readonly groups: Chunk.Chunk<HttpApiGroup.HttpApiGroup.Any>
  readonly errorSchema: Schema.Schema.All
  readonly annotations: Context.Context<never>
}

export interface Service {
  readonly _: unique symbol
}

export type Context<A> =
  A extends HttpApi<infer _Groups, infer _ApiError, infer _ApiErrorR>
    ? _ApiErrorR | HttpApiGroup.HttpApiGroup.Context<_Groups>
    : never

export declare const reflect: <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR>(
  self: HttpApi<Groups, Error, ErrorR>,
  options: {
    readonly onGroup: (options: {
      readonly group: HttpApiGroup.HttpApiGroup<string, any>
      readonly mergedAnnotations: Context.Context<never>
    }) => void
    readonly onEndpoint: (options: {
      readonly group: HttpApiGroup.HttpApiGroup<string, any>
      readonly endpoint: HttpApiEndpoint.HttpApiEndpoint<string, HttpMethod>
      readonly mergedAnnotations: Context.Context<never>
      readonly successAST: Option.Option<AST.AST>
      readonly successStatus: number
      readonly successEncoding: HttpApiSchema.Encoding
      readonly errors: ReadonlyMap<number, Option.Option<AST.AST>>
    }) => void
  }
) => void

export declare const HttpApi: Context.Tag<HttpApi.Service, HttpApi.Any>

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId