export declare const Class: new <Success, Error, A extends Record<string, any>>(
  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true
    ? void
    : { readonly [P in keyof A as P extends keyof Request<unknown, unknown> ? never : P]: A[P] }
) => Request<Success, Error> & Readonly<A>

import { Request } from "effect"

type Success = string
type Error = never

class MyRequest extends Request.Class<
  Success,
  Error,
  {
    readonly id: string
  }
> {}

export declare const TaggedClass: <Tag extends string>(
  tag: Tag
) => new <Success, Error, A extends Record<string, any>>(
  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true
    ? void
    : { readonly [P in keyof A as P extends "_tag" | keyof Request<unknown, unknown> ? never : P]: A[P] }
) => Request<Success, Error> & Readonly<A> & { readonly _tag: Tag }

import { Request } from "effect"

type Success = string
type Error = never

class MyRequest extends Request.TaggedClass("MyRequest")<
  Success,
  Error,
  {
    readonly name: string
  }
> {}

export declare const makeEntry: <A extends Request<any, any>>(options: {
  readonly request: A
  readonly result: Deferred<Request.Success<A>, Request.Error<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>

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>,
    {
      listeners: Listeners
      handle: Deferred<unknown, unknown>
    }
  > {}

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

export interface Variance<out R> {
  readonly [EntryTypeId]: {
    readonly _R: Types.Covariant<R>
  }
}

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

export interface Request<out A, out E = never> extends Request.Variance<A, E> {}

export declare const makeCache: (options: {
  readonly capacity: number
  readonly timeToLive: DurationInput
}) => Effect.Effect<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<void>
  <A extends Request<any, any>>(self: A, result: Request.Result<A>): Effect.Effect<void>
}

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

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

export declare const failCause: {
  <A extends Request<any, any>>(cause: Cause<Request.Error<A>>): (self: A) => Effect.Effect<void>
  <A extends Request<any, any>>(self: A, cause: Cause<Request.Error<A>>): Effect.Effect<void>
}

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

export declare const succeed: {
  <A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<void>
  <A extends Request<any, any>>(self: A, value: Request.Success<A>): Effect.Effect<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 Request.Variance<Request.Success<R>, Request.Error<R>>>): R
}

export interface Variance<out A, out E> {
  readonly [RequestTypeId]: {
    readonly _A: Types.Covariant<A>
    readonly _E: Types.Covariant<E>
  }
}

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

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

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

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