import * as react_jsx_runtime from 'react/jsx-runtime';
import { CSSProperties, ComponentProps, RefObject } from 'react';

type RetroScreenTextSelection = {
    start: number;
    end: number;
};
declare const clampRetroScreenTextOffset: (value: number, textLength: number) => number;
declare const normalizeRetroScreenTextSelection: (selection: RetroScreenTextSelection, textLength: number) => RetroScreenTextSelection;
declare const createRetroScreenTextSelection: (start: number, end?: number, textLength?: number) => RetroScreenTextSelection;
declare const findRetroScreenPreviousWordBoundary: (value: string, offset: number) => number;
declare const findRetroScreenNextWordBoundary: (value: string, offset: number) => number;
declare const getRetroScreenWordSelectionAtOffset: (value: string, offset: number) => RetroScreenTextSelection;
declare const isRetroScreenTextSelectionCollapsed: (selection: RetroScreenTextSelection) => boolean;
declare const collapseRetroScreenTextSelectionToStart: (selection: RetroScreenTextSelection) => RetroScreenTextSelection;
declare const collapseRetroScreenTextSelectionToEnd: (selection: RetroScreenTextSelection) => RetroScreenTextSelection;
declare const deleteRetroScreenSelectedText: (value: string, selection: RetroScreenTextSelection) => {
    value: string;
    selection: RetroScreenTextSelection;
    deletedText: string;
};
declare const replaceRetroScreenSelectedText: (value: string, selection: RetroScreenTextSelection, replacement: string) => {
    value: string;
    selection: RetroScreenTextSelection;
    deletedText: string;
};

type RetroScreenCellIntensity = "normal" | "bold" | "faint";
type RetroScreenTerminalColor = {
    mode: "default";
    value: 0;
} | {
    mode: "palette";
    value: number;
} | {
    mode: "rgb";
    value: number;
};
type RetroScreenCellStyle = {
    intensity: RetroScreenCellIntensity;
    bold: boolean;
    faint: boolean;
    inverse: boolean;
    conceal: boolean;
    blink: boolean;
    foreground: RetroScreenTerminalColor;
    background: RetroScreenTerminalColor;
};
type RetroScreenCell = {
    char: string;
    style: RetroScreenCellStyle;
};
type RetroScreenCursorState = {
    row: number;
    col: number;
    visible: boolean;
    mode: CursorMode;
};
type RetroScreenTerminalMouseTrackingMode = "none" | "vt200" | "drag" | "any";
type RetroScreenTerminalMouseProtocol = "none" | "sgr";
type RetroScreenTerminalModes = {
    insertMode: boolean;
    originMode: boolean;
    wraparoundMode: boolean;
    applicationCursorKeysMode: boolean;
    bracketedPasteMode: boolean;
    focusReportingMode: boolean;
    alternateScreenBufferMode: boolean;
    mouseTrackingMode: RetroScreenTerminalMouseTrackingMode;
    mouseProtocol: RetroScreenTerminalMouseProtocol;
};
type RetroScreenScreenBufferOptions = {
    rows: number;
    cols: number;
    scrollback?: number;
    tabWidth?: number;
    cursorMode?: CursorMode;
};
type RetroScreenScreenSnapshot = {
    rows: number;
    cols: number;
    lines: string[];
    rawLines: string[];
    cells: RetroScreenCell[][];
    scrollback: string[];
    scrollbackCells: RetroScreenCell[][];
    cursor: RetroScreenCursorState;
    pendingWrap: boolean;
    modes: RetroScreenTerminalModes;
};
type RetroScreenWriteOptions = {
    appendNewline?: boolean;
};

type RetroScreenTerminalHostKeyEvent = {
    key: string;
    code: string;
    altKey: boolean;
    ctrlKey: boolean;
    metaKey: boolean;
    shiftKey: boolean;
    repeat: boolean;
};
type RetroScreenTerminalOutputAdapter = {
    beginFrame: () => void;
    writeAnsi: (data: string) => void;
    setCursor: (row: number, col: number) => void;
    setCursorVisible: (visible: boolean) => void;
    resetScreen: () => void;
    endFrame: () => void;
};
type RetroScreenTerminalInputAdapter = {
    onKeyDown?: (event: RetroScreenTerminalHostKeyEvent) => void;
    onKeyUp?: (event: RetroScreenTerminalHostKeyEvent) => void;
    focusTerminal?: () => void;
    blurTerminal?: () => void;
    drainInputQueue?: () => readonly string[];
};
type RetroScreenTerminalHostAdapter = RetroScreenTerminalOutputAdapter & RetroScreenTerminalInputAdapter;

