Supervisor

declare class AbstractSupervisor<T> implements Supervisor<T> {
  constructor<T>();
  readonly [SupervisorTypeId]: {
    _T: (_: never) => never;
  };
  abstract value: Effect<T>;
  map<B>(f: (a: T) => B): Supervisor<B>;
  onEffect<A, E>(_fiber: RuntimeFiber<A, E>, _effect: Effect<any, any, any>): void;
  onEnd<A, E>(_value: Exit<A, E>, _fiber: RuntimeFiber<A, E>): void;
  onResume<A, E>(_fiber: RuntimeFiber<A, E>): void;
  onRun<E, A, X>(execution: () => X, _fiber: RuntimeFiber<A, E>): X;
  onStart<A, E, R>(_context: Context<R>, _effect: Effect<A, E, R>, _parent: Option<RuntimeFiber<any, any>>, _fiber: RuntimeFiber<A, E>): void;
  onSuspend<A, E>(_fiber: RuntimeFiber<A, E>): void;
  zip<A>(right: Supervisor<A>): Supervisor<[T, A]>;
}

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>>>>

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

interface Supervisor<out T> extends Variance<T> {
  readonly value: Effect<T>;
  map<B>(f: (a: T) => B): Supervisor<B>;
  onEffect<A, E>(fiber: RuntimeFiber<A, E>, effect: Effect<any, any, any>): void;
  onEnd<A, E>(value: Exit<A, E>, fiber: RuntimeFiber<A, E>): void;
  onResume<A, E>(fiber: RuntimeFiber<A, E>): void;
  onStart<A, E, R>(context: Context<R>, effect: Effect<A, E, R>, parent: Option<RuntimeFiber<any, any>>, fiber: RuntimeFiber<A, E>): void;
  onSuspend<A, E>(fiber: RuntimeFiber<A, E>): void;
  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>>>