declare const isSecurity: (u: TagClassAny) => u is TagClassSecurityAny

export interface HttpApiMiddleware<Provides, E> extends Effect.Effect<Provides, E, HttpRouter.HttpRouter.Provided> {}

export interface Any {
  readonly [TypeId]: TypeId
}

export interface AnyId {
  readonly [TypeId]: {
    readonly provides: any
  }
}

type Provides<A> = A extends { readonly [TypeId]: { readonly provides: infer P } } ? P : never

type ExtractProvides<A> = Provides<Only<A>>

type Error<A> = A extends { readonly [TypeId]: { readonly failure: infer E } } ? E : never

type ErrorContext<A> = A extends { readonly [TypeId]: { readonly failureContext: infer R } } ? R : never

type Only<R> = Extract<R, AnyId>

type Without<R> = Exclude<R, AnyId>

type HttpApiMiddlewareSecurity<Security, Provides, E> = {
  readonly [K in keyof Security]: (
    _: HttpApiSecurity.HttpApiSecurity.Type<Security[K]>
  ) => Effect.Effect<Provides, E, HttpRouter.HttpRouter.Provided>
}

type TagClass<Self, Name, Options> = Options extends {
  readonly security: Record<string, HttpApiSecurity.HttpApiSecurity>
}
  ? TagClass.BaseSecurity<
      Self,
      Name,
      Options,
      Simplify<
        HttpApiMiddlewareSecurity<Options["security"], TagClass.Service<Options>, TagClass.FailureService<Options>>
      >,
      Options["security"]
    >
  : TagClass.Base<Self, Name, Options, HttpApiMiddleware<TagClass.Service<Options>, TagClass.FailureService<Options>>>

export interface Base<Self, Name extends string, Options, Service> extends Context.Tag<Self, Service> {
  new (_: never): Context.TagClassShape<Name, Service> & {
    readonly [TypeId]: {
      readonly provides: Provides<Options>
      readonly failure: Failure<Options>
      readonly failureContext: FailureContext<Options>
    }
  }
  readonly [TypeId]: TypeId
  readonly optional: Optional<Options>
  readonly failure: FailureSchema<Options>
  readonly provides: Options extends { readonly provides: Context.Tag<any, any> } ? Options["provides"] : undefined
}

export interface BaseSecurity<
  Self,
  Name extends string,
  Options,
  Service,
  Security extends Record<string, HttpApiSecurity.HttpApiSecurity>
> extends Base<Self, Name, Options, Service> {
  readonly [SecurityTypeId]: SecurityTypeId
  readonly security: Security
}

type Provides<Options> = Options extends {
  readonly provides: Context.Tag<any, any>
  readonly optional?: false
}
  ? Context.Tag.Identifier<Options["provides"]>
  : never

type Service<Options> = Options extends { readonly provides: Context.Tag<any, any> }
  ? Context.Tag.Service<Options["provides"]>
  : void

type FailureSchema<Options> = Options extends { readonly failure: Schema.Schema.All; readonly optional?: false }
  ? Options["failure"]
  : typeof Schema.Never

type Failure<Options> = Options extends {
  readonly failure: Schema.Schema<infer _A, infer _I, infer _R>
  readonly optional?: false
}
  ? _A
  : never

type FailureContext<Options> = Schema.Schema.Context<FailureSchema<Options>>

type FailureService<Options> = Optional<Options> extends true ? unknown : Failure<Options>

type Optional<Options> = Options extends { readonly optional: true } ? true : false

export interface TagClassAny extends Context.Tag<any, HttpApiMiddleware.Any> {
  readonly [TypeId]: TypeId
  readonly optional: boolean
  readonly provides?: Context.Tag<any, any>
  readonly failure: Schema.Schema.All
}

export interface TagClassSecurityAny extends TagClassAny {
  readonly [SecurityTypeId]: SecurityTypeId
  readonly security: Record<string, HttpApiSecurity.HttpApiSecurity>
}

declare const Tag: <Self>() => <
  const Name extends string,
  const Options extends {
    readonly optional?: boolean
    readonly failure?: Schema.Schema.All
    readonly provides?: Context.Tag<any, any>
    readonly security?: Record<string, HttpApiSecurity.HttpApiSecurity>
  }
>(
  id: Name,
  options?: Options | undefined
) => TagClass<Self, Name, Options>

declare const SecurityTypeId: unique symbol

type SecurityTypeId = typeof SecurityTypeId

declare const TypeId: unique symbol

type TypeId = typeof TypeId