type RetroScreenTerminalMouseButton = "left" | "middle" | "right" | "wheel-up" | "wheel-down" | "none";
type RetroScreenTerminalMouseAction = "press" | "release" | "move" | "wheel";
type RetroScreenTerminalMouseEvent = {
    action: RetroScreenTerminalMouseAction;
    button: RetroScreenTerminalMouseButton;
    row: number;
    col: number;
    altKey: boolean;
    ctrlKey: boolean;
    metaKey: boolean;
    shiftKey: boolean;
};
type RetroScreenTerminalMouseEncodingOptions = {
    protocol?: RetroScreenTerminalMouseProtocol;
    trackingMode?: RetroScreenTerminalMouseTrackingMode;
};
declare const encodeRetroScreenTerminalMouse: (event: RetroScreenTerminalMouseEvent, options?: RetroScreenTerminalMouseEncodingOptions) => string | null;

type RetroScreenTerminalSessionState = "idle" | "connecting" | "open" | "closed" | "error";
type RetroScreenTerminalSessionGeometry = {
    rows: number;
    cols: number;
};
type RetroScreenTerminalSessionEvent = {
    type: "connecting";
} | {
    type: "open";
} | {
    type: "ready";
    pid?: number | null;
} | {
    type: "data";
    data: string;
} | {
    type: "title";
    title: string;
} | {
    type: "bell";
} | {
    type: "exit";
    exitCode: number | null;
    signal: string | null;
} | {
    type: "close";
    code: number;
    reason: string;
    wasClean: boolean;
} | {
    type: "error";
    message: string;
    error?: unknown;
};
type RetroScreenTerminalSessionListener = (event: RetroScreenTerminalSessionEvent) => void;
type RetroScreenTerminalSession = {
    connect: (geometry: RetroScreenTerminalSessionGeometry) => void;
    writeInput: (data: string | Uint8Array) => void;
    resize: (rows: number, cols: number) => void;
    subscribe: (listener: RetroScreenTerminalSessionListener) => () => void;
    close: () => void;
    getState: () => RetroScreenTerminalSessionState;
};

type CursorMode = "solid" | "hollow";
type RetroScreenGridMode = "auto" | "static";
type RetroScreenDisplaySurfaceMode = "dark" | "light";
type RetroScreenResizeMode = "width" | "height" | "both";
type RetroScreenDisplayPaddingValue = number | string;
type RetroScreenDisplayPadding = RetroScreenDisplayPaddingValue | {
    block?: RetroScreenDisplayPaddingValue;
    inline?: RetroScreenDisplayPaddingValue;
    top?: RetroScreenDisplayPaddingValue;
    right?: RetroScreenDisplayPaddingValue;
    bottom?: RetroScreenDisplayPaddingValue;
    left?: RetroScreenDisplayPaddingValue;
};
type RetroScreenDisplayColorMode = "phosphor-green" | "phosphor-amber" | "phosphor-ice" | "ansi-classic" | "ansi-extended";
type RetroScreenGeometry = {
    rows: number;
    cols: number;
    cellWidth: number;
    cellHeight: number;
    innerWidth: number;
    innerHeight: number;
    fontSize: number;
};
type RetroScreenSharedProps = {
    color?: string;
    displayColorMode?: RetroScreenDisplayColorMode;
    displaySurfaceMode?: RetroScreenDisplaySurfaceMode;
    displayPadding?: RetroScreenDisplayPadding;
    displayFontScale?: number;
    displayRowScale?: number;
    focusGlow?: boolean;
    resizable?: boolean | RetroScreenResizeMode;
    resizableLeadingEdges?: boolean;
    cursorMode?: CursorMode;
    gridMode?: RetroScreenGridMode;
    rows?: number;
    cols?: number;
    className?: string;
    style?: CSSProperties;
    autoFocus?: boolean;
    onFocusChange?: (focused: boolean) => void;
    onGeometryChange?: (geometry: RetroScreenGeometry) => void;
};
type RetroScreenController = {
    write: (data: string, options?: RetroScreenWriteOptions) => void;
    writeMany: (chunks: readonly RetroScreenWriteChunk[]) => void;
    writeln: (line: string) => void;
    clear: () => void;
    reset: () => void;
    batch: <T>(fn: () => T) => T;
    suspendNotifications: () => void;
    resumeNotifications: () => void;
    moveCursorTo: (row: number, col: number) => void;
    resize: (rows: number, cols: number) => void;
    setCursorVisible: (visible: boolean) => void;
    setCursorMode: (mode: CursorMode) => void;
    getSnapshot: () => RetroScreenScreenSnapshot;
    subscribe: (listener: () => void) => () => void;
};
type RetroScreenValueModeProps = RetroScreenSharedProps & {
    mode: "value";
    value: string;
    cells?: RetroScreenCell[][];
    editable?: boolean;
    placeholder?: string;
    onChange?: (value: string) => void;
    onSubmit?: (value: string) => void;
};
type RetroScreenEditorModeProps = RetroScreenSharedProps & {
    mode: "editor";
    value: string;
    editable?: boolean;
    placeholder?: string;
    onChange?: (value: string) => void;
    onSelectionChange?: (selection: RetroScreenTextSelection | null) => void;
};
type RetroScreenTerminalModeProps = RetroScreenSharedProps & {
    mode: "terminal";
    value?: string;
    initialBuffer?: string;
    controller?: RetroScreenController;
    session?: RetroScreenTerminalSession;
    closeSessionOnUnmount?: boolean;
    bufferSize?: number;
    defaultAutoFollow?: boolean;
    captureKeyboard?: boolean;
    captureMouse?: boolean;
    capturePaste?: boolean;
    captureFocusReport?: boolean;
    terminalFocusable?: boolean;
    localScrollbackWhenMouseActive?: boolean;
    onSessionEvent?: (event: RetroScreenTerminalSessionEvent) => void;
    onSessionStateChange?: (state: RetroScreenTerminalSessionState) => void;
    onTerminalData?: (data: string | Uint8Array) => void;
    onTerminalKeyDown?: (event: RetroScreenTerminalHostKeyEvent) => void;
    onTerminalKeyUp?: (event: RetroScreenTerminalHostKeyEvent) => void;
    onTerminalMouse?: (event: RetroScreenTerminalMouseEvent & {
        encodedData: string;
    }) => void;
};
type RetroScreenPromptCommandResult = {
    accepted: true;
    response?: string | string[];
} | {
    accepted: false;
    response?: string | string[];
};
type RetroScreenPromptModeProps = RetroScreenSharedProps & {
    mode: "prompt";
    value?: string;
    promptChar?: string;
    acceptanceText?: string;
    rejectionText?: string;
    bufferSize?: number;
    defaultAutoFollow?: boolean;
    onCommand?: (command: string) => RetroScreenPromptCommandResult | Promise<RetroScreenPromptCommandResult>;
};
type RetroScreenProps = RetroScreenValueModeProps | RetroScreenEditorModeProps | RetroScreenTerminalModeProps | RetroScreenPromptModeProps;
type RetroScreenWriteChunk = string | {
    data: string;
    options?: RetroScreenWriteOptions;
};

