import { Chunk } from "@tsplus/stdlib/collections/Chunk/definition";
import { AtomicReference } from "@tsplus/stdlib/data/AtomicReference";
import { Effect } from "@effect/core/io/Effect/definition";
import type { Exit } from "@effect/core/io/Exit/definition";
import type { FiberRuntime } from "@effect/core/io/Fiber/_internal/runtime";
import type { Patch as P } from "@effect/core/io/Supervisor/patch";
import type { SortedSet } from "@tsplus/stdlib/collections/SortedSet";
import type { Maybe } from "@tsplus/stdlib/data/Maybe";
import type { Env } from "@tsplus/stdlib/service/Env";
export declare const SupervisorURI: unique symbol;
export type SupervisorURI = typeof SupervisorURI;
export declare namespace Supervisor {
    type Patch = P;
}
/**
 * A `Supervisor<A>` is allowed to supervise the launching and termination of
 * fibers, producing some visible value of type `A` from the supervision.
 *
 * @tsplus type effect/core/io/Supervisor
 * @tsplus companion effect/core/io/Supervisor.Ops
 */
export declare abstract class Supervisor<T> {
    readonly [SupervisorURI]: {
        _T: (_: never) => 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.
     */
    abstract get value(): Effect<never, never, T>;
    abstract onStart<R, E, A>(environment: Env<R>, effect: Effect<R, E, A>, parent: Maybe<FiberRuntime<any, any>>, fiber: FiberRuntime<E, A>): void;
    abstract onEnd<E, A>(value: Exit<E, A>, fiber: FiberRuntime<E, A>): void;
    abstract onEffect<E, A>(fiber: FiberRuntime<E, A>, effect: Effect<any, any, any>): void;
    abstract onSuspend<E, A>(fiber: FiberRuntime<E, A>): void;
    abstract onResume<E, A>(fiber: FiberRuntime<E, A>): 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<B>(right: Supervisor<B>): Supervisor<readonly [T, B]>;
}
export declare class ProxySupervisor<T> extends Supervisor<T> {
    readonly underlying: Supervisor<any>;
    readonly value0: () => Effect<never, never, T>;
    constructor(underlying: Supervisor<any>, value0: () => Effect<never, never, T>);
    get value(): Effect<never, never, T>;
    onStart<R, E, A>(environment: Env<R>, effect: Effect<R, E, A>, parent: Maybe<FiberRuntime<any, any>>, fiber: FiberRuntime<E, A>): void;
    onEnd<E, A>(value: Exit<E, A>, fiber: FiberRuntime<E, A>): void;
    onEffect<E, A>(fiber: FiberRuntime<E, A>, effect: Effect<any, any, any>): void;
    onSuspend<E, A>(fiber: FiberRuntime<E, A>): void;
    onResume<E, A>(fiber: FiberRuntime<E, A>): void;
}
export declare class Zip<T0, T1> extends Supervisor<readonly [T0, T1]> {
    readonly left: Supervisor<T0>;
    readonly right: Supervisor<T1>;
    constructor(left: Supervisor<T0>, right: Supervisor<T1>);
    get value(): Effect<never, never, readonly [T0, T1]>;
    onStart<R, E, A>(environment: Env<R>, effect: Effect<R, E, A>, parent: Maybe<FiberRuntime<any, any>>, fiber: FiberRuntime<E, A>): void;
    onEnd<E, A>(value: Exit<E, A>, fiber: FiberRuntime<E, A>): void;
    onEffect<E, A>(fiber: FiberRuntime<E, A>, effect: Effect<any, any, any>): void;
    onSuspend<E, A>(fiber: FiberRuntime<E, A>): void;
    onResume<E, A>(fiber: FiberRuntime<E, A>): void;
}
export declare class Track extends Supervisor<Chunk<FiberRuntime<any, any>>> {
    readonly fibers: Set<FiberRuntime<any, any>>;
    get value(): Effect<never, never, Chunk<FiberRuntime<any, any>>>;
    onStart<R, E, A>(_environment: Env<R>, _effect: Effect<R, E, A>, _parent: Maybe<FiberRuntime<any, any>>, fiber: FiberRuntime<E, A>): void;
    onEnd<E, A>(_value: Exit<E, A>, fiber: FiberRuntime<E, A>): void;
    onEffect<E, A>(_fiber: FiberRuntime<E, A>, _effect: Effect<any, any, any>): void;
    onSuspend<E, A>(_fiber: FiberRuntime<E, A>): void;
    onResume<E, A>(_fiber: FiberRuntime<E, A>): void;
}
export declare class Const<T> extends Supervisor<T> {
    readonly effect: Effect<never, never, T>;
    constructor(effect: Effect<never, never, T>);
    get value(): Effect<never, never, T>;
    onStart<R, E, A>(_environment: Env<R>, _effect: Effect<R, E, A>, _parent: Maybe<FiberRuntime<any, any>>, _fiber: FiberRuntime<E, A>): void;
    onEnd<E, A>(_value: Exit<E, A>, _fiber: FiberRuntime<E, A>): void;
    onEffect<E, A>(_fiber: FiberRuntime<E, A>, _effect: Effect<any, any, any>): void;
    onSuspend<E, A>(_fiber: FiberRuntime<E, A>): void;
    onResume<E, A>(_fiber: FiberRuntime<E, A>): void;
}
/**
 * Creates a new supervisor that tracks children in a set.
 * @tsplus static effect/core/io/Supervisor.Ops unsafeTrack
 * @tsplus location "@effect/core/io/Supervisor/definition"
 */
export declare function unsafeTrack(): Supervisor<Chunk<FiberRuntime<any, any>>>;
/**
 * Creates a new supervisor that tracks children in a set.
 * @tsplus static effect/core/io/Supervisor.Ops track
 * @tsplus location "@effect/core/io/Supervisor/definition"
 */
export declare const track: Effect<never, never, Supervisor<import("@tsplus/stdlib/collections/Chunk").Chunk<FiberRuntime<any, any>>>>;
/**
 * Creates a new supervisor that constantly yields effect when polled
 * @tsplus static effect/core/io/Supervisor.Ops fromEffect
 * @tsplus location "@effect/core/io/Supervisor/definition"
 */
export declare function fromEffect<A>(effect: Effect<never, never, A>): Supervisor<A>;
/**
 * A supervisor that doesn't do anything in response to supervision events.
 * @tsplus static effect/core/io/Supervisor.Ops none
 * @tsplus location "@effect/core/io/Supervisor/definition"
 */
export declare const none: Supervisor<void>;
/**
 * Creates a new supervisor that tracks children in a set.
 * @tsplus static effect/core/io/Supervisor.Ops fibersIn
 * @tsplus location "@effect/core/io/Supervisor/definition"
 */
export declare function fibersIn(ref: AtomicReference<SortedSet<FiberRuntime<any, any>>>): Effect<never, never, Supervisor<SortedSet<FiberRuntime<any, any>>>>;
//# sourceMappingURL=definition.d.ts.map