@orkestrel/console 0.0.1

package/dist/src/server/index.d.ts

@@ -0,0 +1,443 @@
+import { EmitterErrorHandler } from '@orkestrel/emitter';
+import { EmitterHooks } from '@orkestrel/emitter';
+import { EmitterInterface } from '@orkestrel/emitter';
+import { LogLevel } from '../core/index.js';
+import { SinkInterface } from '../core/index.js';
+
+/**
+ * One intercepted process-stream write — the immutable, serializable record a
+ * {@link ProcessCaptureInterface} buffers and emits, the server analogue of the core
+ * `CapturedMessage`.
+ *
+ * @remarks
+ * - `level` — the {@link StreamLevel} naming which stream (`stdout` / `stderr`) was written.
+ * - `text` — the chunk decoded to a string (via {@link import('./helpers.js').decodeChunk} —
+ *   total, never throws), VERBATIM: no trailing-newline trimming and no ANSI stripping, so the
+ *   captured text is exactly the bytes the program emitted.
+ * - `time` — the capture instant as epoch milliseconds (`Date.now()`); a plain number so the record
+ *   stays serializable and orderable.
+ * - Frozen at construction — a consumer (or a `capture` listener) reads it, never mutates it.
+ */
+export declare interface CapturedChunk {
+    readonly level: StreamLevel;
+    readonly text: string;
+    readonly time: number;
+}
+
+/**
+ * The width in character cells of a stream target — its live `columns` when it is a TTY, else the
+ * non-interactive {@link DEFAULT_COLUMNS} fallback. The basis a {@link import('./types.js').ServerSinkInterface}
+ * reports through `columns` so a `Reporter` / `Progress` can size its layout to the terminal.
+ *
+ * @remarks
+ * Reads `target.columns` ON EACH CALL (so a getter-backed real stream reflects a live resize) and
+ * accepts it only when it is a positive finite number; a missing / `0` / non-finite `columns` (a
+ * piped, non-TTY stream) falls back to {@link DEFAULT_COLUMNS}. Total — never throws.
+ *
+ * @param target - The stream whose width to probe
+ * @returns The terminal column count, or {@link DEFAULT_COLUMNS} when not a TTY
+ */
+export declare function columnsOf(target: StreamTargetInterface): number;
+
+/**
+ * Create an observable {@link ProcessCaptureInterface} — the server "own ALL output" capture. It
+ * intercepts the RAW `process.stdout.write` / `process.stderr.write` (not just `console.*`, which is
+ * the core `Capture`), so it catches direct `process` writes, library output, and child-process
+ * pipes. Each intercepted write becomes a frozen {@link import('./types.js').CapturedChunk},
+ * buffered (bounded, per-stream) and emitted on `capture`; per options it is mirrored back to the
+ * real stream and/or forwarded to a {@link import('../core/index.js').SinkInterface}.
+ *
+ * @param options - See {@link ProcessCaptureOptions}
+ * @returns A {@link ProcessCaptureInterface}
+ *
+ * @remarks
+ * - **The wrapper never throws and passes backpressure through** — a throw in `process.stdout.write`
+ *   would crash the host, so chunks are decoded totally and the original's `boolean` is returned.
+ * - **Snapshot-at-start + non-reentrant + process-global** — `start()` snapshots and swaps the
+ *   pristine `write`; `stop()` restores the EXACT original. At most ONE may be active at a time.
+ *   Create any server sink BEFORE installing a capture so the mirror's replay is not re-captured.
+ *
+ * @example
+ * ```ts
+ * import { createProcessCapture } from '@src/server'
+ *
+ * const capture = createProcessCapture({ levels: ['stderr'], mirror: true })
+ * capture.start()
+ * process.stderr.write('a library diagnostic\n') // captured AND still shown
+ * capture.stop()
+ * ```
+ */
+export declare function createProcessCapture(options?: ProcessCaptureOptions): ProcessCaptureInterface;
+
+/**
+ * Create the server TTY {@link ServerSinkInterface} — the C-g server output backend, the
+ * env-symmetric sibling of `createBrowserSink` / core's `createConsoleSink`. `write(text, level?)`
+ * routes by level to the process streams and is isTTY-aware: it sends ANSI straight to a terminal
+ * (which renders it, with a leading `\r` overwriting the line natively — that is how the C-e
+ * animations become a LIVE redraw here, with no extra code) but {@link import('../core/index.js').strip}s
+ * the ANSI to clean text when the stream is piped to a file or another process.
+ *
+ * @param options - See {@link ServerSinkOptions}
+ * @returns A {@link ServerSinkInterface} — a {@link import('../core/index.js').SinkInterface} that also
+ *   exposes the terminal `columns` width
+ *
+ * @remarks
+ * - **Routes by level.** `error` / `warn` → the error stream (`process.stderr` by default), every
+ *   other level (and an omitted level) → the out stream (`process.stdout`) — the SAME routing as
+ *   core's `createConsoleSink`, so a logger's `error` reaches `stderr`.
+ * - **isTTY-aware ANSI.** For each write, if the TARGET stream is a TTY the styled `text` is written
+ *   VERBATIM (the terminal renders the ANSI, and a leading `\r` overwrites the current line — live
+ *   animations for free); if it is NOT a TTY (a pipe / redirect to a log file), the ANSI is stripped
+ *   so the file gets clean text. The decision is per-stream and per-write, re-read live, so it stays
+ *   correct if a stream's TTY-ness ever differs between out and err.
+ * - **Width.** `columns` reflects the live `out.columns` (so it tracks a terminal resize), falling
+ *   back to {@link import('./constants.js').DEFAULT_COLUMNS} when the out stream is not a TTY — or a
+ *   fixed value when `options.columns` is supplied. Feed it to a `Reporter` / `Progress` `width`.
+ * - **Injectable + guard-narrowed.** `options.out` / `options.err` default to `process.stdout` /
+ *   `process.stderr` but accept ANY {@link import('./types.js').StreamTargetInterface}, resolved
+ *   through {@link isStreamTarget} (AGENTS §14 — narrow the boundary, never `as`), so a test drives
+ *   the sink (and the isTTY-strip path) with a fake stream that never touches the real process
+ *   streams.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, createReporter } from '../core/index.js'
+ * import { createServerSink } from '@src/server'
+ *
+ * const sink = createServerSink()
+ * const logger = createLogger({ name: 'app', sink })
+ * logger.error('boom') // → process.stderr, ANSI rendered on a TTY / stripped to a pipe
+ * const reporter = createReporter({ sink, width: sink.columns })
+ * ```
+ */
+export declare function createServerSink(options?: ServerSinkOptions): ServerSinkInterface;
+
+/**
+ * Decode one `process.stdout.write` / `process.stderr.write` chunk to a string — TOTAL, never
+ * throws (AGENTS §14). The process write signature accepts `string | Uint8Array` plus an optional
+ * encoding; the capture wrapper reuses this so intercepting a raw stream write can never crash the
+ * host (a throw inside `process.stdout.write` would take the program down).
+ *
+ * @remarks
+ * - A `string` chunk is returned verbatim — the common case (`console.log`, most library output,
+ *   and `process.stdout.write('text')` all pass a string).
+ * - A `Buffer` chunk is decoded with the supplied `encoding` when it is a recognized
+ *   {@link BufferEncoding} (`process` write supports `'utf8'` / `'hex'` / `'base64'` / …), defaulting
+ *   to `'utf8'`; a bare `Uint8Array` is decoded via `TextDecoder` (always utf-8 — the `encoding`
+ *   argument applies ONLY to a `Buffer`, never a plain `Uint8Array`).
+ * - Anything else is coerced with `String(chunk)` (a number / object / bigint / symbol a misbehaving
+ *   writer hands the stream). The coercion is itself guarded: a value whose `toString` /
+ *   `Symbol.toPrimitive` throws yields the stable `'[unprintable]'` placeholder. So the helper is
+ *   TOTAL on every input — it always yields SOME string, never an exception (a throw here would
+ *   escape into `process.*.write` and crash the host).
+ *
+ * @param chunk - The chunk passed to the stream's `write`
+ * @param encoding - The optional encoding argument passed alongside the chunk
+ * @returns The chunk as text
+ *
+ * @example
+ * ```ts
+ * decodeChunk('hi') // 'hi'
+ * decodeChunk(Buffer.from('hi')) // 'hi'
+ * decodeChunk(new Uint8Array([104, 105])) // 'hi'
+ * ```
+ */
+export declare function decodeChunk(chunk: unknown, encoding?: unknown): string;
+
+/**
+ * The default set of {@link StreamLevel}s a process capture patches when `options.levels` is omitted
+ * — BOTH streams ({@link STREAM_LEVELS}). A consumer narrows it (e.g. just `['stderr']`) via
+ * `options.levels`.
+ */
+export declare const DEFAULT_CAPTURE_LEVELS: readonly StreamLevel[];
+
+/**
+ * The default bounded-buffer cap for a {@link import('./types.js').ProcessCaptureInterface} — at
+ * most this many recent {@link import('./types.js').CapturedChunk}s are retained per buffer (the
+ * total buffer AND each per-stream bucket; oldest dropped first). Mirrors the core `Capture`'s
+ * `DEFAULT_CAPTURE_LIMIT`; a consumer overrides it via `options.limit`.
+ */
+export declare const DEFAULT_CAPTURE_LIMIT = 1000;
+
+/**
+ * The terminal width {@link import('./factories.js').createServerSink} reports through
+ * {@link import('./types.js').ServerSinkInterface.columns} when the out stream is NOT a TTY (so
+ * `.columns` is `undefined`) and no explicit `options.columns` was supplied — the conventional
+ * 80-column default a non-interactive context (a pipe, a CI log) assumes.
+ */
+export declare const DEFAULT_COLUMNS = 80;
+
+/**
+ * Whether `encoding` is a {@link BufferEncoding} accepted by `Buffer.prototype.toString` — a total
+ * guard used by {@link decodeChunk} to honor a process-write `encoding` argument only when it is a
+ * real Node encoding (otherwise utf-8 is assumed).
+ *
+ * @param encoding - The candidate encoding (the second `write` argument, possibly a callback)
+ * @returns `true` when `encoding` names a supported buffer encoding
+ */
+export declare function isBufferEncoding(encoding: unknown): encoding is BufferEncoding;
+
+/**
+ * Whether `value` is a usable {@link StreamTargetInterface} — a record with a callable `write`. A
+ * total type guard (AGENTS §14): it NEVER throws and returns `false` for anything off-shape, so it
+ * narrows the one unavoidable boundary (the real `process.stdout` / `process.stderr`, or a fake
+ * stream a test injects) to the exact slice the sink + capture touch — no `as`.
+ *
+ * @remarks
+ * Only `write` is required (the irreducible output method); `isTTY` and `columns` are optional on
+ * {@link StreamTargetInterface}, so their absence does not disqualify a target — a piped stream
+ * (no `isTTY`) is still a valid write target, just a non-terminal one.
+ *
+ * @param value - Any value crossing the boundary (a process stream, an injected fake, `unknown`)
+ * @returns `true` when `value` has a callable `write`
+ *
+ * @example
+ * ```ts
+ * isStreamTarget(process.stdout) // true
+ * isStreamTarget({ write: () => true }) // true
+ * isStreamTarget({}) // false (no write)
+ * ```
+ */
+export declare function isStreamTarget(value: unknown): value is StreamTargetInterface;
+
+/**
+ * An observable interceptor of the RAW process output streams (AGENTS §13) — it takes control of
+ * `process.stdout.write` / `process.stderr.write` on the WRITE side. While `active`, every write to
+ * a configured {@link StreamLevel} is captured as a frozen {@link CapturedChunk}, buffered (total +
+ * per-stream, bounded), emitted on `capture`, and — per options — mirrored to the real stream and/or
+ * forwarded to a {@link SinkInterface}.
+ *
+ * @remarks
+ * Where the core `Capture` patches `console.*` (the high-level read side), this patches the
+ * low-level stream `write`, so it owns ALL server output: a direct `process.stdout.write`, a
+ * third-party library's writes, a child-process pipe — not only `console.*`.
+ *
+ * - **Snapshot-at-start (the no-capture-loop principle).** `start()` snapshots the CURRENT
+ *   `process[stream].write` for each configured level, then installs the wrappers. The mirror
+ *   replays through that snapshot (bound to its stream) — so a server sink created from the same
+ *   streams BEFORE the capture is never re-captured: this catches OTHER writers, not the mirror's
+ *   own replay. Create your sinks before installing a capture.
+ * - **Idempotent + PROCESS-GLOBAL + NON-REENTRANT.** `start()` while `active` is a no-op (never
+ *   double-patches — that would snapshot the wrapper as the "original" and break restore); `stop()`
+ *   while inactive is a no-op. It patches the ONE global `process`, so at most ONE process capture
+ *   may be active at a time — two concurrently would interleave buffers and clobber each other's
+ *   restore.
+ * - **The wrapper NEVER throws and passes backpressure through.** A throw inside
+ *   `process.stdout.write` would crash the host, so the wrapper decodes the chunk through the total
+ *   {@link decodeChunk}, and returns the snapshot-original's `boolean` when mirroring (so a caller's
+ *   `write` backpressure handling still works) or `true` when capture-only (the buffer never fills).
+ * - **Bounded buffers.** The total buffer and each per-stream bucket are each capped at `limit`
+ *   (oldest dropped first), never unbounded — the same retention precedent as the core `Capture`.
+ * - **Lifecycle (§10).** `start` / `stop` toggle interception (emitting `start` / `stop`);
+ *   `destroy()` stops (restoring the PRISTINE `write`) then destroys the emitter.
+ *
+ * @example
+ * ```ts
+ * const capture = new ProcessCapture({ levels: ['stderr'], mirror: true })
+ * capture.start()
+ * process.stderr.write('a library diagnostic\n') // captured AND still written to the terminal
+ * capture.messages('stderr') // [{ level: 'stderr', text: 'a library diagnostic\n', time: … }]
+ * capture.stop() // process.stderr.write restored
+ * ```
+ */
+export declare class ProcessCapture implements ProcessCaptureInterface {
+    #private;
+    constructor(options?: ProcessCaptureOptions);
+    get emitter(): EmitterInterface<ProcessCaptureEventMap>;
+    get active(): boolean;
+    start(): void;
+    stop(): void;
+    messages(): readonly CapturedChunk[];
+    messages(level: StreamLevel): readonly CapturedChunk[];
+    clear(): void;
+    destroy(): void;
+}
+
+/**
+ * The observable events a {@link ProcessCaptureInterface} emits (AGENTS §13) — mirrors the core
+ * `Capture`'s `CaptureEventMap`, but the captured record is a {@link CapturedChunk} (stream-keyed).
+ *
+ * @remarks
+ * - `capture` — an intercepted `process.stdout` / `process.stderr` write, carrying the frozen
+ *   {@link CapturedChunk}. The hook a live log viewer / tee subscribes to.
+ * - `start` / `stop` — the interception toggled on / off (pure signals, empty tuples).
+ *
+ * Listener isolation is the emitter's (§13): a listener throw routes to the emitter's `error`
+ * handler, never onto this map — so a buggy `capture` listener can never escape into the host's
+ * `process.stdout.write` call (which would crash the program).
+ *
+ * Declared as a `type` alias (not `interface extends EventMap`, §4.5): a type-literal satisfies the
+ * `EventMap` constraint structurally, whereas an interface lacks the index signature.
+ */
+export declare type ProcessCaptureEventMap = {
+    /** An intercepted process-stream write — the frozen {@link CapturedChunk}. */
+    readonly capture: readonly [chunk: CapturedChunk];
+    /** Interception began (`process.*.write` patched). */
+    readonly start: readonly [];
+    /** Interception ended (`process.*.write` restored). */
+    readonly stop: readonly [];
+};
+
+/**
+ * An observable interceptor of the RAW process output streams (AGENTS §13) — the server's
+ * "own ALL output" capture. Where the core `Capture` patches `console.*` (the high-level read
+ * side), this patches `process.stdout.write` / `process.stderr.write` (the low-level stream), so it
+ * catches DIRECT `process.stdout.write`, third-party library output, and child-process pipes —
+ * everything that reaches the streams, not just `console.*`.
+ *
+ * @remarks
+ * - **Snapshot-at-start (the no-capture-loop principle).** `start()` snapshots the CURRENT
+ *   `process[stream].write` for each configured {@link StreamLevel}, then installs the wrappers. The
+ *   mirror replays through that snapshot — so a server sink created from the same streams BEFORE the
+ *   capture is never re-captured. Create your sinks before installing a capture.
+ * - **Idempotent + PROCESS-GLOBAL + NON-REENTRANT.** `start()` while `active` is a no-op (never
+ *   double-patches); `stop()` while inactive is a no-op. It patches the ONE global `process`, so at
+ *   most ONE process capture may be active at a time — running two concurrently interleaves their
+ *   buffers and clobbers each other's restore.
+ * - **The wrapper NEVER throws and passes through backpressure.** A throw inside
+ *   `process.stdout.write` would crash the host, so the wrapper builds its record through a total
+ *   decode, and returns the snapshot-original's boolean (or `true` when mirroring is off) so a
+ *   caller's backpressure handling keeps working.
+ * - **Bounded buffers.** The total buffer and each per-stream bucket are each capped at `limit`
+ *   (oldest dropped first), never unbounded.
+ * - **Lifecycle (§10).** `start` / `stop` toggle interception (emitting `start` / `stop`);
+ *   `destroy()` stops (restoring the pristine `write`) then destroys the emitter.
+ */
+export declare interface ProcessCaptureInterface {
+    readonly emitter: EmitterInterface<ProcessCaptureEventMap>;
+    /** Whether interception is currently installed (`start`ed and not yet `stop`ped). */
+    readonly active: boolean;
+    /** Begin intercepting the configured process streams (idempotent; emits `start`). */
+    start(): void;
+    /** Restore the pristine `process.*.write` references (idempotent; emits `stop`). */
+    stop(): void;
+    /** A copy of the full captured buffer, oldest first (capped at `limit`). */
+    messages(): readonly CapturedChunk[];
+    /** A copy of the captured buffer for ONE {@link StreamLevel}, oldest first (capped at `limit`). */
+    messages(level: StreamLevel): readonly CapturedChunk[];
+    /** Drop every buffered chunk (total + per-stream); interception is unaffected. */
+    clear(): void;
+    /** Stop interception (restoring the streams) and tear down the emitter. */
+    destroy(): void;
+}
+
+/**
+ * Options for {@link import('./factories.js').createProcessCapture} — every field optional, so a
+ * bare `createProcessCapture()` buffers both streams without mirroring or forwarding.
+ *
+ * @remarks
+ * - `on` — initial {@link ProcessCaptureEventMap} listeners, wired at construction (e.g.
+ *   `{ capture: (c) => tee(c) }`).
+ * - `error` — the listener-error handler forwarded to the entity's emitter (§13).
+ * - `levels` — which streams to intercept; defaults to {@link import('./constants.js').DEFAULT_CAPTURE_LEVELS}
+ *   (both `stdout` and `stderr`). Narrow it (e.g. just `['stderr']`) to capture one stream.
+ * - `mirror` — when `true`, each intercepted write is ALSO replayed to the snapshot-original
+ *   `write` (bound to its stream), so the output still reaches the terminal while being captured;
+ *   defaults to `false` (capture-only, the program's output is swallowed into the buffer).
+ * - `sink` — an optional {@link SinkInterface} each intercepted chunk is also written to
+ *   (`sink.write(text, level)` with the {@link StreamLevel} mapped to a {@link import('../core/index.js').LogLevel} via
+ *   {@link import('./constants.js').STREAM_LEVEL_MAP}), to tee captured output into the logging
+ *   pipeline / a file. Absent by default.
+ * - `limit` — the bounded-buffer cap (total AND each per-stream bucket); defaults to
+ *   {@link import('./constants.js').DEFAULT_CAPTURE_LIMIT}. Retention is ALWAYS bounded.
+ */
+export declare interface ProcessCaptureOptions {
+    readonly on?: EmitterHooks<ProcessCaptureEventMap>;
+    readonly error?: EmitterErrorHandler;
+    readonly levels?: readonly StreamLevel[];
+    readonly mirror?: boolean;
+    readonly sink?: SinkInterface;
+    readonly limit?: number;
+}
+
+/**
+ * A {@link SinkInterface} that also exposes the target terminal's {@link columns} width — the shape
+ * {@link import('./factories.js').createServerSink} returns. It is a drop-in {@link SinkInterface}
+ * (so a `Logger` / `Reporter` / `Spinner` / `Progress` takes it as `sink`) whose extra `columns`
+ * getter lets a consumer size a `Reporter`'s layout to the live terminal.
+ *
+ * @remarks
+ * `columns` is a getter, re-read on every access — so it reflects the CURRENT terminal width (a
+ * resize is observed) unless a fixed `options.columns` was supplied, in which case it is constant.
+ */
+export declare interface ServerSinkInterface extends SinkInterface {
+    readonly columns: number;
+}
+
+/**
+ * Options for {@link import('./factories.js').createServerSink} — all optional, so a bare
+ * `createServerSink()` writes to the real process streams.
+ *
+ * @remarks
+ * - `out` — the stream `info` / `debug` (and an omitted level) are written to; defaults to
+ *   `process.stdout`. Any {@link StreamTargetInterface} is accepted, so a test injects a fake.
+ * - `err` — the stream `error` / `warn` are written to; defaults to `process.stderr`.
+ * - `columns` — an explicit width override for {@link ServerSinkInterface.columns}. When omitted,
+ *   the sink reads the live `out.columns` (so it tracks a terminal resize), falling back to
+ *   {@link import('./constants.js').DEFAULT_COLUMNS} when the out stream is not a TTY.
+ */
+export declare interface ServerSinkOptions {
+    readonly out?: StreamTargetInterface;
+    readonly err?: StreamTargetInterface;
+    readonly columns?: number;
+}
+
+/**
+ * Each {@link StreamLevel}'s {@link LogLevel} for the optional sink forward — the projection a
+ * process capture routes through when writing an intercepted chunk to a
+ * {@link import('../core/index.js').SinkInterface}
+ * (`sink.write(text, STREAM_LEVEL_MAP[level])`). `stderr` is conventionally the error/diagnostic
+ * stream → `error`; `stdout` is the normal output stream → `info`. The source of truth for the
+ * stream-to-log projection (the server analogue of the core `CAPTURE_LEVEL_MAP`).
+ */
+export declare const STREAM_LEVEL_MAP: Readonly<Record<StreamLevel, LogLevel>>;
+
+/**
+ * The two process streams a {@link import('./types.js').ProcessCaptureInterface} can intercept, in
+ * `stdout`-then-`stderr` order — the {@link StreamLevel} universe and the default configured set.
+ */
+export declare const STREAM_LEVELS: readonly StreamLevel[];
+
+/**
+ * Which process stream a {@link CapturedChunk} came from — the "level" axis of the process-stream
+ * {@link ProcessCaptureInterface}, the server analogue of the core `Capture`'s `CaptureLevel`.
+ *
+ * @remarks
+ * DISTINCT from {@link import('../core/index.js').LogLevel}: a `StreamLevel` names the ORIGINATING process stream
+ * (`process.stdout` vs `process.stderr`), not a severity. It is a named value family (it indexes
+ * {@link import('./constants.js').STREAM_LEVEL_MAP} to a {@link import('../core/index.js').LogLevel} for the optional sink
+ * forward), never a binary toggle — so it stays a union (AGENTS §4.4).
+ */
+export declare type StreamLevel = 'stdout' | 'stderr';
+
+/**
+ * The minimal writable-stream shape the C-g server sink and process capture address — exactly the
+ * slice of a Node `tty.WriteStream` / `process.stdout` they touch, and no more. A
+ * {@link ServerSinkOptions} target and a {@link ProcessCaptureInterface}'s patched streams are
+ * narrowed to this via {@link import('./helpers.js').isStreamTarget} (AGENTS §14 — narrow the
+ * boundary, never `as`), so a test can drive either with a hand-built fake stream that never
+ * touches the real `process` streams.
+ *
+ * @remarks
+ * - `write(text)` — the one required method: push a chunk to the stream, returning the host's
+ *   backpressure boolean (`false` when the kernel buffer is full). A `process` stream returns it;
+ *   a fake may return `void` (read as truthy / no backpressure).
+ * - `isTTY` — present and `true` on a real terminal, absent / `false` when the stream is piped to a
+ *   file or another process. The sink reads it to decide whether to keep ANSI (a terminal renders
+ *   it, and a leading `\r` overwrites natively) or {@link import('../core/index.js').strip} it to clean
+ *   text (a log file should not carry escape codes).
+ * - `columns` — the terminal width in character cells when the stream is a TTY, `undefined`
+ *   otherwise; the sink surfaces it as {@link ServerSinkInterface.columns} so a consumer can feed a
+ *   `Reporter` / `Progress` its render width.
+ */
+export declare interface StreamTargetInterface {
+    write(text: string): boolean | void;
+    readonly isTTY?: boolean;
+    readonly columns?: number;
+}
+
+export declare type StreamWriteCallback = (error?: Error | null) => void;
+
+export declare type StreamWriteFunction = NodeJS.WriteStream['write'];
+
+export { }