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

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

export declare const apiKey: (options: {
  readonly key: string
  readonly in?: "header" | "query" | "cookie" | undefined
}) => ApiKey

export declare const authorization: (scheme: string) => Authorization

export declare const basic: Basic

export declare const bearer: Authorization

export interface And<A extends HttpApiSecurity, B extends HttpApiSecurity>
  extends HttpApiSecurity.Proto<readonly [HttpApiSecurity.Type<A>, HttpApiSecurity.Type<B>]> {
  readonly _tag: "And"
  readonly first: A
  readonly second: A
}

export interface ApiKey extends HttpApiSecurity.Proto<Redacted> {
  readonly _tag: "ApiKey"
  readonly in: "header" | "query" | "cookie"
  readonly key: string
}

export interface Authorization extends HttpApiSecurity.Proto<Redacted> {
  readonly _tag: "Authorization"
  readonly scheme: string
}

export interface Basic extends HttpApiSecurity.Proto<Credentials> {
  readonly _tag: "Basic"
}

export interface Credentials {
  readonly username: string
  readonly password: Redacted
}

export type HttpApiSecurity =
  | HttpApiSecurity.Base
  | Optional<HttpApiSecurity>
  | Or<HttpApiSecurity, HttpApiSecurity>
  | And<HttpApiSecurity, HttpApiSecurity>

export interface Proto<out A> extends Pipeable {
  readonly [TypeId]: {
    readonly _A: Covariant<A>
  }
  readonly annotations: Context.Context<never>
}

export type Base = Authorization | ApiKey | Basic

export type Type<A extends HttpApiSecurity> = A extends Proto<infer Out> ? Out : never

export interface Optional<A extends HttpApiSecurity>
  extends HttpApiSecurity.Proto<Option.Option<HttpApiSecurity.Type<A>>> {
  readonly _tag: "Optional"
  readonly security: A
}

export interface Or<A extends HttpApiSecurity, B extends HttpApiSecurity>
  extends HttpApiSecurity.Proto<HttpApiSecurity.Type<A> | HttpApiSecurity.Type<B>> {
  readonly _tag: "Or"
  readonly first: A
  readonly second: B
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

export declare class SecurityDecodeError

export declare const and: {
  <B extends HttpApiSecurity>(second: B): <A extends HttpApiSecurity>(first: A) => Or<A, B>
  <A extends HttpApiSecurity, B extends HttpApiSecurity>(first: A, second: B): Or<A, B>
}

export declare const optional: <A extends HttpApiSecurity>(security: A) => Optional<A>

export declare const or: {
  <B extends HttpApiSecurity>(second: B): <A extends HttpApiSecurity>(first: A) => Or<A, B>
  <A extends HttpApiSecurity, B extends HttpApiSecurity>(first: A, second: B): Or<A, B>
}