export declare const and: {
  <A1, A2, E2, R2>(
    that: Security<A2, E2, R2>
  ): <E1, R1>(self: Security<A1, E1, R1>) => Security<[A1, A2], E1 | E2, R1 | R2>
  <A1, E1, R1, A2, E2, R2>(self: Security<A1, E1, R1>, that: Security<A2, E2, R2>): Security<[A1, A2], E1 | E2, R1 | R2>
}

export declare const as: {
  <B>(value: B): <A, E, R>(self: Security<A, E, R>) => Security<B, E, R>
  <A, B, E, R>(self: Security<A, E, R>, value: B): Security<B, E, R>
}

export declare const asSome: <A, E, R>(self: Security<A, E, R>) => Security<Option.Option<A>, E, R>

export declare const map: {
  <A, B>(f: (a: A) => B): <E, R>(self: Security<A, E, R>) => Security<B, E, R>
  <A, B, E, R>(self: Security<A, E, R>, f: (a: A) => B): Security<B, E, R>
}

export declare const mapEffect: {
  <A1, A2, E2, R2>(
    f: (a: A1) => Effect.Effect<A2, E2, R2>
  ): <E1, R1>(
    self: Security<A1, E1, R1>
  ) => Security<
    A2,
    E1 | Exclude<E2, HttpError.HttpError>,
    R1 | Exclude<R2, HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams>
  >
  <A1, E1, R1, A2, E2, R2>(
    self: Security<A1, E1, R1>,
    f: (a: A1) => Effect.Effect<A2, E2, R2>
  ): Security<
    A2,
    E1 | Exclude<E2, HttpError.HttpError>,
    R1 | Exclude<R2, HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams>
  >
}

export declare const mapHandler: {
  <A, B, E1, E2, R1, R2>(
    f: (handler: Security.Handler<A, E1, R1>) => Security.Handler<B, E2, R2>
  ): (security: Security<A, E1, R1>) => Security<B, E2, R2>
  <A, B, E1, E2, R1, R2>(
    security: Security<A, E1, R1>,
    f: (handler: Security.Handler<A, E1, R1>) => Security.Handler<B, E2, R2>
  ): Security<B, E2, R2>
}

export declare const mapSchema: {
  <A, B>(schema: Schema.Schema<B, A>): <E, R>(self: Security<A, E, R>) => Security<B, E, R>
  <A, B, E, R>(self: Security<A, E, R>, schema: Schema.Schema<B, A>): Security<B, E, R>
}

export declare const or: {
  <A1, A2, E2, R2>(
    that: Security<A2, E2, R2>
  ): <E1, R1>(self: Security<A1, E1, R1>) => Security<A1 | A2, E1 | E2, R1 | R2>
  <A1, E1, R1, A2, E2, R2>(self: Security<A1, E1, R1>, that: Security<A2, E2, R2>): Security<A1 | A2, E1 | E2, R1 | R2>
}

export declare const apiKey: (options: ApiKeyOptions) => Security<string>

export declare const basic: (options?: BasicOptions) => Security<BasicCredentials>

export declare const bearer: (options?: BearerOptions) => Security<string>

export declare const make: <A, E, R>(
  parser: Security.Handler<A, E, R>,
  openapi?: Record.ReadonlyRecord<string, unknown>
) => Security<
  A,
  Exclude<E, HttpError.HttpError>,
  Exclude<R, HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams>
>

export declare const never: Security<never, never, never>

export declare const unit: Security<void, never, never>

export declare const getOpenApi: <A, E, R>(security: Security<A, E, R>) => Record.ReadonlyRecord<string, unknown>

export declare const handleRequest: <A, E, R>(security: Security<A, E, R>) => Security.Handler<A, E, R>

export interface ApiKeyOptions {
  key: string
  in: "header" | "query" // TODO: support cookie
  name?: string
  description?: string
}

export interface BasicCredentials {
  user: string
  pass: string
}

export interface BasicOptions {
  name?: string
  description?: string
}

export interface BearerOptions {
  name?: string
  description?: string
  bearerFormat?: string
}

export interface Security<A, E = never, R = never> extends Security.Variance<A, E, R>, Pipeable.Pipeable {}

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

export type Any = Security<any, any, any>

export type Context<T extends Any> = [T] extends [Security<any, any, infer R>] ? R : never

export type Default = Security<void, never, never>

export type Error<T extends Any> = [T] extends [Security<any, infer E, any>] ? E : never

export type Handler<A, E, R> = Effect.Effect<
  A,
  E,
  R | HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams
>

export type Success<T extends Any> = [T] extends [Security<infer A, any, any>] ? A : never

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId