the-moby-effect 1.45.0-alpha.11 → 1.45.0-alpha.13

package/dist/dts/demux/Demux.d.ts

@@ -9,17 +9,58 @@ import * as Effect from "effect/Effect";
 import * as Scope from "effect/Scope";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
-import { CompressedDemuxOutput } from "./Compressed.js";
+import { CompressedDemuxOutput, CompressedStdinStdoutStderrOutput } from "./Compressed.js";
 import { MultiplexedStreamSocket } from "./Multiplexed.js";
-import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./Raw.js";
+import { RawStreamSocket } from "./Raw.js";
+/** @since 1.0.0 */
+export declare namespace Demux {
+    /**
+     * @since 1.0.0
+     * @category Types
+     */
+    type StdinStdoutStderrSocketOptions = {
+        stdin: RawStreamSocket;
+        stdout?: never;
+        stderr?: never;
+    } | {
+        stdin?: never;
+        stdout: RawStreamSocket;
+        stderr?: never;
+    } | {
+        stdin?: never;
+        stdout?: never;
+        stderr: RawStreamSocket;
+    } | {
+        stdin: RawStreamSocket;
+        stdout: RawStreamSocket;
+        stderr?: never;
+    } | {
+        stdin: RawStreamSocket;
+        stdout?: never;
+        stderr: RawStreamSocket;
+    } | {
+        stdin?: never;
+        stdout: RawStreamSocket;
+        stderr: RawStreamSocket;
+    } | {
+        stdin: RawStreamSocket;
+        stdout: RawStreamSocket;
+        stderr: RawStreamSocket;
+    };
+    /**
+     * @since 1.0.0
+     * @category Types
+     */
+    type AnySocketOptions = RawStreamSocket | MultiplexedStreamSocket | StdinStdoutStderrSocketOptions;
+}
 /**
- * Demux either a bidirectional raw socket, multiplexed socket, or
- * unidirectional raw socket(s) to a single sink.
+ * Demux either a raw socket, multiplexed socket, or multiple raw socket(s) to a
+ * single sink.
  *
  * @since 1.0.0
  * @category Demux
  * @example
- *     // Demux a bidirectional raw socket to one sink
+ *     // Demux a single raw socket to one sink
  *     import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
  *     import * as Chunk from "effect/Chunk";
  *     import * as Effect from "effect/Effect";
@@ -63,7 +104,7 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         // Since the container was started with "tty: true",
  *         // we should get a raw socket here
  *         const socket:
- *             | DemuxRaw.BidirectionalRawStreamSocket
+ *             | DemuxRaw.RawStreamSocket
  *             | DemuxMultiplexed.MultiplexedStreamSocket =
  *             yield* containers.attach({
  *                 stdin: true,
@@ -73,8 +114,8 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *                 id: containerId,
  *             });
  *         assert.ok(
- *             DemuxRaw.isBidirectionalRawStreamSocket(socket),
- *             "Expected a bidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(socket),
+ *             "Expected a raw socket"
  *         );
  *
  *         // Demux to a single sink
@@ -97,7 +138,7 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         .pipe(NodeRuntime.runMain);
  *
  * @example
- *     // Demux a bidirectional multiplexed socket to one sink
+ *     // Demux a multiplexed socket to one sink
  *     import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
  *     import * as Chunk from "effect/Chunk";
  *     import * as Effect from "effect/Effect";
@@ -141,7 +182,7 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         // Since the container was started with "tty: false",
  *         // we should get a multiplexed socket here
  *         const socket:
- *             | DemuxRaw.BidirectionalRawStreamSocket
+ *             | DemuxRaw.RawStreamSocket
  *             | DemuxMultiplexed.MultiplexedStreamSocket =
  *             yield* containers.attach({
  *                 stdin: true,
@@ -175,7 +216,7 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         .pipe(NodeRuntime.runMain);
  *
  * @example
- *     // Demux unidirectional sockets to one sink
+ *     // Demux multiple raw sockets to one sink
  *     import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
  *     import * as NodeSocket from "@effect/platform-node/NodeSocket";
  *     import * as Chunk from "effect/Chunk";
@@ -217,36 +258,36 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         });
  *
  *         // It doesn't matter what tty option we start the container
- *         // with here, we will only get a unidirectional socket
- *         const stdinSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         // with here, we will only get a raw socket
+ *         const stdinSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stdin: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
- *         const stdoutSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         const stdoutSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stdout: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
- *         const stderrSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         const stderrSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stderr: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stdinSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stdinSocket),
+ *             "Expected a raw socket"
  *         );
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stdoutSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stdoutSocket),
+ *             "Expected a raw socket"
  *         );
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stderrSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stderrSocket),
+ *             "Expected a raw socket"
  *         );
  *
  *         // Demux to a single sink
@@ -280,7 +321,7 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         .pipe(NodeRuntime.runMain);
  *
  * @example
- *     // Demux unidirectional socket to one sink
+ *     // Demux a single raw socket to one sink
  *     import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
  *     import * as NodeSocket from "@effect/platform-node/NodeSocket";
  *     import * as Chunk from "effect/Chunk";
@@ -326,16 +367,16 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         });
  *
  *         // It doesn't matter what tty option we start the container
- *         // with here, we will only get a unidirectional socket
- *         const stdoutSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         // with here, we will only get a raw socket
+ *         const stdoutSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stdout: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stdoutSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stdoutSocket),
+ *             "Expected a raw socket"
  *         );
  *
  *         // Demux to a single sink
@@ -355,12 +396,12 @@ import { BidirectionalRawStreamSocket, UnidirectionalRawStreamSocket } from "./R
  *         .pipe(NodeRuntime.runMain);
  */
 export declare const demuxToSingleSink: {
-    <A1, E1, E2, R1, R2>(socket: BidirectionalRawStreamSocket, source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
+    <A1, E1, E2, R1, R2>(socket: RawStreamSocket, source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
         encoding?: string | undefined;
-    } | undefined): Effect.Effect<A1, E1 | E2 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
+    } | undefined): Effect.Effect<A1, E1 | E2 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
     <A1, E1, E2, R1, R2>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
         encoding?: string | undefined;