declare function RetroScreen(props: RetroScreenProps): react_jsx_runtime.JSX.Element;

type RetroScreenAnsiGeometrySource = "sauce" | "fallback";
type RetroScreenAnsiSnapshotStorageMode = "eager" | "sparse";
type RetroScreenAnsiGeometryPolicy = {
    fallbackRows: number;
    fallbackCols: number;
    viewportRows: number;
    viewportCols: number;
    eagerMaxCells: number;
    eagerMaxRows: number;
    eagerMaxCols: number;
    maxDimension: number;
};
type RetroScreenAnsiSourceGeometry = {
    rows: number;
    cols: number;
    totalCells: number;
    geometrySource: RetroScreenAnsiGeometrySource;
    storageMode: RetroScreenAnsiSnapshotStorageMode;
    metadata: RetroScreenAnsiMetadata | null;
};
type RetroScreenAnsiViewportWindow = {
    rowOffset: number;
    colOffset: number;
    rows: number;
    cols: number;
    maxRowOffset: number;
    maxColOffset: number;
};
type RetroScreenAnsiLineSliceAccessor = (rowIndex: number, startCol: number, endCol: number) => string;
type RetroScreenAnsiCellSliceAccessor = (rowIndex: number, startCol: number, endCol: number) => RetroScreenCell[];
type RetroScreenAnsiFrameSnapshot = {
    sourceRows: number;
    sourceCols: number;
    frameIndex: number;
    frameCount: number;
    isComplete: boolean;
    isStreaming: boolean;
    storageMode?: RetroScreenAnsiSnapshotStorageMode;
    lines: string[];
    cells?: RetroScreenCell[][];
    metadata?: RetroScreenAnsiMetadata | null;
    getLineSlice?: RetroScreenAnsiLineSliceAccessor;
    getCellSlice?: RetroScreenAnsiCellSliceAccessor;
};
declare const DEFAULT_RETROSCREEN_ANSI_GEOMETRY_POLICY: Readonly<RetroScreenAnsiGeometryPolicy>;
declare const resolveRetroScreenAnsiSourceGeometry: ({ metadata, policy, }?: {
    metadata?: RetroScreenAnsiMetadata | null;
    policy?: RetroScreenAnsiGeometryPolicy;
}) => RetroScreenAnsiSourceGeometry;
declare const normalizeRetroScreenAnsiViewportWindow: ({ sourceRows, sourceCols, rowOffset, colOffset, rows, cols, }: {
    sourceRows: number;
    sourceCols: number;
    rowOffset?: number;
    colOffset?: number;
    rows?: number;
    cols?: number;
}) => RetroScreenAnsiViewportWindow;

