import type { ExecutionStrategy } from "../ExecutionStrategy";
import * as Ex from "../Exit";
import type { Exit } from "../Exit/model";
import type { Executor } from "../Fiber/executor";
import type { Fiber } from "../Fiber/model";
import * as M from "../Managed/_core";
import { Managed } from "../Managed/model";
import * as RM from "../Managed/ReleaseMap";
import * as T from "./_internal/effect";
export declare function releaseAllReleaseMaps(
   exit: Exit<any, any>,
   execStrategy: ExecutionStrategy
): (_: RM.ReleaseMap) => T.IO<any>;
/**
 * Applies the function `f` to each element of the `Iterable<A>` and runs
 * produced effects in parallel, discarding the results.
 *
 * For a sequential version of this method, see `foreach_`.
 *
 * Optimized to avoid keeping full tree of effects, so that method could be
 * able to handle large input sequences.
 * Behaves almost like this code:
 *
 * Additionally, interrupts all effects on any failure.
 */
export declare function traverseIUnitPar_<R, E, A>(as: Iterable<A>, f: (a: A) => T.Task<R, E, any>): T.Task<R, E, void>;
/**
 * Applies the function `f` to each element of the `Iterable<A>` and runs
 * produced effects in parallel, discarding the results.
 *
 * For a sequential version of this method, see `foreach_`.
 *
 * Optimized to avoid keeping full tree of effects, so that method could be
 * able to handle large input sequences.
 * Behaves almost like this code:
 *
 * Additionally, interrupts all effects on any failure.
 */
export declare const traverseIUnitPar: <R, E, A>(
   f: (a: A) => T.Task<R, E, any>
) => (as: Iterable<A>) => T.Task<R, E, void>;
/**
 * Applies the function `f` to each element of the `Iterable<A>` in parallel,
 * and returns the results in a new `readonly B[]`.
 *
 * For a sequential version of this method, see `foreach`.
 */
export declare const traverseIPar_: <R, E, A, B>(
   as: Iterable<A>,
   f: (a: A) => T.Task<R, E, B>
) => T.Task<R, E, readonly B[]>;
export declare const traverseIPar: <R, E, A, B>(
   f: (a: A) => T.Task<R, E, B>
) => (as: Iterable<A>) => T.Task<R, E, readonly B[]>;
/**
 * Applies the functionw `f` to each element of the `Iterable<A>` in parallel,
 * and returns the results in a new `readonly B[]`.
 *
 * Unlike `foreachPar`, this method will use at most up to `n` fibers.
 */
export declare const traverseIParN_: (
   n: number
) => <A, R, E, B>(as: Iterable<A>, f: (a: A) => T.Task<R, E, B>) => T.Task<R, E, readonly B[]>;
export declare const traverseIParN: (
   n: number
) => <R, E, A, B>(f: (a: A) => T.Task<R, E, B>) => (as: Iterable<A>) => T.Task<R, E, readonly B[]>;
/**
 * Run a task while acquiring the resource before and releasing it after
 */
export declare const useManaged: <A, R2, E2, B>(
   f: (a: A) => T.Task<R2, E2, B>
) => <R, E>(self: M.Managed<R, E, A>) => T.Task<R & R2, E2 | E, B>;
/**
 * Run a task while acquiring the resource before and releasing it after
 */
export declare const useManaged_: <R, E, A, R2, E2, B>(
   self: M.Managed<R, E, A>,
   f: (a: A) => T.Task<R2, E2, B>
) => T.Task<R & R2, E | E2, B>;
/**
 * Creates a `Managed` value that acquires the original resource in a fiber,
 * and provides that fiber. The finalizer for this value will interrupt the fiber
 * and run the original finalizer.
 */
export declare const forkManaged: <R, E, A>(self: M.Managed<R, E, A>) => M.Managed<R, never, Executor<E, A>>;
/**
 * Construct a `ReleaseMap` wrapped in a `Managed`. The `ReleaseMap` will
 * be released with the specified `ExecutionStrategy` as the release action
 * for the resulting `Managed`.
 */
export declare const makeManagedReleaseMap: (es: ExecutionStrategy) => Managed<unknown, never, RM.ReleaseMap>;
/**
 * Joins all fibers, awaiting their _successful_ completion.
 * Attempting to join a fiber that has erred will result in
 * a catchable error, _if_ that error does not result from interruption.
 */
export declare const joinAllFibers: <E, A>(as: Iterable<Fiber<E, A>>) => T.Task<unknown, E, readonly A[]>;
/**
 * Awaits on all fibers to be completed, successfully or not.
 */
export declare const awaitAllFibers: <E, A>(
   as: Iterable<Fiber<E, A>>
) => T.Task<unknown, never, Ex.Exit<E, readonly A[]>>;
//# sourceMappingURL=index.d.ts.map