NodeStream

declare const pipeThroughDuplex: {
  <E2, B = Uint8Array<ArrayBufferLike>>(
    duplex: LazyArg<Duplex>,
    onError: (error: unknown) => E2,
    options?: FromReadableOptions & FromWritableOptions,
  ): <R, E, A>(self: Stream<A, E, R>) => Stream<B, E2 | E, R>;
  <R, E, A, E2, B = Uint8Array<ArrayBufferLike>>(
    self: Stream<A, E, R>,
    duplex: LazyArg<Duplex>,
    onError: (error: unknown) => E2,
    options?: FromReadableOptions & FromWritableOptions,
  ): Stream<B, E | E2, R>;
};

declare const pipeThroughSimple: {
  (
    duplex: LazyArg<Duplex>,
  ): <R, E>(
    self: Stream<string | Uint8Array<ArrayBufferLike>, E, R>,
  ) => Stream<Uint8Array<ArrayBufferLike>, any, R>;
  <R, E>(
    self: Stream<string | Uint8Array<ArrayBufferLike>, E, R>,
    duplex: LazyArg<Duplex>,
  ): Stream<Uint8Array<ArrayBufferLike>, any, R>;
};

declare const fromDuplex: <IE, E, I = Uint8Array, O = Uint8Array>(
  evaluate: LazyArg<Duplex>,
  onError: (error: unknown) => E,
  options?: FromReadableOptions & FromWritableOptions,
) => Channel<Chunk<O>, Chunk<I>, IE | E, IE, void, unknown>;

declare const fromReadable: <E, A = Uint8Array<ArrayBufferLike>>(
  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
  onError: (error: unknown) => E,
  options?: FromReadableOptions,
) => Stream.Stream<A, E>;

declare const fromReadableChannel: <E, A = Uint8Array<ArrayBufferLike>>(
  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
  onError: (error: unknown) => E,
  options?: FromReadableOptions,
) => Channel<Chunk<A>, unknown, E>;

declare const toReadable: <E, R>(
  stream: Stream.Stream<string | Uint8Array, E, R>,
) => Effect<Readable, never, R>;

declare const toReadableNever: <E>(
  stream: Stream.Stream<string | Uint8Array, E, never>,
) => Readable;

declare const toString: <E>(
  readable: LazyArg<Readable | NodeJS.ReadableStream>,
  options: {
    readonly encoding?: BufferEncoding;
    readonly maxBytes?: SizeInput;
    readonly onFailure: (error: unknown) => E;
  },
) => Effect<string, E>;

declare const toUint8Array: <E>(
  readable: LazyArg<Readable | NodeJS.ReadableStream>,
  options: {
    readonly maxBytes?: SizeInput;
    readonly onFailure: (error: unknown) => E;
  },
) => Effect<Uint8Array, E>;

interface FromWritableOptions {
  readonly encoding?: any;
  readonly endOnDone?: boolean;
}

interface FromReadableOptions {
  readonly chunkSize?: any;
  readonly closeOnDone?: boolean;
}

declare const stderr: Stream.Stream<Uint8Array>;

declare const stdin: Stream.Stream<Uint8Array>;

declare const stdout: Stream.Stream<Uint8Array>;