@easbot/tui 0.1.7

package/dist/index.d.ts

@@ -0,0 +1,762 @@
+import { EventEmitter } from 'node:events';
+
+interface AutocompleteItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+interface SlashCommand {
+    name: string;
+    description?: string;
+    getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
+}
+interface AutocompleteProvider {
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+    };
+}
+declare class CombinedAutocompleteProvider implements AutocompleteProvider {
+    private commands;
+    private basePath;
+    private fdPath;
+    constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string, fdPath?: string | null);
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+    };
+    private extractAtPrefix;
+    private extractPathPrefix;
+    private expandHomePath;
+    private resolveScopedFuzzyQuery;
+    private scopedPathForDisplay;
+    private getFileSuggestions;
+    private scoreEntry;
+    private getFuzzyFileSuggestions;
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+}
+
+interface Terminal {
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    write(data: string): void;
+    get columns(): number;
+    get rows(): number;
+    get kittyProtocolActive(): boolean;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+}
+declare class ProcessTerminal implements Terminal {
+    private wasRaw;
+    private inputHandler?;
+    private resizeHandler?;
+    private _kittyProtocolActive;
+    private stdinBuffer?;
+    private stdinDataHandler?;
+    private writeLogPath;
+    get kittyProtocolActive(): boolean;
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    private setupStdinBuffer;
+    private queryAndEnableKittyProtocol;
+    private enableWindowsVTInput;
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    stop(): void;
+    write(data: string): void;
+    get columns(): number;
+    get rows(): number;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+}
+
+declare function visibleWidth(str: string): number;
+declare function wrapTextWithAnsi(text: string, width: number): string[];
+declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string, pad?: boolean): string;
+declare function sliceByColumn(line: string, startCol: number, length: number, strict?: boolean): string;
+
+interface Component {
+    render(width: number): string[];
+    handleInput?(data: string): void;
+    wantsKeyRelease?: boolean;
+    invalidate(): void;
+}
+type InputListenerResult = {
+    consume?: boolean;
+    data?: string;
+} | undefined;
+type InputListener = (data: string) => InputListenerResult;
+interface Focusable {
+    focused: boolean;
+}
+declare function isFocusable(component: Component | null): component is Component & Focusable;
+declare const CURSOR_MARKER = "\u001B_pi:c\u0007";
+
+type OverlayAnchor = 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center' | 'left-center' | 'right-center';
+interface OverlayMargin {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+type SizeValue = number | `${number}%`;
+interface OverlayOptions {
+    width?: SizeValue;
+    minWidth?: number;
+    maxHeight?: SizeValue;
+    anchor?: OverlayAnchor;
+    offsetX?: number;
+    offsetY?: number;
+    row?: SizeValue;
+    col?: SizeValue;
+    margin?: OverlayMargin | number;
+    visible?: (termWidth: number, termHeight: number) => boolean;
+}
+interface OverlayHandle {
+    hide(): void;
+    setHidden(hidden: boolean): void;
+    isHidden(): boolean;
+}
+declare class Container implements Component {
+    children: Component[];
+    addChild(component: Component): void;
+    removeChild(component: Component): void;
+    clear(): void;
+    invalidate(): void;
+    render(width: number): string[];
+}
+declare class TUI extends Container {
+    terminal: Terminal;
+    private previousLines;
+    private previousWidth;
+    private focusedComponent;
+    private inputListeners;
+    onDebug?: () => void;
+    private renderRequested;
+    private cursorRow;
+    private hardwareCursorRow;
+    private inputBuffer;
+    private cellSizeQueryPending;
+    private showHardwareCursor;
+    private clearOnShrink;
+    private maxLinesRendered;
+    private previousViewportTop;
+    private fullRedrawCount;
+    private stopped;
+    private overlayStack;
+    constructor(terminal: Terminal, showHardwareCursor?: boolean);
+    get fullRedraws(): number;
+    getShowHardwareCursor(): boolean;
+    setShowHardwareCursor(enabled: boolean): void;
+    getClearOnShrink(): boolean;
+    setClearOnShrink(enabled: boolean): void;
+    setFocus(component: Component | null): void;
+    showOverlay(component: Component, options?: OverlayOptions): OverlayHandle;
+    hideOverlay(): void;
+    hasOverlay(): boolean;
+    private isOverlayVisible;
+    private getTopmostVisibleOverlay;
+    invalidate(): void;
+    start(): void;
+    addInputListener(listener: InputListener): () => void;
+    removeInputListener(listener: InputListener): void;
+    private queryCellSize;
+    stop(): void;
+    requestRender(force?: boolean): void;
+    private handleInput;
+    private parseCellSizeResponse;
+    private resolveOverlayLayout;
+    private resolveAnchorRow;
+    private resolveAnchorCol;
+    private compositeOverlays;
+    private static readonly SEGMENT_RESET;
+    private applyLineResets;
+    private compositeLineAt;
+    private extractCursorPosition;
+    private doRender;
+    private positionHardwareCursor;
+}
+
+declare class Box implements Component {
+    children: Component[];
+    private paddingX;
+    private paddingY;
+    private bgFn?;
+    private cache?;
+    constructor(paddingX?: number, paddingY?: number, bgFn?: (text: string) => string);
+    addChild(component: Component): void;
+    removeChild(component: Component): void;
+    clear(): void;
+    setBgFn(bgFn?: (text: string) => string): void;
+    private invalidateCache;
+    private matchCache;
+    invalidate(): void;
+    render(width: number): string[];
+    private applyBg;
+}
+
+declare class Text implements Component {
+    private text;
+    private paddingX;
+    private paddingY;
+    private customBgFn?;
+    private cachedText?;
+    private cachedWidth?;
+    private cachedLines?;
+    constructor(text?: string, paddingX?: number, paddingY?: number, customBgFn?: (text: string) => string);
+    setText(text: string): void;
+    setCustomBgFn(customBgFn?: (text: string) => string): void;
+    invalidate(): void;
+    render(width: number): string[];
+}
+
+declare class Loader extends Text {
+    private spinnerColorFn;
+    private messageColorFn;
+    private message;
+    private frames;
+    private currentFrame;
+    private intervalId;
+    private ui;
+    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string);
+    render(width: number): string[];
+    start(): void;
+    stop(): void;
+    setMessage(message: string): void;
+    private updateDisplay;
+}
+
+declare class CancellableLoader extends Loader {
+    private abortController;
+    onAbort?: () => void;
+    get signal(): AbortSignal;
+    get aborted(): boolean;
+    handleInput(data: string): void;
+    dispose(): void;
+}
+
+interface SelectItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+interface SelectListTheme {
+    selectedPrefix: (text: string) => string;
+    selectedText: (text: string) => string;
+    description: (text: string) => string;
+    scrollInfo: (text: string) => string;
+    noMatch: (text: string) => string;
+}
+declare class SelectList implements Component {
+    private items;
+    private filteredItems;
+    private selectedIndex;
+    private maxVisible;
+    private theme;
+    onSelect?: (item: SelectItem) => void;
+    onCancel?: () => void;
+    onSelectionChange?: (item: SelectItem) => void;
+    constructor(items: SelectItem[], maxVisible: number, theme: SelectListTheme);
+    setFilter(filter: string): void;
+    setSelectedIndex(index: number): void;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+    private notifySelectionChange;
+    getSelectedItem(): SelectItem | null;
+}
+
+interface EditorTheme {
+    borderColor: (str: string) => string;
+    selectList: SelectListTheme;
+}
+interface EditorOptions {
+    paddingX?: number;
+    autocompleteMaxVisible?: number;
+}
+declare class Editor implements Component, Focusable {
+    private state;
+    focused: boolean;
+    protected tui: TUI;
+    private theme;
+    private paddingX;
+    private lastWidth;
+    private scrollOffset;
+    borderColor: (str: string) => string;
+    private autocompleteProvider?;
+    private autocompleteList?;
+    private autocompleteState;
+    private autocompletePrefix;
+    private autocompleteMaxVisible;
+    private pastes;
+    private pasteCounter;
+    private pasteBuffer;
+    private isInPaste;
+    private history;
+    private historyIndex;
+    private killRing;
+    private lastAction;
+    private jumpMode;
+    private preferredVisualCol;
+    private undoStack;
+    onSubmit?: (text: string) => void;
+    onChange?: (text: string) => void;
+    disableSubmit: boolean;
+    constructor(tui: TUI, theme: EditorTheme, options?: EditorOptions);
+    getPaddingX(): number;
+    setPaddingX(padding: number): void;
+    getAutocompleteMaxVisible(): number;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    setAutocompleteProvider(provider: AutocompleteProvider): void;
+    addToHistory(text: string): void;
+    private isEditorEmpty;
+    private isOnFirstVisualLine;
+    private isOnLastVisualLine;
+    private navigateHistory;
+    private setTextInternal;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    private layoutText;
+    getText(): string;
+    getExpandedText(): string;
+    getLines(): string[];
+    getCursor(): {
+        line: number;
+        col: number;
+    };
+    setText(text: string): void;
+    insertTextAtCursor(text: string): void;
+    private insertTextAtCursorInternal;
+    private insertCharacter;
+    private handlePaste;
+    private addNewLine;
+    private shouldSubmitOnBackslashEnter;
+    private submitValue;
+    private handleBackspace;
+    private setCursorCol;
+    private moveToVisualLine;
+    private computeVerticalMoveColumn;
+    private moveToLineStart;
+    private moveToLineEnd;
+    private deleteToStartOfLine;
+    private deleteToEndOfLine;
+    private deleteWordBackwards;
+    private deleteWordForward;
+    private handleForwardDelete;
+    private buildVisualLineMap;
+    private findCurrentVisualLine;
+    private moveCursor;
+    private pageScroll;
+    private moveWordBackwards;
+    private yank;
+    private yankPop;
+    private insertYankedText;
+    private deleteYankedText;
+    private pushUndoSnapshot;
+    private undo;
+    private jumpToChar;
+    private moveWordForwards;
+    private isSlashMenuAllowed;
+    private isAtStartOfMessage;
+    private isInSlashCommandContext;
+    private tryTriggerAutocomplete;
+    private handleTabCompletion;
+    private handleSlashCommandCompletion;
+    private forceFileAutocomplete;
+    private cancelAutocomplete;
+    isShowingAutocomplete(): boolean;
+    private updateAutocomplete;
+}
+
+type ImageProtocol = 'kitty' | 'iterm2' | null;
+interface TerminalCapabilities {
+    images: ImageProtocol;
+    trueColor: boolean;
+    hyperlinks: boolean;
+}
+interface CellDimensions {
+    widthPx: number;
+    heightPx: number;
+}
+interface ImageDimensions {
+    widthPx: number;
+    heightPx: number;
+}
+interface ImageRenderOptions {
+    maxWidthCells?: number;
+    maxHeightCells?: number;
+    preserveAspectRatio?: boolean;
+    imageId?: number;
+}
+declare function getCellDimensions(): CellDimensions;
+declare function setCellDimensions(dims: CellDimensions): void;
+declare function detectCapabilities(): TerminalCapabilities;
+declare function getCapabilities(): TerminalCapabilities;
+declare function resetCapabilitiesCache(): void;
+declare function allocateImageId(): number;
+declare function encodeKitty(base64Data: string, options?: {
+    columns?: number;
+    rows?: number;
+    imageId?: number;
+}): string;
+declare function deleteKittyImage(imageId: number): string;
+declare function deleteAllKittyImages(): string;
+declare function encodeITerm2(base64Data: string, options?: {
+    width?: number | string;
+    height?: number | string;
+    name?: string;
+    preserveAspectRatio?: boolean;
+    inline?: boolean;
+}): string;
+declare function calculateImageRows(imageDimensions: ImageDimensions, targetWidthCells: number, cellDimensions?: CellDimensions): number;
+declare function getPngDimensions(base64Data: string): ImageDimensions | null;
+declare function getJpegDimensions(base64Data: string): ImageDimensions | null;
+declare function getGifDimensions(base64Data: string): ImageDimensions | null;
+declare function getWebpDimensions(base64Data: string): ImageDimensions | null;
+declare function getImageDimensions(base64Data: string, mimeType: string): ImageDimensions | null;
+declare function renderImage(base64Data: string, imageDimensions: ImageDimensions, options?: ImageRenderOptions): {
+    sequence: string;
+    rows: number;
+    imageId?: number;
+} | null;
+declare function imageFallback(mimeType: string, dimensions?: ImageDimensions, filename?: string): string;
+
+interface ImageTheme {
+    fallbackColor: (str: string) => string;
+}
+interface ImageOptions {
+    maxWidthCells?: number;
+    maxHeightCells?: number;
+    filename?: string;
+    imageId?: number;
+}
+declare class Image implements Component {
+    private base64Data;
+    private mimeType;
+    private dimensions;
+    private theme;
+    private options;
+    private imageId?;
+    private cachedLines?;
+    private cachedWidth?;
+    constructor(base64Data: string, mimeType: string, theme: ImageTheme, options?: ImageOptions, dimensions?: ImageDimensions);
+    getImageId(): number | undefined;
+    invalidate(): void;
+    render(width: number): string[];
+}
+
+declare class Input implements Component, Focusable {
+    private value;
+    private cursor;
+    onSubmit?: (value: string) => void;
+    onEscape?: () => void;
+    focused: boolean;
+    private pasteBuffer;
+    private isInPaste;
+    private killRing;
+    private lastAction;
+    private undoStack;
+    getValue(): string;
+    setValue(value: string): void;
+    handleInput(data: string): void;
+    private insertCharacter;
+    private handleBackspace;
+    private handleForwardDelete;
+    private deleteToLineStart;
+    private deleteToLineEnd;
+    private deleteWordBackwards;
+    private deleteWordForward;
+    private yank;
+    private yankPop;
+    private pushUndo;
+    private undo;
+    private moveWordBackwards;
+    private moveWordForwards;
+    private handlePaste;
+    invalidate(): void;
+    render(width: number): string[];
+}
+
+interface DefaultTextStyle {
+    color?: (text: string) => string;
+    bgColor?: (text: string) => string;
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    underline?: boolean;
+}
+interface MarkdownTheme {
+    heading: (text: string) => string;
+    link: (text: string) => string;
+    linkUrl: (text: string) => string;
+    code: (text: string) => string;
+    codeBlock: (text: string) => string;
+    codeBlockBorder: (text: string) => string;
+    quote: (text: string) => string;
+    quoteBorder: (text: string) => string;
+    hr: (text: string) => string;
+    listBullet: (text: string) => string;
+    bold: (text: string) => string;
+    italic: (text: string) => string;
+    strikethrough: (text: string) => string;
+    underline: (text: string) => string;
+    highlightCode?: (code: string, lang?: string) => string[];
+    codeBlockIndent?: string;
+}
+declare class Markdown implements Component {
+    private text;
+    private paddingX;
+    private paddingY;
+    private defaultTextStyle?;
+    private theme;
+    private defaultStylePrefix?;
+    private cachedText?;
+    private cachedWidth?;
+    private cachedLines?;
+    constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle);
+    setText(text: string): void;
+    invalidate(): void;
+    render(width: number): string[];
+    private applyDefaultStyle;
+    private getDefaultStylePrefix;
+    private getStylePrefix;
+    private getDefaultInlineStyleContext;
+    private renderToken;
+    private renderInlineTokens;
+    private renderList;
+    private renderListItem;
+    private getLongestWordWidth;
+    private wrapCellText;
+    private renderTable;
+}
+
+interface SettingItem {
+    id: string;
+    label: string;
+    description?: string;
+    currentValue: string;
+    values?: string[];
+    submenu?: (currentValue: string, done: (selectedValue?: string) => void) => Component;
+}
+interface SettingsListTheme {
+    label: (text: string, selected: boolean) => string;
+    value: (text: string, selected: boolean) => string;
+    description: (text: string) => string;
+    cursor: string;
+    hint: (text: string) => string;
+}
+interface SettingsListOptions {
+    enableSearch?: boolean;
+}
+declare class SettingsList implements Component {
+    private items;
+    private filteredItems;
+    private theme;
+    private selectedIndex;
+    private maxVisible;
+    private onChange;
+    private onCancel;
+    private searchInput?;
+    private searchEnabled;
+    private submenuComponent;
+    private submenuItemIndex;
+    constructor(items: SettingItem[], maxVisible: number, theme: SettingsListTheme, onChange: (id: string, newValue: string) => void, onCancel: () => void, options?: SettingsListOptions);
+    updateValue(id: string, newValue: string): void;
+    invalidate(): void;
+    render(width: number): string[];
+    private renderMainList;
+    handleInput(data: string): void;
+    private activateItem;
+    private closeSubmenu;
+    private applyFilter;
+    private addHintLine;
+}
+
+declare class Spacer implements Component {
+    private lines;
+    constructor(lines?: number);
+    setLines(lines: number): void;
+    invalidate(): void;
+    render(_width: number): string[];
+}
+
+declare class TruncatedText implements Component {
+    private text;
+    private paddingX;
+    private paddingY;
+    constructor(text: string, paddingX?: number, paddingY?: number);
+    invalidate(): void;
+    render(width: number): string[];
+}
+
+interface EditorComponent extends Component {
+    getText(): string;
+    setText(text: string): void;
+    handleInput(data: string): void;
+    onSubmit?: (text: string) => void;
+    onChange?: (text: string) => void;
+    addToHistory?(text: string): void;
+    insertTextAtCursor?(text: string): void;
+    getExpandedText?(): string;
+    setAutocompleteProvider?(provider: AutocompleteProvider): void;
+    borderColor?: (str: string) => string;
+    setPaddingX?(padding: number): void;
+    setAutocompleteMaxVisible?(maxVisible: number): void;
+}
+
+interface FuzzyMatch {
+    matches: boolean;
+    score: number;
+}
+declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
+declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[];
+
+declare function setKittyProtocolActive(active: boolean): void;
+declare function isKittyProtocolActive(): boolean;
+type Letter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type SymbolKey = '`' | '-' | '=' | '[' | ']' | '\\' | ';' | "'" | ',' | '.' | '/' | '!' | '@' | '#' | '$' | '%' | '^' | '&' | '*' | '(' | ')' | '_' | '+' | '|' | '~' | '{' | '}' | ':' | '<' | '>' | '?';
+type SpecialKey = 'escape' | 'esc' | 'enter' | 'return' | 'tab' | 'space' | 'backspace' | 'delete' | 'insert' | 'clear' | 'home' | 'end' | 'pageUp' | 'pageDown' | 'up' | 'down' | 'left' | 'right' | 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12';
+type BaseKey = Letter | SymbolKey | SpecialKey;
+type KeyId = BaseKey | `ctrl+${BaseKey}` | `shift+${BaseKey}` | `alt+${BaseKey}` | `ctrl+shift+${BaseKey}` | `shift+ctrl+${BaseKey}` | `ctrl+alt+${BaseKey}` | `alt+ctrl+${BaseKey}` | `shift+alt+${BaseKey}` | `alt+shift+${BaseKey}` | `ctrl+shift+alt+${BaseKey}` | `ctrl+alt+shift+${BaseKey}` | `shift+ctrl+alt+${BaseKey}` | `shift+alt+ctrl+${BaseKey}` | `alt+ctrl+shift+${BaseKey}` | `alt+shift+ctrl+${BaseKey}`;
+declare const Key: {
+    readonly escape: "escape";
+    readonly esc: "esc";
+    readonly enter: "enter";
+    readonly return: "return";
+    readonly tab: "tab";
+    readonly space: "space";
+    readonly backspace: "backspace";
+    readonly delete: "delete";
+    readonly insert: "insert";
+    readonly clear: "clear";
+    readonly home: "home";
+    readonly end: "end";
+    readonly pageUp: "pageUp";
+    readonly pageDown: "pageDown";
+    readonly up: "up";
+    readonly down: "down";
+    readonly left: "left";
+    readonly right: "right";
+    readonly f1: "f1";
+    readonly f2: "f2";
+    readonly f3: "f3";
+    readonly f4: "f4";
+    readonly f5: "f5";
+    readonly f6: "f6";
+    readonly f7: "f7";
+    readonly f8: "f8";
+    readonly f9: "f9";
+    readonly f10: "f10";
+    readonly f11: "f11";
+    readonly f12: "f12";
+    readonly backtick: "`";
+    readonly hyphen: "-";
+    readonly equals: "=";
+    readonly leftbracket: "[";
+    readonly rightbracket: "]";
+    readonly backslash: "\\";
+    readonly semicolon: ";";
+    readonly quote: "'";
+    readonly comma: ",";
+    readonly period: ".";
+    readonly slash: "/";
+    readonly exclamation: "!";
+    readonly at: "@";
+    readonly hash: "#";
+    readonly dollar: "$";
+    readonly percent: "%";
+    readonly caret: "^";
+    readonly ampersand: "&";
+    readonly asterisk: "*";
+    readonly leftparen: "(";
+    readonly rightparen: ")";
+    readonly underscore: "_";
+    readonly plus: "+";
+    readonly pipe: "|";
+    readonly tilde: "~";
+    readonly leftbrace: "{";
+    readonly rightbrace: "}";
+    readonly colon: ":";
+    readonly lessthan: "<";
+    readonly greaterthan: ">";
+    readonly question: "?";
+    readonly ctrl: <K extends BaseKey>(key: K) => `ctrl+${K}`;
+    readonly shift: <K extends BaseKey>(key: K) => `shift+${K}`;
+    readonly alt: <K extends BaseKey>(key: K) => `alt+${K}`;
+    readonly ctrlShift: <K extends BaseKey>(key: K) => `ctrl+shift+${K}`;
+    readonly shiftCtrl: <K extends BaseKey>(key: K) => `shift+ctrl+${K}`;
+    readonly ctrlAlt: <K extends BaseKey>(key: K) => `ctrl+alt+${K}`;
+    readonly altCtrl: <K extends BaseKey>(key: K) => `alt+ctrl+${K}`;
+    readonly shiftAlt: <K extends BaseKey>(key: K) => `shift+alt+${K}`;
+    readonly altShift: <K extends BaseKey>(key: K) => `alt+shift+${K}`;
+    readonly ctrlShiftAlt: <K extends BaseKey>(key: K) => `ctrl+shift+alt+${K}`;
+};
+type KeyEventType = 'press' | 'repeat' | 'release';
+declare function isKeyRelease(data: string): boolean;
+declare function isKeyRepeat(data: string): boolean;
+declare function matchesKey(data: string, keyId: KeyId): boolean;
+declare function parseKey(data: string): string | undefined;
+
+type EditorAction = 'cursorUp' | 'cursorDown' | 'cursorLeft' | 'cursorRight' | 'cursorWordLeft' | 'cursorWordRight' | 'cursorLineStart' | 'cursorLineEnd' | 'jumpForward' | 'jumpBackward' | 'pageUp' | 'pageDown' | 'deleteCharBackward' | 'deleteCharForward' | 'deleteWordBackward' | 'deleteWordForward' | 'deleteToLineStart' | 'deleteToLineEnd' | 'newLine' | 'submit' | 'tab' | 'selectUp' | 'selectDown' | 'selectPageUp' | 'selectPageDown' | 'selectConfirm' | 'selectCancel' | 'copy' | 'yank' | 'yankPop' | 'undo' | 'expandTools' | 'toggleSessionPath' | 'toggleSessionSort' | 'renameSession' | 'deleteSession' | 'deleteSessionNoninvasive';
+
+type EditorKeybindingsConfig = {
+    [K in EditorAction]?: KeyId | KeyId[];
+};
+declare const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig>;
+declare class EditorKeybindingsManager {
+    private actionToKeys;
+    constructor(config?: EditorKeybindingsConfig);
+    private buildMaps;
+    matches(data: string, action: EditorAction): boolean;
+    getKeys(action: EditorAction): KeyId[];
+    setConfig(config: EditorKeybindingsConfig): void;
+}
+declare function getEditorKeybindings(): EditorKeybindingsManager;
+declare function setEditorKeybindings(manager: EditorKeybindingsManager): void;
+
+type StdinBufferOptions = {
+    timeout?: number;
+};
+type StdinBufferEventMap = {
+    data: [string];
+    paste: [string];
+};
+declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
+    private buffer;
+    private timeout;
+    private readonly timeoutMs;
+    private pasteMode;
+    private pasteBuffer;
+    constructor(options?: StdinBufferOptions);
+    process(data: string | Buffer): void;
+    flush(): string[];
+    clear(): void;
+    getBuffer(): string;
+    destroy(): void;
+}
+
+export { type AutocompleteItem, type AutocompleteProvider, Box, CURSOR_MARKER, CancellableLoader, type CellDimensions, CombinedAutocompleteProvider, type Component, Container, DEFAULT_EDITOR_KEYBINDINGS, type DefaultTextStyle, Editor, type EditorAction, type EditorComponent, type EditorKeybindingsConfig, EditorKeybindingsManager, type EditorOptions, type EditorTheme, type Focusable, type FuzzyMatch, Image, type ImageDimensions, type ImageOptions, type ImageProtocol, type ImageRenderOptions, type ImageTheme, Input, Key, type KeyEventType, type KeyId, Loader, Markdown, type MarkdownTheme, type OverlayAnchor, type OverlayHandle, type OverlayMargin, type OverlayOptions, ProcessTerminal, type SelectItem, SelectList, type SelectListTheme, type SettingItem, SettingsList, type SettingsListTheme, type SizeValue, type SlashCommand, Spacer, StdinBuffer, type StdinBufferEventMap, type StdinBufferOptions, TUI, type Terminal, type TerminalCapabilities, Text, TruncatedText, allocateImageId, calculateImageRows, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, fuzzyFilter, fuzzyMatch, getCapabilities, getCellDimensions, getEditorKeybindings, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getWebpDimensions, imageFallback, isFocusable, isKeyRelease, isKeyRepeat, isKittyProtocolActive, matchesKey, parseKey, renderImage, resetCapabilitiesCache, setCellDimensions, setEditorKeybindings, setKittyProtocolActive, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi };