import * as E from "../../../Either";
import * as O from "../../../Option";
import * as Sy from "../../../Sync";
import type { FiberId } from "../../Fiber/FiberId";
import type { Cause } from "./model";
/**
 * ```haskell
 * as :: Functor f => b -> f a -> f b
 * ```
 *
 * Substitutes a value under a type constructor
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare const as: <E1>(e: E1) => <E>(fa: Cause<E>) => Cause<E1>;
/**
 * Extracts a list of non-recoverable errors from the `Cause`.
 */
export declare const defects: <E>(cause: Cause<E>) => ReadonlyArray<unknown>;
/**
 * Produces a list of all recoverable errors `E` in the `Cause`.
 */
export declare const failures: <E>(cause: Cause<E>) => readonly E[];
/**
 * Returns a set of interruptors, fibers that interrupted the fiber described
 * by this `Cause`.
 */
export declare const interruptors: <E>(cause: Cause<E>) => ReadonlySet<FiberId>;
/**
 * Determines if the `Cause` contains only interruptions and not any `Die` or
 * `Fail` causes.
 */
export declare const interruptedOnly: <E>(cause: Cause<E>) => boolean;
/**
 * @internal
 */
export declare const stripFailuresSafe: <E>(cause: Cause<E>) => Sy.IO<Cause<never>>;
/**
 * Discards all typed failures kept on this `Cause`.
 */
export declare const stripFailures: <E>(cause: Cause<E>) => Cause<never>;
/**
 * @internal
 */
export declare const stripInterruptsSafe: <E>(cause: Cause<E>) => Sy.IO<Cause<E>>;
/**
 * Discards all interrupts kept on this `Cause`.
 */
export declare const stripInterrupts: <E>(cause: Cause<E>) => Cause<E>;
/**
 * @internal
 */
export declare const keepDefectsSafe: <E>(cause: Cause<E>) => Sy.IO<O.Option<Cause<never>>>;
/**
 * Remove all `Fail` and `Interrupt` nodes from this `Cause`,
 * return only `Die` cause/finalizer defects.
 */
export declare const keepDefects: <E>(cause: Cause<E>) => O.Option<Cause<never>>;
export declare const sequenceCauseEitherSafe: <E, A>(cause: Cause<E.Either<E, A>>) => Sy.IO<E.Either<Cause<E>, A>>;
/**
 * Converts the specified `Cause<Either<E, A>>` to an `Either<Cause<E>, A>`.
 */
export declare const sequenceCauseEither: <E, A>(cause: Cause<E.Either<E, A>>) => E.Either<Cause<E>, A>;
export declare const sequenceCauseOptionSafe: <E>(cause: Cause<O.Option<E>>) => Sy.IO<O.Option<Cause<E>>>;
/**
 * Converts the specified `Cause<Option<E>>` to an `Option<Cause<E>>`.
 */
export declare const sequenceCauseOption: <E>(cause: Cause<O.Option<E>>) => O.Option<Cause<E>>;
/**
 * Retrieve the first checked error on the `Left` if available,
 * if there are no checked errors return the rest of the `Cause`
 * that is known to contain only `Die` or `Interrupt` causes.
 * */
export declare const failureOrCause: <E>(cause: Cause<E>) => E.Either<E, Cause<never>>;
/**
 * Squashes a `Cause` down to a single `Throwable`, chosen to be the
 * "most important" `Throwable`.
 */
export declare const squash: <E>(f: (e: E) => unknown) => (cause: Cause<E>) => unknown;
//# sourceMappingURL=combinators.d.ts.map