type RetroScreenAnsiByteChunk = Uint8Array | ArrayBuffer | ArrayLike<number>;
type RetroScreenAnsiMetadata = {
    title: string;
    author: string;
    group: string;
    font: string;
    width: number;
    height: number;
};
type RetroScreenAnsiFrameStreamSnapshot = {
    completedFrames: readonly string[];
    currentFrame: string;
};
type RetroScreenAnsiSnapshotFrame = {
    lines: readonly string[];
    text: string;
    cells?: readonly RetroScreenCell[][];
    storageMode: RetroScreenAnsiSnapshotStorageMode;
    getLineSlice: RetroScreenAnsiLineSliceAccessor;
    getCellSlice: RetroScreenAnsiCellSliceAccessor;
};
type RetroScreenAnsiSnapshotStreamSnapshot = {
    completedFrames: readonly RetroScreenAnsiSnapshotFrame[];
    currentFrame: RetroScreenAnsiSnapshotFrame;
    sourceRows: number;
    sourceCols: number;
    metadata: RetroScreenAnsiMetadata | null;
    storageMode: RetroScreenAnsiSnapshotStorageMode;
};
type RetroScreenAnsiFrameStream = {
    appendChunk: (chunk: RetroScreenAnsiByteChunk) => RetroScreenAnsiFrameStreamSnapshot;
    appendText: (text: string) => RetroScreenAnsiFrameStreamSnapshot;
    getSnapshot: () => RetroScreenAnsiFrameStreamSnapshot;
    reset: () => void;
};
type RetroScreenAnsiSnapshotStream = {
    appendChunk: (chunk: RetroScreenAnsiByteChunk) => RetroScreenAnsiSnapshotStreamSnapshot;
    appendText: (text: string) => RetroScreenAnsiSnapshotStreamSnapshot;
    getSnapshot: () => RetroScreenAnsiSnapshotStreamSnapshot;
    reset: () => void;
};
declare const normalizeRetroScreenAnsiByteChunk: (chunk: RetroScreenAnsiByteChunk) => Uint8Array;
declare const decodeRetroScreenAnsiBytes: (bytes: Uint8Array) => string;
declare const findRetroScreenAnsiSauceIndex: (bytes: Uint8Array) => number;
declare const stripRetroScreenAnsiSauce: (bytes: Uint8Array) => Uint8Array<ArrayBufferLike>;
declare const parseRetroScreenAnsiSauce: (bytes: Uint8Array) => RetroScreenAnsiMetadata;
declare const splitRetroScreenAnsiBytes: (bytes: Uint8Array, chunkSize?: number) => Uint8Array<ArrayBufferLike>[];
declare const createRetroScreenAnsiSnapshotStream: ({ rows, cols, metadata, storageMode }: {
    rows: number;
    cols: number;
    metadata?: RetroScreenAnsiMetadata | null;
    storageMode?: RetroScreenAnsiSnapshotStorageMode;
}) => RetroScreenAnsiSnapshotStream;
declare const createRetroScreenAnsiFrameStream: ({ rows, cols }: {
    rows: number;
    cols: number;
}) => RetroScreenAnsiFrameStream;
declare const materializeRetroScreenAnsiFrames: (bytesOrText: Uint8Array | string, rows: number, cols: number) => string[];
declare const materializeRetroScreenAnsiSnapshots: (bytesOrText: Uint8Array | string, rows: number, cols: number, metadata?: RetroScreenAnsiMetadata | null) => RetroScreenAnsiSnapshotFrame[];

type RetroScreenAnsiPlayerState = {
    displayValue: string;
    frameIndex: number;
    frameCount: number;
    isComplete: boolean;
    isStreaming: boolean;
};
type UseRetroScreenAnsiPlayerArgs = {
    byteStream?: readonly RetroScreenAnsiByteChunk[];
    rows: number;
    cols: number;
    frameDelayMs?: number;
    loop?: boolean;
    complete?: boolean;
    loadingValue?: string;
};
declare const useRetroScreenAnsiPlayer: ({ byteStream, rows, cols, frameDelayMs, loop, complete, loadingValue }: UseRetroScreenAnsiPlayerArgs) => RetroScreenAnsiPlayerState;

type RetroScreenAnsiPlayerProps = Omit<ComponentProps<typeof RetroScreen>, "mode" | "value" | "gridMode" | "rows" | "cols"> & {
    byteStream?: readonly RetroScreenAnsiByteChunk[];
    rows: number;
    cols: number;
    frameDelayMs?: number;
    loop?: boolean;
    complete?: boolean;
    loadingValue?: string;
    onPlaybackStateChange?: (state: RetroScreenAnsiPlayerState) => void;
};
declare function RetroScreenAnsiPlayer({ byteStream, rows, cols, frameDelayMs, loop, complete, loadingValue, onPlaybackStateChange, ...screenProps }: RetroScreenAnsiPlayerProps): react_jsx_runtime.JSX.Element;

