declare class AbstractSupervisor<T>

declare const onStart: <A, E, R>(
  _context: Context.Context<R>,
  _effect: Effect.Effect<A, E, R>,
  _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
  _fiber: Fiber.RuntimeFiber<A, E>
) => void

declare const onEnd: <A, E>(_value: Exit.Exit<A, E>, _fiber: Fiber.RuntimeFiber<A, E>) => void

declare const onEffect: <A, E>(_fiber: Fiber.RuntimeFiber<A, E>, _effect: Effect.Effect<any, any, any>) => void

declare const onSuspend: <A, E>(_fiber: Fiber.RuntimeFiber<A, E>) => void

declare const onResume: <A, E>(_fiber: Fiber.RuntimeFiber<A, E>) => void

declare const map: <B>(f: (a: T) => B) => Supervisor<B>

declare const zip: <A>(right: Supervisor<A>) => Supervisor<[T, A]>

declare const onRun: <E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>) => X

value: Effect.Effect<T, never, never>

readonly [SupervisorTypeId]: { _T: (_: never) => never; }

declare const fibersIn: (
  ref: MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>
) => Effect.Effect<Supervisor<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>>

declare const fromEffect: <A>(effect: Effect.Effect<A>) => Supervisor<A>

declare const none: Supervisor<void>

declare const track: Effect.Effect<Supervisor<Array<Fiber.RuntimeFiber<any, any>>>, never, never>

declare const addSupervisor: <A>(supervisor: Supervisor<A>) => Layer.Layer<never>

export interface Supervisor<out T> extends Supervisor.Variance<T> {
  /**
   * Returns an `Effect` that succeeds with the value produced by this
   * supervisor. This value may change over time, reflecting what the supervisor
   * produces as it supervises fibers.
   */
  readonly value: Effect.Effect<T>

  /**
   * Supervises the start of a `Fiber`.
   */
  onStart<A, E, R>(
    context: Context.Context<R>,
    effect: Effect.Effect<A, E, R>,
    parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
    fiber: Fiber.RuntimeFiber<A, E>
  ): void

  /**
   * Supervises the end of a `Fiber`.
   */
  onEnd<A, E>(value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void

  /**
   * Supervises the execution of an `Effect` by a `Fiber`.
   */
  onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<any, any, any>): void

  /**
   * Supervises the suspension of a computation running within a `Fiber`.
   */
  onSuspend<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void

  /**
   * Supervises the resumption of a computation running within a `Fiber`.
   */
  onResume<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void

  /**
   * Maps this supervisor to another one, which has the same effect, but whose
   * value has been transformed by the specified function.
   */
  map<B>(f: (a: T) => B): Supervisor<B>

  /**
   * Returns a new supervisor that performs the function of this supervisor, and
   * the function of the specified supervisor, producing a tuple of the outputs
   * produced by both supervisors.
   */
  zip<A>(right: Supervisor<A>): Supervisor<[T, A]>
}

declare const SupervisorTypeId: unique symbol

type SupervisorTypeId = typeof SupervisorTypeId

declare const unsafeTrack: () => Supervisor<Array<Fiber.RuntimeFiber<any, any>>>

export interface Variance<out T> {
  readonly [SupervisorTypeId]: {
    readonly _T: Types.Covariant<T>
  }
}