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>