type UseRetroScreenTerminalBridgeArgs = {
    terminalProps: RetroScreenTerminalModeProps | null;
    geometry: RetroScreenGeometry;
    terminalController: RetroScreenController | null;
};
declare const useRetroScreenTerminalBridge: ({ terminalProps, geometry, terminalController }: UseRetroScreenTerminalBridgeArgs) => {
    sessionState: RetroScreenTerminalSessionState;
    sessionTitle: string | null;
    sessionBellCount: number;
};

type RetroScreenAnsiSnapshotPlayerState = {
    displayValue: string;
    frameIndex: number;
    frameCount: number;
    isComplete: boolean;
    isStreaming: boolean;
    sourceRows: number;
    sourceCols: number;
    storageMode: RetroScreenAnsiSnapshotStorageMode;
    lines: readonly string[];
    metadata: RetroScreenAnsiMetadata | null;
    frameSnapshot: RetroScreenAnsiFrameSnapshot;
};
type UseRetroScreenAnsiSnapshotPlayerArgs = {
    byteStream?: readonly RetroScreenAnsiByteChunk[];
    metadata?: RetroScreenAnsiMetadata | null;
    policy?: RetroScreenAnsiGeometryPolicy;
    frameDelayMs?: number;
    loop?: boolean;
    complete?: boolean;
    loadingValue?: string;
};
declare const useRetroScreenAnsiSnapshotPlayer: ({ byteStream, metadata, policy, frameDelayMs, loop, complete, loadingValue }: UseRetroScreenAnsiSnapshotPlayerArgs) => RetroScreenAnsiSnapshotPlayerState;

declare const useRetroScreenController: (options?: Partial<RetroScreenScreenBufferOptions>) => RetroScreenController;

type RetroScreenEditorSessionOptions = {
    value?: string;
    placeholder?: string;
    editable?: boolean;
    cursorMode?: CursorMode;
    selectionStart?: number;
    selectionEnd?: number;
};
type RetroScreenEditorSessionState = {
    value: string;
    placeholder: string;
    editable: boolean;
    cursorMode: CursorMode;
    selection: RetroScreenTextSelection;
};
type RetroScreenEditorSession = {
    setValue: (value: string) => void;
    getValue: () => string;
    setSelection: (start: number, end?: number) => void;
    getSelection: () => RetroScreenTextSelection;
    getSelectedText: () => string;
    moveCursorTo: (offset: number) => void;
    moveCursorByCharacter: (direction: -1 | 1) => void;
    moveCursorByWord: (direction: -1 | 1) => void;
    moveCursorToBoundary: (direction: -1 | 1) => void;
    selectAll: () => void;
    selectWordAt: (offset: number) => void;
    extendSelectionByCharacter: (direction: -1 | 1) => void;
    extendSelectionByWord: (direction: -1 | 1) => void;
    extendSelectionToBoundary: (direction: -1 | 1) => void;
    collapseSelectionToStart: () => void;
    collapseSelectionToEnd: () => void;
    replaceSelection: (text: string) => boolean;
    cutSelection: () => {
        changed: boolean;
        text: string;
    };
    deleteBackward: () => boolean;
    deleteForward: () => boolean;
    setEditable: (editable: boolean) => void;
    isEditable: () => boolean;
    setPlaceholder: (placeholder: string) => void;
    getPlaceholder: () => string;
    setCursorMode: (mode: CursorMode) => void;
    getCursorMode: () => CursorMode;
    getState: () => RetroScreenEditorSessionState;
    subscribe: (listener: () => void) => () => void;
};
declare const createRetroScreenEditorSession: (options?: RetroScreenEditorSessionOptions) => RetroScreenEditorSession;

declare const useRetroScreenEditorSession: (options?: RetroScreenEditorSessionOptions) => RetroScreenEditorSession;

type UseRetroScreenGeometryOptions = {
    screenRef: RefObject<HTMLElement | null>;
    probeRef: RefObject<HTMLElement | null>;
    gridMode?: RetroScreenGridMode;
    rows?: number;
    cols?: number;
    fontScale?: number;
    onGeometryChange?: (geometry: RetroScreenGeometry) => void;
};
declare const useRetroScreenGeometry: ({ screenRef, probeRef, gridMode, rows, cols, fontScale, onGeometryChange }: UseRetroScreenGeometryOptions) => {
    geometry: RetroScreenGeometry;
    cssVars: CSSProperties;
};

