export declare const makeEntry: <A extends Request<any, any>>(options: {
  readonly request: A
  readonly result: Deferred<Request.Error<A>, Request.Success<A>>
  readonly listeners: Listeners
  readonly ownerId: FiberId
  readonly state: { completed: boolean }
}) => Entry<A>

export declare const of: <R extends Request<any, any>>() => Request.Constructor<R, never>

export declare const tagged: <R extends Request<any, any> & { _tag: string }>(
  tag: R['_tag']
) => Request.Constructor<R, '_tag'>

export declare const isEntry: (u: unknown) => u is Entry<unknown>

export interface Cache
  extends _Cache.ConsumerCache<
    Request<any, any>,
    never,
    {
      listeners: Listeners
      handle: Deferred<unknown, unknown>
    }
  > {}

export interface Entry<R> extends Entry.Variance<R> {
  readonly request: R
  readonly result: Deferred<
    [R] extends [Request<infer _E, infer _A>] ? _E : never,
    [R] extends [Request<infer _E, infer _A>] ? _A : never
  >
  readonly listeners: Listeners
  readonly ownerId: FiberId
  readonly state: {
    completed: boolean
  }
}

export interface Variance<R> {
  readonly [EntryTypeId]: {
    readonly _R: (_: never) => R
  }
}

export interface Listeners {
  count: number
  observers: Set<(count: number) => void>
  addObserver(f: (count: number) => void): void
  removeObserver(f: (count: number) => void): void
  increment(): void
  decrement(): void
}

export interface Request<E, A> extends Request.Variance<E, A>, Data.Case {}

export declare const makeCache: (options: {
  readonly capacity: number
  readonly timeToLive: DurationInput
}) => Effect.Effect<never, never, Cache>

export declare const isRequest: (u: unknown) => u is Request<unknown, unknown>

export declare const complete: {
  <A extends Request<any, any>>(result: Request.Result<A>): (self: A) => Effect.Effect<never, never, void>
  <A extends Request<any, any>>(self: A, result: Request.Result<A>): Effect.Effect<never, never, void>
}

export declare const completeEffect: {
  <A extends Request<any, any>, R>(effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>): (
    self: A
  ) => Effect.Effect<R, never, void>
  <A extends Request<any, any>, R>(
    self: A,
    effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>
  ): Effect.Effect<R, never, void>
}

export declare const fail: {
  <A extends Request<any, any>>(error: Request.Error<A>): (self: A) => Effect.Effect<never, never, void>
  <A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<never, never, void>
}

export declare const interruptWhenPossible: {
  (all: Iterable<Request<any, any>>): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, void>
  <R, E, A>(self: Effect.Effect<R, E, A>, all: Iterable<Request<any, any>>): Effect.Effect<R, E, void>
}

export declare const succeed: {
  <A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<never, never, void>
  <A extends Request<any, any>>(self: A, value: Request.Success<A>): Effect.Effect<never, never, void>
}

export declare const EntryTypeId: typeof EntryTypeId

export type EntryTypeId = typeof EntryTypeId

export declare const RequestTypeId: typeof RequestTypeId

export type RequestTypeId = typeof RequestTypeId

export interface Constructor<R extends Request<any, any>, T extends keyof R = never> {
  (args: Omit<R, T | keyof (Data.Case & Request.Variance<Request.Error<R>, Request.Success<R>>)>): R
}

export interface Variance<E, A> {
  readonly [RequestTypeId]: {
    readonly _E: (_: never) => E
    readonly _A: (_: never) => A
  }
}

export type Error<T extends Request<any, any>> = [T] extends [Request<infer _E, infer _A>] ? _E : never

export type OptionalResult<T extends Request<any, any>> = T extends Request<infer E, infer A>
  ? Exit.Exit<E, Option.Option<A>>
  : never

export type Result<T extends Request<any, any>> = T extends Request<infer E, infer A> ? Exit.Exit<E, A> : never

export type Success<T extends Request<any, any>> = [T] extends [Request<infer _E, infer _A>] ? _A : never