import * as T from "../../Task/_core";
import type { FiberId } from "../FiberId";
import type { Fiber } from "../model";
/**
 * ```haskell
 * interrupt :: Fiber e a -> Task _ _ (Exit e a)
 * ```
 *
 * Interrupts the fiber from whichever fiber is calling this method. If the
 * fiber has already exited, the returned effect will resume immediately.
 * Otherwise, the effect will resume when the fiber exits.
 */
export declare const interrupt: <E, A>(fiber: Fiber<E, A>) => T.Task<unknown, never, import("../../Exit").Exit<E, A>>;
/**
 * ```haskell
 * interruptAllAs_ :: (Iterable (Fiber Any Any), FiberId) -> Task _ _ ()
 * ```
 *
 * Interrupts all fibers as by the specified fiber, awaiting their interruption.
 */
export declare const interruptAllAs_: (fs: Iterable<Fiber<any, any>>, id: FiberId) => T.IO<void>;
/**
 * ```haskell
 * interruptAllAs :: FiberId -> Iterable (Fiber Any Any) -> Task _ _ ()
 * ```
 *
 * Interrupts all fibers as by the specified fiber, awaiting their interruption.
 */
export declare const interruptAllAs: (id: FiberId) => (fs: Iterable<Fiber<any, any>>) => T.IO<void>;
/**
 * ```haskell
 * interruptFork :: Fiber e a -> Task _ _ ()
 * ```
 *
 * Interrupts the fiber from whichever fiber is calling this method. The
 * interruption will happen in a separate daemon fiber, and the returned
 * effect will always resume immediately without waiting.
 */
export declare const interruptFork: <E, A>(fiber: Fiber<E, A>) => T.Task<unknown, never, void>;
//# sourceMappingURL=interrupt.d.ts.map