type RetroScreenPromptSessionOptions = Partial<RetroScreenScreenBufferOptions> & {
    promptChar?: string;
    acceptanceText?: string;
    rejectionText?: string;
    onCommand?: (command: string) => RetroScreenPromptCommandResult | Promise<RetroScreenPromptCommandResult>;
};
type RetroScreenPromptSession = {
    setDraft: (draft: string) => void;
    getDraft: () => string;
    setSelection: (offset: number) => void;
    setFocused: (focused: boolean) => void;
    isAwaitingResponse: () => boolean;
    resize: (rows: number, cols: number) => void;
    setCursorMode: (mode: CursorMode) => void;
    updateOptions: (options: Partial<RetroScreenPromptSessionOptions>) => void;
    clear: () => void;
    reset: () => void;
    submit: (command?: string) => Promise<RetroScreenPromptCommandResult>;
    getSnapshot: () => RetroScreenScreenSnapshot;
    subscribe: (listener: () => void) => () => void;
};
declare const createRetroScreenPromptSession: (options?: RetroScreenPromptSessionOptions) => RetroScreenPromptSession;

declare const useRetroScreenPromptSession: (options?: RetroScreenPromptSessionOptions) => RetroScreenPromptSession;

type RetroScreenCursorRenderState = {
    row: number;
    col: number;
    mode: CursorMode;
};
type RetroScreenRenderCell = RetroScreenCell & {
    sourceOffset: number | null;
    isSelected: boolean;
};
type RetroScreenRenderModel = {
    lines: string[];
    cells?: RetroScreenRenderCell[][];
    cursor: RetroScreenCursorRenderState | null;
    isDimmed: boolean;
};
declare const ansiSnapshotToRenderModelWindow: (snapshot: RetroScreenAnsiFrameSnapshot, options?: {
    rowOffset?: number;
    colOffset?: number;
    rows?: number;
    cols?: number;
}) => RetroScreenRenderModel;

type MeasureGridInput = {
    innerWidth: number;
    innerHeight: number;
    cellWidth: number;
    cellHeight: number;
    fontSize?: number;
};
declare const measureGrid: ({ innerWidth, innerHeight, cellWidth, cellHeight, fontSize }: MeasureGridInput) => RetroScreenGeometry;

type WrapTextOptions = {
    cols: number;
    tabWidth?: number;
};
declare const wrapTextToColumns: (text: string, options: WrapTextOptions) => string[];

declare const createRetroScreenController: (options?: Partial<RetroScreenScreenBufferOptions>) => RetroScreenController;

type RetroScreenTerminalClientMessage = {
    type: "open";
    rows: number;
    cols: number;
    cwd?: string;
    env?: Record<string, string>;
    command?: string;
    args?: string[];
    term?: string;
} | {
    type: "input";
    data: string;
    encoding: "utf8" | "base64";
} | {
    type: "resize";
    rows: number;
    cols: number;
} | {
    type: "close";
};
type RetroScreenTerminalWebSocketLike = {
    readyState: number;
    onopen: ((event: Event) => void) | null;
    onmessage: ((event: MessageEvent<string>) => void) | null;
    onerror: ((event: Event) => void) | null;
    onclose: ((event: CloseEvent) => void) | null;
    send: (data: string) => void;
    close: (code?: number, reason?: string) => void;
};
type RetroScreenTerminalWebSocketConstructor = new (url: string, protocols?: string | string[]) => RetroScreenTerminalWebSocketLike;
type RetroScreenTerminalWebSocketSessionOptions = {
    url: string | URL;
    protocols?: string | string[];
    WebSocket?: RetroScreenTerminalWebSocketConstructor;
    openPayload?: Omit<Extract<RetroScreenTerminalClientMessage, {
        type: "open";
    }>, "type" | "rows" | "cols"> | ((geometry: RetroScreenTerminalSessionGeometry) => Omit<Extract<RetroScreenTerminalClientMessage, {
        type: "open";
    }>, "type" | "rows" | "cols">);
};
declare const createRetroScreenWebSocketSession: (options: RetroScreenTerminalWebSocketSessionOptions) => RetroScreenTerminalSession;

type RetroScreenTerminalInputEncodingOptions = {
    applicationCursorKeysMode?: boolean;
};
declare const encodeRetroScreenTerminalInput: (event: RetroScreenTerminalHostKeyEvent, options?: RetroScreenTerminalInputEncodingOptions) => string | null;

type RetroScreenTerminalPasteEncodingOptions = {
    bracketedPasteMode?: boolean;
};
declare const encodeRetroScreenTerminalPaste: (text: string, options?: RetroScreenTerminalPasteEncodingOptions) => string;
declare const encodeRetroScreenTerminalFocusReport: (focused: boolean) => "\u001B[I" | "\u001B[O";

