declare const layerClient: <Id, S, R, EX = never, RX = never>(
  tag: Context.Tag<Id, S>,
  service: RpcMiddlewareClient<R> | Effect.Effect<RpcMiddlewareClient<R>, EX, RX>
) => Layer.Layer<ForClient<Id>, EX, R | Exclude<RX, Scope>>

export interface Any {
  (options: {
    readonly rpc: Rpc.AnyWithProps
    readonly payload: unknown
    readonly headers: Headers
  }): Effect.Effect<any, any>
}

export interface ForClient<Id> {
  readonly _: unique symbol
  readonly id: Id
}

export interface RpcMiddleware<Provides, E> {
  (options: {
    readonly rpc: Rpc.AnyWithProps
    readonly payload: unknown
    readonly headers: Headers
  }): Effect.Effect<Provides, E>
}

export interface RpcMiddlewareClient<R = never> {
  (options: {
    readonly rpc: Rpc.AnyWithProps
    readonly request: Request<Rpc.Any>
  }): Effect.Effect<Request<Rpc.Any>, never, R>
}

export interface TagClass<Self, Name extends string, Options>
  extends TagClass.Base<
    Self,
    Name,
    Options,
    RpcMiddleware<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]: TypeId
  readonly optional: Optional<Options>
  readonly failure: FailureSchema<Options>
  readonly provides: Options extends { readonly provides: Context.Tag<any, any> } ? Options["provides"] : undefined
  readonly requiredForClient: RequiredForClient<Options>
}

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 Schema.Schema.Context<FailureSchema<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

type RequiredForClient<Options> = Options extends { readonly requiredForClient: true } ? true : false

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

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

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 requiredForClient?: boolean
  }
>(
  id: Name,
  options?: Options | undefined
) => TagClass<Self, Name, Options>

declare const TypeId: unique symbol

type TypeId = typeof TypeId