import { Queue, Dequeue } from "@effect/core/io/Queue/definition/common";
import { ExecutionStrategy } from "@effect/core/io/ExecutionStrategy/definition";
import { Fiber } from "@effect/core/io/Fiber/definition";
import { Exit } from "@effect/core/io/Exit/definition";
import { ReleaseMap } from "@effect/core/io/Scope/ReleaseMap/definition";
import { MutableQueue } from "@tsplus/stdlib/collections/mutable/MutableQueue/definition";
import { Deferred } from "@effect/core/io/Deferred/definition";
import { AtomicBoolean } from "@tsplus/stdlib/data/AtomicBoolean";
import { EmptyMutableQueue } from "@tsplus/stdlib/collections/mutable/MutableQueue";
import { Effect } from "@effect/core/io/Effect/definition/base";
import type { Strategy } from "@effect/core/io/Queue/operations/strategy";
import { Chunk } from "@tsplus/stdlib/collections/Chunk";
import type { Collection } from "@tsplus/stdlib/collections/Collection";
import { Maybe } from "@tsplus/stdlib/data/Maybe";
/**
 * Applies the function `f` to each element of the `Collection<A>` and returns
 * the results in a new `Chunk<B>`.
 *
 * For a parallel version of this method, see `forEachPar`. If you do not need
 * the results, see `forEachDiscard` for a more efficient implementation.
 * @tsplus static effect/core/io/Effect.Ops forEach
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function forEach<A, R, E, B>(as: Collection<A>, f: (a: A) => Effect<R, E, B>): Effect<R, E, Chunk<B>>;
/**
 * Same as `forEach`, except that the function `f` is supplied
 * a second argument that corresponds to the index (starting from 0)
 * of the current element being iterated over.
 * @tsplus static effect/core/io/Effect.Ops forEachWithIndex
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function forEachWithIndex<A, R, E, B>(as: Collection<A>, f: (a: A, i: number) => Effect<R, E, B>): Effect<R, E, Chunk<B>>;
/**
 * Applies the function `f` to each element of the `Collection<A>` and runs
 * produced effects sequentially.
 *
 * Equivalent to `unit(forEach(as, f))`, but without the cost of building
 * the list of results.
 * @tsplus static effect/core/io/Effect.Ops forEachDiscard
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function forEachDiscard<R, E, A, X>(as: Collection<A>, f: (a: A) => Effect<R, E, X>): Effect<R, E, void>;
/**
 * Applies the function `f` to each element of the `Collection<A>` in parallel,
 * and returns the results in a new `Chunk<B>`.
 *
 * For a sequential version of this method, see `forEach`.
 * @tsplus static effect/core/io/Effect.Ops forEachPar
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function forEachPar<R, E, A, B>(as: Collection<A>, f: (a: A) => Effect<R, E, B>): Effect<R, E, Chunk<B>>;
/**
 * Same as `forEachPar`, except that the function `f` is supplied
 * a second argument that corresponds to the index (starting from 0)
 * of the current element being iterated over.
 * @tsplus static effect/core/io/Effect.Ops forEachParWithIndex
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function forEachParWithIndex<R, E, A, B>(as: Collection<A>, f: (a: A, i: number) => Effect<R, E, B>): Effect<R, E, Chunk<B>>;
/**
 * Applies the function `f` to each element of the `Collection<A>` and runs
 * produced effects in parallel, discarding the results.
 *
 * For a sequential version of this method, see `forEachDiscard`.
 *
 * Optimized to avoid keeping full tree of effects, so that method could be
 * able to handle large input sequences. Additionally, interrupts all effects
 * on any failure.
 * @tsplus static effect/core/io/Effect.Ops forEachParDiscard
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function forEachParDiscard<R, E, A, X>(as: Collection<A>, f: (a: A) => Effect<R, E, X>): Effect<R, E, void>;
/**
 * Applies the function `f` to each element of the `Collection<A>` and returns
 * the result in a new `Chunk<B>` using the specified execution strategy.
 * @tsplus static effect/core/io/Effect.Ops forEachExec
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function forEachExec<R, E, A, B>(as: Collection<A>, f: (a: A) => Effect<R, E, B>, strategy: ExecutionStrategy): Effect<R, E, Chunk<B>>;
/**
 * Evaluate each effect in the structure from left to right, and collect the
 * results. For a parallel version, see `collectAllPar`.
 * @tsplus static effect/core/io/Effect.Ops collectAll
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAll<R, E, A>(as: Collection<Effect<R, E, A>>): Effect<R, E, Chunk<A>>;
/**
 * Evaluate each effect in the structure in parallel, and collect the
 * results. For a sequential version, see `collectAll`.
 * @tsplus static effect/core/io/Effect.Ops collectAllPar
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllPar<R, E, A>(as: Collection<Effect<R, E, A>>): Effect<R, E, Chunk<A>>;
/**
 * Evaluate each effect in the structure from left to right, and discard the
 * results. For a parallel version, see `collectAllParDiscard`.
 * @tsplus static effect/core/io/Effect.Ops collectAllDiscard
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllDiscard<R, E, A>(as: Collection<Effect<R, E, A>>): Effect<R, E, void>;
/**
 * Evaluate each effect in the structure in parallel, and discard the
 * results. For a sequential version, see `collectAllDiscard`.
 * @tsplus static effect/core/io/Effect.Ops collectAllParDiscard
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllParDiscard<R, E, A>(as: Collection<Effect<R, E, A>>): Effect<R, E, void>;
/**
 * Evaluate each effect in the structure with `collectAll`, and collect
 * the results with given partial function.
 * @tsplus static effect/core/io/Effect.Ops collectAllWith
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllWith<R, E, A, B>(as: Collection<Effect<R, E, A>>, pf: (a: A) => Maybe<B>): Effect<R, E, Chunk<B>>;
/**
 * Evaluate each effect in the structure with `collectAll`, and collect
 * the results with given partial function.
 * @tsplus static effect/core/io/Effect.Ops collectAllWithPar
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllWithPar<R, E, A, B>(as: Collection<Effect<R, E, A>>, pf: (a: A) => Maybe<B>): Effect<R, E, Chunk<B>>;
/**
 * Returns a filtered, mapped subset of the elements of this chunk based on a
 * partial function.
 * @tsplus static effect/core/io/Effect.Ops collectAllWithEffect
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllWithEffect<A, R, E, B>(self: Collection<A>, f: (a: A) => Maybe<Effect<R, E, B>>): Effect<R, E, Chunk<B>>;
/**
 * Evaluate and run each effect in the structure and collect discarding failed ones.
 * @tsplus static effect/core/io/Effect.Ops collectAllSuccesses
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllSuccesses<R, E, A>(as: Collection<Effect<R, E, A>>): Effect<R, never, Chunk<A>>;
/**
 * Evaluate and run each effect in the structure in parallel, and collect discarding failed ones.
 * @tsplus static effect/core/io/Effect.Ops collectAllSuccessesPar
 * @tsplus location "@effect/core/io/Effect/operations/excl-forEach"
 */