-    } | undefined): (socket: BidirectionalRawStreamSocket) => Effect.Effect<A1, E1 | E2 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
+    } | undefined): (socket: RawStreamSocket) => Effect.Effect<A1, E1 | E2 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
     <A1, E1, E2, R1, R2>(socket: MultiplexedStreamSocket, source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
         bufferSize?: number | undefined;
         encoding?: string | undefined;
@@ -369,78 +410,38 @@ export declare const demuxToSingleSink: {
         bufferSize?: number | undefined;
         encoding?: string | undefined;
     } | undefined): (socket: MultiplexedStreamSocket) => Effect.Effect<A1, E1 | E2 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
-    <A1, E1, E2, R1, R2>(sockets: {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    }, source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
+    <A1, E1, E2, R1, R2>(sockets: Demux.StdinStdoutStderrSocketOptions, source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
         encoding?: string | undefined;
-    } | undefined): Effect.Effect<A1, E1 | E2 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
+    } | undefined): Effect.Effect<A1, E1 | E2 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
     <A1, E1, E2, R1, R2>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
         encoding?: string | undefined;
-    } | undefined): (sockets: {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    }) => Effect.Effect<A1, E1 | E2 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
+    } | undefined): (sockets: Demux.StdinStdoutStderrSocketOptions) => Effect.Effect<A1, E1 | E2 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
 };
 /**
- * Demux either a multiplexed socket or unidirectional socket(s) to separate
- * sinks. If you need to also demux a bidirectional raw socket, then use
+ * Like {@link demuxToSingleSink}, but with unknown input socket.
+ *
+ * @since 1.0.0
+ * @category Demux
+ */
+export declare const demuxUnknownToSingleSink: {
+    <A1, E1, E2, R1, R2>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
+        bufferSize?: number | undefined;
+        encoding?: string | undefined;
+    } | undefined): (socket: Demux.AnySocketOptions) => Effect.Effect<A1, E1 | E2 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
+    <A1, E1, E2, R1, R2>(socket: Demux.AnySocketOptions, source: Stream.Stream<string | Uint8Array, E1, R1>, sink: Sink.Sink<A1, string, string, E2, R2>, options?: {
+        bufferSize?: number | undefined;
+        encoding?: string | undefined;
+    } | undefined): Effect.Effect<A1, E1 | E2 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>>;
+};
+/**
+ * Demux either a multiplexed socket or multiple raw socket to separate sinks.
+ * If you need to also demux a single raw socket, then use
  * {@link demuxUnknownToSeparateSinks} instead.
  *
  * @since 1.0.0
  * @category Demux
  * @example
- *     // Demux a bidirectional multiplexed socket to two sinks
+ *     // Demux a multiplexed socket to two sinks
  *     import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
  *     import * as Chunk from "effect/Chunk";
  *     import * as Effect from "effect/Effect";
@@ -484,7 +485,7 @@ export declare const demuxToSingleSink: {
  *         // Since the container was started with "tty: false",
  *         // we should get a multiplexed socket here
  *         const socket:
- *             | DemuxRaw.BidirectionalRawStreamSocket
+ *             | DemuxRaw.RawStreamSocket
  *             | DemuxMultiplexed.MultiplexedStreamSocket =
  *             yield* containers.attach({
  *                 stdin: true,
@@ -519,7 +520,7 @@ export declare const demuxToSingleSink: {
  *         .pipe(NodeRuntime.runMain);
  *
  * @example
- *     // Demux unidirectional sockets to two sinks
+ *     // Demux multiple raw sockets to two sinks
  *     import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
  *     import * as NodeSocket from "@effect/platform-node/NodeSocket";
  *     import * as Chunk from "effect/Chunk";
@@ -561,36 +562,36 @@ export declare const demuxToSingleSink: {
  *         });
  *
  *         // It doesn't matter what tty option we start the container
- *         // with here, we will only get a unidirectional socket
- *         const stdinSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         // with here, we will only get a raw socket
+ *         const stdinSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stdin: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
- *         const stdoutSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         const stdoutSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stdout: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
- *         const stderrSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         const stderrSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stderr: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stdinSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stdinSocket),
+ *             "Expected a raw socket"
  *         );
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stdoutSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stdoutSocket),
+ *             "Expected a raw socket"
  *         );
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stderrSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stderrSocket),
+ *             "Expected a raw socket"
  *         );
  *
  *         // Demux to a single sink
@@ -619,7 +620,7 @@ export declare const demuxToSingleSink: {
  *         .pipe(NodeRuntime.runMain);
  *
  * @example
- *     // Demux unidirectional socket to two sinks
+ *     // Demux single raw socket to two sinks
  *     import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
  *     import * as NodeSocket from "@effect/platform-node/NodeSocket";
  *     import * as Chunk from "effect/Chunk";
@@ -665,16 +666,16 @@ export declare const demuxToSingleSink: {
  *         });
  *
  *         // It doesn't matter what tty option we start the container
- *         // with here, we will only get a unidirectional socket
- *         const stdoutSocket: DemuxRaw.UnidirectionalRawStreamSocket =
+ *         // with here, we will only get a raw socket
+ *         const stdoutSocket: DemuxRaw.RawStreamSocket =
  *             yield* containers.attachWebsocket({
  *                 stdout: true,
  *                 stream: true,
  *                 id: containerId,
  *             });
  *         assert.ok(
- *             DemuxRaw.isUnidirectionalRawStreamSocket(stdoutSocket),
- *             "Expected a unidirectional raw socket"
+ *             DemuxRaw.isRawStreamSocket(stdoutSocket),
+ *             "Expected a raw socket"
  *         );
  *
  *         // Demux to a single sink
@@ -704,89 +705,33 @@ export declare const demuxToSeparateSinks: {
         bufferSize?: number | undefined;
         encoding?: string | undefined;
     } | undefined): (socket: MultiplexedStreamSocket) => Effect.Effect<CompressedDemuxOutput<A1, A2>, E1 | E2 | E3 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
-    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    }>(sockets: SocketOptions, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends Demux.StdinStdoutStderrSocketOptions>(sockets: SocketOptions, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
         encoding?: string | undefined;
-    } | undefined): Effect.Effect<SocketOptions["stdout"] extends UnidirectionalRawStreamSocket ? SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<A1, A2> : CompressedDemuxOutput<A1, void> : SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<void, A2> : CompressedDemuxOutput<void, void>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
-    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    }>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+    } | undefined): Effect.Effect<CompressedStdinStdoutStderrOutput<SocketOptions, A1, A2>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
+    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends Demux.StdinStdoutStderrSocketOptions>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
         encoding?: string | undefined;
-    } | undefined): (sockets: SocketOptions) => Effect.Effect<SocketOptions["stdout"] extends UnidirectionalRawStreamSocket ? SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<A1, A2> : CompressedDemuxOutput<A1, void> : SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<void, A2> : CompressedDemuxOutput<void, void>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
+    } | undefined): (sockets: SocketOptions) => Effect.Effect<CompressedStdinStdoutStderrOutput<SocketOptions, A1, A2>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
 };
 /**
- * Demux a bidirectional raw socket, multiplexed socket, or unidirectional raw
- * sockets to two sinks. If given a bidirectional raw stream socket, then stdout
- * and stderr will be combined on the same sink. If given a multiplexed stream
- * socket, then stdout and stderr will be forwarded to different sinks. If given
- * a unidirectional raw stream sockets, then you are only required to provide
- * one for stdout but can also provide sockets for stdin and stderr as well. The
- * return type will depend on the type of socket provided, so this isn't
- * suitable for all use cases.
+ * Demux a single raw socket, multiplexed socket, or multiple raw sockets to two
+ * sinks. If given a single raw stream socket, then stdout and stderr will be
+ * combined on the same sink. If given a multiplexed stream socket, then stdout
+ * and stderr will be forwarded to different sinks. If given multiple raw stream
+ * sockets, then you can choose which ones to provide. The return type will
+ * depend on the type of socket provided, so this isn't suitable for all use
+ * cases. If you need a unified signature, you should use
+ * {@link demuxUnknownToSeparateSinks}.
  *
  * @since 1.0.0
  * @category Demux
  */
