/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * Modified by Callstack, 2025.
 */
import tty from 'node:tty';
type UnderlyingStream = NodeJS.WritableStream;
type StreamChunk = Buffer | Uint8Array | string;
type WriteCallback = (error?: Error | null) => void;
type ExternalWrite = {
    chunk: StreamChunk;
    encoding?: BufferEncoding;
    callback?: WriteCallback;
};
/**
 * We don't just print things to the console, sometimes we also want to show
 * and update progress. This utility just ensures the output stays neat: no
 * missing newlines, no mangled log lines.
 *
 *     const terminal = Terminal.default;
 *     terminal.status('Updating... 38%');
 *     terminal.log('warning: Something happened.');
 *     terminal.status('Updating, done.');
 *     terminal.persistStatus();
 *
 * The final output:
 *
 *     warning: Something happened.
 *     Updating, done.
 *
 * Without the status feature, we may get a mangled output:
 *
 *     Updating... 38%warning: Something happened.
 *     Updating, done.
 *
 * This is meant to be user-readable and TTY-oriented. We use stdout by default
 * because it's more about status information than diagnostics/errors (stderr).
 *
 * Do not add any higher-level functionality in this class such as "warning" and
 * "error" printers, as it is not meant for formatting/reporting. It has the
 * single responsibility of handling status messages.
 */
declare class Terminal {
    _logLines: Array<string>;
    _nextStatusStr: string;
    _statusStr: string;
    _stream: UnderlyingStream;
    _ttyStream: tty.WriteStream | null;
    _rawStreamWrite: (...args: Array<any>) => boolean;
    _externalWrites: Array<ExternalWrite>;
    _updatePromise: Promise<void> | null;
    _isUpdating: boolean;
    _isInternalWrite: boolean;
    _isPendingUpdate: boolean;
    _shouldFlush: boolean;
    _writeStatusThrottled: (status: string) => void;
    constructor(stream: UnderlyingStream, { ttyPrint }?: {
        ttyPrint?: boolean;
    });
    _patchTTYStreamWrites(): void;
    _writeRaw(chunk: StreamChunk, encoding?: BufferEncoding, callback?: WriteCallback): boolean;
    _writeInternal(chunk: StreamChunk, encoding?: BufferEncoding): Promise<void>;
    _hasVisibleStatus(): boolean;
    _clearCurrentStatus(ttyStream: tty.WriteStream, statusStr: string): Promise<void>;
    /**
     * Schedule an update of the status and log lines.
     * If there's an ongoing update, schedule another one after the current one.
     * If there are two updates scheduled, do nothing, as the second update will
     * take care of the latest status and log lines.
     */
    _scheduleUpdate(): void;
    waitForUpdates(): Promise<void>;
    /**
     * Useful for calling console/stdout directly after terminal logs
     * Otherwise, you could end up with mangled output when the queued
     * update starts writing to stream after a delay.
     */
    flush(): Promise<void>;
    /**
     * Clear and write the new status, logging in bulk in-between. Doing this in a
     * throttled way (in a different tick than the calls to `log()` and
     * `status()`) prevents us from repeatedly rewriting the status in case
     * `terminal.log()` is called several times.
     */
    _update(): Promise<void>;
    /**
     * Shows some text that is meant to be overriden later. Return the previous
     * status that was shown and is no more. Calling `status()` with no argument
     * removes the status altogether. The status is never shown in a
     * non-interactive terminal: for example, if the output is redirected to a
     * file, then we don't care too much about having a progress bar.
     */
    status(format: string, ...args: Array<any>): string;
    /**
     * Similar to `console.log`, except it moves the status/progress text out of
     * the way correctly. In non-interactive terminals this is the same as
     * `console.log`.
     */
    log(format: string, ...args: Array<any>): void;
    /**
     * Log the current status and start from scratch. This is useful if the last
     * status was the last one of a series of updates.
     */
    persistStatus(): void;
}
/**
 * Terminal that keeps separate status lines per platform
 * and renders them together as a multi-line status.
 */
declare class MultiPlatformTerminal extends Terminal {
    private platformStatuses;
    status(platform: string, ...args: Array<any>): string;
    private buildCombinedStatus;
    private checkAllPlatformsDone;
}
export { MultiPlatformTerminal, Terminal };