export declare function collectAllSuccessesPar<R, E, A>(as: Collection<Effect<R, E, A>>): Effect<R, never, Chunk<A>>;
/**
 * 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 function fiberJoinAll<E, A>(as: Collection<Fiber<E, A>>): Effect<never, E, Chunk<A>>;
/**
 * Awaits on all fibers to be completed, successfully or not.
 */
export declare function fiberWaitAll<E, A>(as: Collection<Fiber<E, A>>): Effect<never, never, Exit<E, Chunk<A>>>;
/**
 * Releases all the finalizers in the releaseMap according to the ExecutionStrategy.
 */
export declare function releaseMapReleaseAll(self: ReleaseMap, ex: Exit<unknown, unknown>, execStrategy: ExecutionStrategy): Effect<never, never, unknown>;
export declare function makeBoundedQueue<A>(requestedCapacity: number): Effect<never, never, Queue<A>>;
export declare function createQueue<A>(queue: MutableQueue<A>, strategy: Strategy<A>): Effect<never, never, Queue<A>>;
export declare function unsafeCreateQueue<A>(queue: MutableQueue<A>, takers: MutableQueue<Deferred<never, A>>, shutdownHook: Deferred<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>): Queue<A>;
export declare function makeBackPressureStrategy<A>(): BackPressureStrategy<A>;
export declare class BackPressureStrategy<A> implements Strategy<A> {
    /**
     * - `A` is an item to add
     * - `Deferred<never, boolean>` is the deferred completing the whole `offerAll`
     * - `boolean` indicates if it's the last item to offer (deferred should be
     *    completed once this item is added)
     */
    private putters;
    handleSurplus(as: Chunk<A>, queue: MutableQueue<A>, takers: MutableQueue<Deferred<never, A>>, isShutdown: AtomicBoolean): Effect<never, never, boolean>;
    unsafeRemove(deferred: Deferred<never, boolean>): void;
    unsafeOffer(as: Chunk<A>, deferred: Deferred<never, boolean>): void;
    unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Deferred<never, A>>): void;
    get surplusSize(): number;
    get shutdown(): Effect<never, never, void>;
}
//# sourceMappingURL=excl-forEach.d.ts.map