-export declare const demuxUnknownToSeparateSinks: {
-    <A1, A2, E1, E2, E3, R1, R2, R3>(socket: BidirectionalRawStreamSocket, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+export declare const demuxAnyToSeparateSinks: {
+    <A1, A2, E1, E2, E3, R1, R2, R3>(socket: RawStreamSocket, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
         encoding?: string | undefined;
     } | undefined): Effect.Effect<A1, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
     <A1, A2, E1, E2, E3, R1, R2, R3>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
         encoding?: string | undefined;
-    } | undefined): (socket: BidirectionalRawStreamSocket) => Effect.Effect<A1, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
+    } | undefined): (socket: RawStreamSocket) => Effect.Effect<A1, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
     <A1, A2, E1, E2, E3, R1, R2, R3>(socket: MultiplexedStreamSocket, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
         bufferSize?: number | undefined;
         encoding?: string | undefined;
@@ -795,67 +740,28 @@ export declare const demuxUnknownToSeparateSinks: {
         bufferSize?: number | undefined;
         encoding?: string | undefined;
     } | undefined): (socket: MultiplexedStreamSocket) => Effect.Effect<CompressedDemuxOutput<A1, A2>, E1 | E2 | E3 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
-    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    }>(sockets: SocketOptions, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends Demux.StdinStdoutStderrSocketOptions>(sockets: SocketOptions, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
         encoding?: string | undefined;
-    } | undefined): Effect.Effect<SocketOptions["stdout"] extends UnidirectionalRawStreamSocket ? SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<A1, A2> : CompressedDemuxOutput<A1, void> : SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<void, A2> : CompressedDemuxOutput<void, void>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
-    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin?: never;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr?: never;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout?: never;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin?: never;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    } | {
-        stdin: UnidirectionalRawStreamSocket;
-        stdout: UnidirectionalRawStreamSocket;
-        stderr: UnidirectionalRawStreamSocket;
-    }>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+    } | undefined): Effect.Effect<CompressedStdinStdoutStderrOutput<SocketOptions, A1, A2>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
+    <A1, A2, E1, E2, E3, R1, R2, R3, SocketOptions extends Demux.StdinStdoutStderrSocketOptions>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+        encoding?: string | undefined;
+    } | undefined): (sockets: SocketOptions) => Effect.Effect<CompressedStdinStdoutStderrOutput<SocketOptions, A1, A2>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
+};
+/**
+ * Like {@link demuxAnyToSeparateSinks}, but with unknown sockets and a unified
+ * signature.
+ *
+ * @since 1.0.0
+ * @category Demux
+ */
+export declare const demuxUnknownToSeparateSinks: {
+    <A1, A2, E1, E2, E3, R1, R2, R3>(source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+        bufferSize?: number | undefined;
+        encoding?: string | undefined;
+    } | undefined): (socket: Demux.AnySocketOptions) => Effect.Effect<void, E1 | E2 | E3 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
+    <A1, A2, E1, E2, E3, R1, R2, R3>(socket: Demux.AnySocketOptions, source: Stream.Stream<string | Uint8Array, E1, R1>, sink1: Sink.Sink<A1, string, string, E2, R2>, sink2: Sink.Sink<A2, string, string, E3, R3>, options?: {
+        bufferSize?: number | undefined;
         encoding?: string | undefined;
-    } | undefined): (sockets: SocketOptions) => Effect.Effect<SocketOptions["stdout"] extends UnidirectionalRawStreamSocket ? SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<A1, A2> : CompressedDemuxOutput<A1, void> : SocketOptions["stderr"] extends UnidirectionalRawStreamSocket ? CompressedDemuxOutput<void, A2> : CompressedDemuxOutput<void, void>, E1 | E2 | E3 | Socket.SocketError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
+    } | undefined): Effect.Effect<void, E1 | E2 | E3 | Socket.SocketError | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>;
 };
 //# sourceMappingURL=Demux.d.ts.map