import { Stream } from "@effect/core/stream/Stream/definition";
import { Effect } from "@effect/core/io/Effect/definition";
import { Dequeue, Queue } from "@effect/core/io/Queue/definition/common";
import { Exit } from "@effect/core/io/Exit/definition";
import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
import { Deferred } from "@effect/core/io/Deferred/definition";
import { Predicate } from "@tsplus/stdlib/data/Predicate";
import { Ref } from "@effect/core/io/Ref/definition";
import { HashMap } from "@tsplus/stdlib/collections/HashMap/definition";
import type { GroupBy } from "@effect/core/stream/GroupBy/definition/base";
import { GroupBySym } from "@effect/core/stream/GroupBy/definition/base";
import { _A, _E, _K, _R, _V } from "@effect/core/stream/GroupBy/definition/symbols";
export declare class GroupByInternal<R, E, K, V, A> implements GroupBy<R, E, K, V, A> {
    readonly stream: Stream<R, E, A>;
    readonly key: (a: A) => Effect<R, E, readonly [K, V]>;
    readonly buffer: number;
    readonly [GroupBySym]: GroupBySym;
    readonly [_R]: (_: R) => void;
    readonly [_E]: () => E;
    readonly [_K]: () => K;
    readonly [_V]: () => V;
    readonly [_A]: () => A;
    constructor(stream: Stream<R, E, A>, key: (a: A) => Effect<R, E, readonly [K, V]>, buffer: number);
    /**
     * Run the function across all groups, collecting the results in an
     * arbitrary order.
     */
    apply<R1, E1, A1>(f: (k: K, stream: Stream<never, E, V>) => Stream<R1, E1, A1>): Stream<R | R1, E | E1, A1>;
    grouped(): Stream<R, E, readonly [K, Dequeue<Exit<Maybe<E>, V>>]>;
    /**
     * Only consider the first `n` groups found in the stream.
     */
    first(n: number): GroupByInternal<R, E, K, V, A>;
    /**
     * Filter the groups to be processed.
     */
    filter(f: Predicate<K>): GroupByInternal<R, E, K, V, A>;
}
/**
 * @tsplus macro remove
 */
export declare function concreteGroupBy<R, E, K, V, A>(_: GroupBy<R, E, K, V, A>): asserts _ is GroupByInternal<R, E, K, V, A>;
export declare class FirstInternal<R, E, K, V, A> extends GroupByInternal<R, E, K, V, A> {
    readonly n: number;
    constructor(stream: Stream<R, E, A>, key: (a: A) => Effect<R, E, readonly [K, V]>, buffer: number, n: number);
    grouped(): Stream<R, E, readonly [K, Dequeue<Exit<Maybe<E>, V>>]>;
}
export declare class FilterInternal<R, E, K, V, A> extends GroupByInternal<R, E, K, V, A> {
    readonly f: Predicate<K>;
    constructor(stream: Stream<R, E, A>, key: (a: A) => Effect<R, E, readonly [K, V]>, buffer: number, f: Predicate<K>);
    grouped(): Stream<R, E, readonly [K, Dequeue<Exit<Maybe<E>, V>>]>;
}
//# sourceMappingURL=GroupByInternal.d.ts.map