import { Env } from "@tsplus/stdlib/service/Env";
import { RuntimeFlags } from "@effect/core/io/RuntimeFlags/definition";
import { FiberRefs } from "@effect/core/io/FiberRefs/definition";
import { Effect } from "@effect/core/io/Effect/definition";
import { FiberId } from "@effect/core/io/FiberId/definition";
import { FiberRef } from "@effect/core/io/FiberRef/definition";
import { Supervisor } from "@effect/core/io/Supervisor/definition";
import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
import { FiberScope } from "@effect/core/io/FiberScope/definition";
import { Exit } from "@effect/core/io/Exit/definition";
import { identity } from "@tsplus/stdlib/data/Function";
import { FiberRuntime } from "@effect/core/io/Fiber/_internal/runtime";
export declare class AsyncFiber<E, A> {
    readonly fiber: FiberRuntime<E, A>;
    readonly _tag = "AsyncFiber";
    constructor(fiber: FiberRuntime<E, A>);
}
export declare class Runtime<R> {
    readonly environment: Env<R>;
    readonly runtimeFlags: RuntimeFlags;
    readonly fiberRefs: FiberRefs;
    constructor(environment: Env<R>, runtimeFlags: RuntimeFlags, fiberRefs: FiberRefs);
    unsafeFork: <E, A>(effect: import("../Effect").Effect<R, E, A>) => FiberRuntime<E, A>;
    unsafeRunWith: <E, A>(effect: import("../Effect").Effect<R, E, A>, k: (exit: import("../Exit").Exit<E, A>) => void) => (fiberId: FiberId) => (_: (exit: import("../Exit").Exit<E, A>) => void) => void;
    unsafeRunSync: <E, A>(effect: import("../Effect").Effect<R, E, A>) => A;
    unsafeRunSyncExit: <E, A>(effect: import("../Effect").Effect<R, E, A>) => import("../Exit").Exit<E, A>;
    /**
     * Executes the effect asynchronously, discarding the result of execution.
     *
     * This method is effectful and should only be invoked at the edges of your
     * program.
     */
    unsafeRunAsync: <E, A>(effect: import("../Effect").Effect<R, E, A>) => void;
    /**
     * Executes the effect asynchronously, eventually passing the exit value to
     * the specified callback.
     *
     * This method is effectful and should only be invoked at the edges of your
     * program.
     */
    unsafeRunAsyncWith: <E, A>(effect: import("../Effect").Effect<R, E, A>, k: (exit: import("../Exit").Exit<E, A>) => void) => void;
    /**
     * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
     * with the value of the effect once the effect has been executed, or will be
     * rejected with the first error or exception throw by the effect.
     *
     * This method is effectful and should only be used at the edges of your
     * program.
     */
    unsafeRunPromise: <E, A>(effect: import("../Effect").Effect<R, E, A>) => Promise<A>;
    /**
     * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
     * with the `Exit` state of the effect once the effect has been executed.
     *
     * This method is effectful and should only be used at the edges of your
     * program.
     */
    unsafeRunPromiseExit: <E, A>(effect: import("../Effect").Effect<R, E, A>) => Promise<import("../Exit").Exit<E, A>>;
}
//# sourceMappingURL=definition.d.ts.map