type RetroScreenCsiIdentifier = {
    prefix?: string;
    intermediates?: string;
    final: string;
};
type RetroScreenEscapeIdentifier = {
    intermediates?: string;
    final: string;
};
type RetroScreenModeChangeCommand = {
    type: "setMode" | "resetMode";
    identifier: RetroScreenCsiIdentifier;
    params: number[];
};
type RetroScreenTerminalCommand = {
    type: "print";
    char: string;
} | {
    type: "lineFeed";
} | {
    type: "carriageReturn";
} | {
    type: "backspace";
} | {
    type: "tab";
} | {
    type: "formFeed";
} | {
    type: "bell";
} | {
    type: "cursorUp";
    count: number;
} | {
    type: "cursorDown";
    count: number;
} | {
    type: "cursorForward";
    count: number;
} | {
    type: "cursorBackward";
    count: number;
} | {
    type: "cursorPosition";
    row: number;
    col: number;
} | {
    type: "insertChars";
    count: number;
} | {
    type: "deleteChars";
    count: number;
} | {
    type: "insertLines";
    count: number;
} | {
    type: "deleteLines";
    count: number;
} | {
    type: "scrollUp";
    count: number;
} | {
    type: "scrollDown";
    count: number;
} | {
    type: "setScrollRegion";
    top?: number;
    bottom?: number;
} | {
    type: "eraseInDisplay";
    mode: number;
} | {
    type: "eraseInLine";
    mode: number;
} | {
    type: "saveCursor";
    source: "ansi" | "dec";
} | {
    type: "restoreCursor";
    source: "ansi" | "dec";
} | {
    type: "setGraphicRendition";
    params: number[];
} | {
    type: "index";
} | {
    type: "nextLine";
} | {
    type: "reverseIndex";
} | {
    type: "resetToInitialState";
} | RetroScreenModeChangeCommand | {
    type: "unknownEscape";
    identifier: RetroScreenEscapeIdentifier;
} | {
    type: "unknownCsi";
    identifier: RetroScreenCsiIdentifier;
    params: number[];
};

type RetroScreenAnsiParserHandlers = {
    command: (command: RetroScreenTerminalCommand) => void;
};
declare class RetroScreenAnsiParser {
    private readonly handlers;
    private state;
    private escIntermediateBuffer;
    private csiPrefixBuffer;
    private csiParamBuffer;
    private csiIntermediateBuffer;
    constructor(handlers: RetroScreenAnsiParserHandlers);
    feed(data: string): void;
    reset(): void;
    private feedCharacter;
    private feedTextCharacter;
    private feedEscapeCharacter;
    private feedCsiCharacter;
    private dispatchEscape;
    private dispatchCsi;
}

declare class RetroScreenScreenBuffer {
    readonly rows: number;
    readonly cols: number;
    readonly scrollbackLimit: number;
    readonly tabWidth: number;
    private grid;
    private scrollbackCells;
    private readonly parser;
    private cursorState;
    private savedCursorState;
    private currentStyle;
    private terminalModes;
    private pendingWrap;
    private scrollRegionTop;
    private scrollRegionBottom;
    private primarySurface;
    private alternateSurface;
    private activeSurface;
    constructor(options: RetroScreenScreenBufferOptions);
    clear(): void;
    reset(): void;
    write(data: string, options?: RetroScreenWriteOptions): void;
    writeln(line: string): void;
    moveCursorTo(row: number, col: number): void;
    setCursorVisible(visible: boolean): void;
    setCursorMode(mode: CursorMode): void;
    getCursor(): {
        row: number;
        col: number;
        visible: boolean;
        mode: CursorMode;
    };
    getSnapshot(): RetroScreenScreenSnapshot;
    private applyCommand;
    private writePrintable;
    private insertTab;
    private carriageReturn;
    private cursorUp;
    private cursorDown;
    private cursorForward;
    private cursorBackward;
    private cursorPosition;
    private insertChars;
    private deleteChars;
    private insertLines;
    private deleteLines;
    private scrollUp;
    private scrollDown;
    private setScrollRegion;
    private lineFeed;
    private backspace;
    private eraseInLine;
    private eraseInDisplay;
    private saveCursor;
    private restoreCursor;
    private setGraphicRendition;
    private index;
    private nextLine;
    private reverseIndex;
    private setMode;
    private prepareCursorForPrint;
    private normalizeCursorForMovement;
    private moveCursorHome;
    private isCursorWithinScrollRegion;
    private insertBlankCells;
    private deleteCells;
    private shiftLinesUp;
    private shiftLinesDown;
    private createSurfaceState;
    private getActiveSurfaceState;
    private storeSurface;
    private loadSurface;
    private setAlternateScreenMode;
}

