effect 3.7.1 → 3.7.3

package/dist/dts/Stream.d.ts

@@ -465,8 +465,22 @@ export declare const branchAfter: {
  * @category utils
  */
 export declare const broadcast: {
-    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>;
-    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>;
+    <N extends number>(n: N, maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>;
+    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>;
 };
 /**
  * Fan out the stream, producing a dynamic number of streams that have the
@@ -477,8 +491,22 @@ export declare const broadcast: {
  * @category utils
  */
 export declare const broadcastDynamic: {
-    (maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
-    <A, E, R>(self: Stream<A, E, R>, maximumLag: number): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
+    (maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
 };
 /**
  * Converts the stream to a scoped list of queues. Every value will be
@@ -491,8 +519,22 @@ export declare const broadcastDynamic: {
  * @category utils
  */
 export declare const broadcastedQueues: {
-    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, R | Scope.Scope>;
-    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>;
+    <N extends number>(n: N, maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>;
+    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>;
 };
 /**
  * Converts the stream to a scoped dynamic amount of queues. Every chunk will
@@ -505,8 +547,22 @@ export declare const broadcastedQueues: {
  * @category utils
  */
 export declare const broadcastedQueuesDynamic: {
-    (maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, R | Scope.Scope>;
-    <A, E, R>(self: Stream<A, E, R>, maximumLag: number): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>;
+    (maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, maximumLag: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>;
 };
 /**
  * Allows a faster producer to progress independently of a slower consumer by
@@ -4048,8 +4104,22 @@ export declare const timeoutTo: {
  * @category destructors
  */
 export declare const toPubSub: {
-    (capacity: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>;
-    <A, E, R>(self: Stream<A, E, R>, capacity: number): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>;
+    (capacity: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, capacity: number | {
+        readonly capacity: "unbounded";
+        readonly replay?: number | undefined;
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
+        readonly replay?: number | undefined;
+    }): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>;
 };
 /**
  * Returns in a scope a ZIO effect that can be used to repeatedly pull chunks