export { type CursorMode, DEFAULT_RETROSCREEN_ANSI_GEOMETRY_POLICY, RetroScreen, type RetroScreenAnsiByteChunk, type RetroScreenAnsiCellSliceAccessor, type RetroScreenAnsiFrameSnapshot, type RetroScreenAnsiFrameStream, type RetroScreenAnsiFrameStreamSnapshot, type RetroScreenAnsiGeometryPolicy, type RetroScreenAnsiGeometrySource, type RetroScreenAnsiLineSliceAccessor, type RetroScreenAnsiMetadata, RetroScreenAnsiParser, RetroScreenAnsiPlayer, type RetroScreenAnsiPlayerProps, type RetroScreenAnsiPlayerState, type RetroScreenAnsiSnapshotFrame, type RetroScreenAnsiSnapshotPlayerState, type RetroScreenAnsiSnapshotStorageMode, type RetroScreenAnsiSnapshotStream, type RetroScreenAnsiSnapshotStreamSnapshot, type RetroScreenAnsiSourceGeometry, type RetroScreenAnsiViewportWindow, type RetroScreenCell, type RetroScreenCellIntensity, type RetroScreenCellStyle, type RetroScreenController, type RetroScreenCursorState, type RetroScreenDisplayColorMode, type RetroScreenDisplayPadding, type RetroScreenDisplayPaddingValue, type RetroScreenDisplaySurfaceMode, type RetroScreenEditorModeProps, type RetroScreenEditorSession, type RetroScreenEditorSessionOptions, type RetroScreenEditorSessionState, type RetroScreenGeometry, type RetroScreenPromptCommandResult, type RetroScreenPromptModeProps, type RetroScreenPromptSession, type RetroScreenPromptSessionOptions, type RetroScreenProps, type RetroScreenRenderModel, type RetroScreenResizeMode, RetroScreenScreenBuffer, type RetroScreenScreenBufferOptions, type RetroScreenScreenSnapshot, type RetroScreenSharedProps, type RetroScreenTerminalColor, type RetroScreenTerminalHostAdapter, type RetroScreenTerminalHostKeyEvent, type RetroScreenTerminalInputAdapter, type RetroScreenTerminalInputEncodingOptions, type RetroScreenTerminalModeProps, type RetroScreenTerminalModes, type RetroScreenTerminalMouseAction, type RetroScreenTerminalMouseButton, type RetroScreenTerminalMouseEncodingOptions, type RetroScreenTerminalMouseEvent, type RetroScreenTerminalMouseProtocol, type RetroScreenTerminalMouseTrackingMode, type RetroScreenTerminalOutputAdapter, type RetroScreenTerminalPasteEncodingOptions, type RetroScreenTerminalSession, type RetroScreenTerminalSessionEvent, type RetroScreenTerminalSessionGeometry, type RetroScreenTerminalSessionListener, type RetroScreenTerminalSessionState, type RetroScreenTerminalWebSocketConstructor, type RetroScreenTerminalWebSocketLike, type RetroScreenTerminalWebSocketSessionOptions, type RetroScreenTextSelection, type RetroScreenValueModeProps, type RetroScreenWriteChunk, type RetroScreenWriteOptions, ansiSnapshotToRenderModelWindow, clampRetroScreenTextOffset, collapseRetroScreenTextSelectionToEnd, collapseRetroScreenTextSelectionToStart, createRetroScreenAnsiFrameStream, createRetroScreenAnsiSnapshotStream, createRetroScreenController, createRetroScreenEditorSession, createRetroScreenPromptSession, createRetroScreenTextSelection, createRetroScreenWebSocketSession, decodeRetroScreenAnsiBytes, deleteRetroScreenSelectedText, encodeRetroScreenTerminalFocusReport, encodeRetroScreenTerminalInput, encodeRetroScreenTerminalMouse, encodeRetroScreenTerminalPaste, findRetroScreenAnsiSauceIndex, findRetroScreenNextWordBoundary, findRetroScreenPreviousWordBoundary, getRetroScreenWordSelectionAtOffset, isRetroScreenTextSelectionCollapsed, materializeRetroScreenAnsiFrames, materializeRetroScreenAnsiSnapshots, measureGrid, normalizeRetroScreenAnsiByteChunk, normalizeRetroScreenAnsiViewportWindow, normalizeRetroScreenTextSelection, parseRetroScreenAnsiSauce, replaceRetroScreenSelectedText, resolveRetroScreenAnsiSourceGeometry, splitRetroScreenAnsiBytes, stripRetroScreenAnsiSauce, useRetroScreenAnsiPlayer, useRetroScreenAnsiSnapshotPlayer, useRetroScreenController, useRetroScreenEditorSession, useRetroScreenGeometry, useRetroScreenPromptSession, useRetroScreenTerminalBridge, wrapTextToColumns };