@easbot/tui 0.2.1 → 0.2.3

package/dist/index.d.cts

@@ -5,38 +5,45 @@ interface AutocompleteItem {
     label: string;
     description?: string;
 }
+type Awaitable<T> = T | Promise<T>;
 interface SlashCommand {
     name: string;
     description?: string;
-    getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
+    argumentHint?: string;
+    getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
+}
+interface AutocompleteSuggestions {
+    items: AutocompleteItem[];
+    prefix: string;
 }
 interface AutocompleteProvider {
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null;
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, options: {
+        signal: AbortSignal;
+        force?: boolean;
+    }): Promise<AutocompleteSuggestions | null>;
     applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
         lines: string[];
         cursorLine: number;
         cursorCol: number;
     };
-    updateCommands?(commands: SlashCommand[]): void;
+    shouldTriggerFileCompletion?(lines: string[], cursorLine: number, cursorCol: number): boolean;
 }
 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;
+    constructor(commands: (SlashCommand | AutocompleteItem)[] | undefined, basePath: string, fdPath?: string | null);
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, options: {
+        signal: AbortSignal;
+        force?: boolean;
+    }): Promise<AutocompleteSuggestions | null>;
     applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
         lines: string[];
         cursorLine: number;
         cursorCol: number;
     };
     private extractAtPrefix;
+    private extractHashPrefix;
     private extractPathPrefix;
     private expandHomePath;
     private resolveScopedFuzzyQuery;
@@ -44,10 +51,6 @@ declare class CombinedAutocompleteProvider implements AutocompleteProvider {
     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;
 }
 
@@ -66,14 +69,17 @@ interface Terminal {
     clearFromCursor(): void;
     clearScreen(): void;
     setTitle(title: string): void;
+    setProgress(active: boolean): void;
 }
 declare class ProcessTerminal implements Terminal {
     private wasRaw;
     private inputHandler?;
     private resizeHandler?;
     private _kittyProtocolActive;
+    private _modifyOtherKeysActive;
     private stdinBuffer?;
     private stdinDataHandler?;
+    private progressInterval?;
     private writeLogPath;
     get kittyProtocolActive(): boolean;
     start(onInput: (data: string) => void, onResize: () => void): void;
@@ -92,12 +98,13 @@ declare class ProcessTerminal implements Terminal {
     clearFromCursor(): void;
     clearScreen(): void;
     setTitle(title: string): void;
+    setProgress(active: boolean): void;
+    private clearProgressInterval;
 }
 
 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[];
@@ -135,11 +142,15 @@ interface OverlayOptions {
     col?: SizeValue;
     margin?: OverlayMargin | number;
     visible?: (termWidth: number, termHeight: number) => boolean;
+    nonCapturing?: boolean;
 }
 interface OverlayHandle {
     hide(): void;
     setHidden(hidden: boolean): void;
     isHidden(): boolean;
+    focus(): void;
+    unfocus(): void;
+    isFocused(): boolean;
 }
 declare class Container implements Component {
     children: Component[];
@@ -153,20 +164,23 @@ declare class TUI extends Container {
     terminal: Terminal;
     private previousLines;
     private previousWidth;
+    private previousHeight;
     private focusedComponent;
     private inputListeners;
     onDebug?: () => void;
     private renderRequested;
+    private renderTimer;
+    private lastRenderAt;
+    private static readonly MIN_RENDER_INTERVAL_MS;
     private cursorRow;
     private hardwareCursorRow;
-    private inputBuffer;
-    private cellSizeQueryPending;
     private showHardwareCursor;
     private clearOnShrink;
     private maxLinesRendered;
     private previousViewportTop;
     private fullRedrawCount;
     private stopped;
+    private focusOrderCounter;
     private overlayStack;
     constructor(terminal: Terminal, showHardwareCursor?: boolean);
     get fullRedraws(): number;
@@ -187,8 +201,9 @@ declare class TUI extends Container {
     private queryCellSize;
     stop(): void;
     requestRender(force?: boolean): void;
+    private scheduleRender;
     private handleInput;
-    private parseCellSizeResponse;
+    private consumeCellSizeResponse;
     private resolveOverlayLayout;
     private resolveAnchorRow;
     private resolveAnchorCol;
@@ -234,19 +249,27 @@ declare class Text implements Component {
     render(width: number): string[];
 }
 
+interface LoaderIndicatorOptions {
+    frames?: string[];
+    intervalMs?: number;
+}
 declare class Loader extends Text {
     private spinnerColorFn;
     private messageColorFn;
     private message;
     private frames;
+    private intervalMs;
     private currentFrame;
     private intervalId;
     private ui;
-    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string);
+    private renderIndicatorVerbatim;
+    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string, indicator?: LoaderIndicatorOptions);
     render(width: number): string[];
     start(): void;
     stop(): void;
     setMessage(message: string): void;
+    setIndicator(indicator?: LoaderIndicatorOptions): void;
+    private restartAnimation;
     private updateDisplay;
 }
 
@@ -271,21 +294,39 @@ interface SelectListTheme {
     scrollInfo: (text: string) => string;
     noMatch: (text: string) => string;
 }
+interface SelectListTruncatePrimaryContext {
+    text: string;
+    maxWidth: number;
+    columnWidth: number;
+    item: SelectItem;
+    isSelected: boolean;
+}
+interface SelectListLayoutOptions {
+    minPrimaryColumnWidth?: number;
+    maxPrimaryColumnWidth?: number;
+    truncatePrimary?: (context: SelectListTruncatePrimaryContext) => string;
+}
 declare class SelectList implements Component {
     private items;
     private filteredItems;
     private selectedIndex;
     private maxVisible;
     private theme;
+    private layout;
     onSelect?: (item: SelectItem) => void;
     onCancel?: () => void;
     onSelectionChange?: (item: SelectItem) => void;
-    constructor(items: SelectItem[], maxVisible: number, theme: SelectListTheme);
+    constructor(items: SelectItem[], maxVisible: number, theme: SelectListTheme, layout?: SelectListLayoutOptions);
     setFilter(filter: string): void;
     setSelectedIndex(index: number): void;
     invalidate(): void;
     render(width: number): string[];
     handleInput(keyData: string): void;
+    private renderItem;
+    private getPrimaryColumnWidth;
+    private getPrimaryColumnBounds;
+    private truncatePrimary;
+    private getDisplayValue;
     private notifySelectionChange;
     getSelectedItem(): SelectItem | null;
 }
@@ -312,6 +353,11 @@ declare class Editor implements Component, Focusable {
     private autocompleteState;
     private autocompletePrefix;
     private autocompleteMaxVisible;
+    private autocompleteAbort?;
+    private autocompleteDebounceTimer?;
+    private autocompleteRequestTask;
+    private autocompleteStartToken;
+    private autocompleteRequestId;
     private pastes;
     private pasteCounter;
     private pasteBuffer;
@@ -322,11 +368,14 @@ declare class Editor implements Component, Focusable {
     private lastAction;
     private jumpMode;
     private preferredVisualCol;
+    private snappedFromCursorCol;
     private undoStack;
     onSubmit?: (text: string) => void;
     onChange?: (text: string) => void;
     disableSubmit: boolean;
     constructor(tui: TUI, theme: EditorTheme, options?: EditorOptions);
+    private validPasteIds;
+    private segment;
     getPaddingX(): number;
     setPaddingX(padding: number): void;
     getAutocompleteMaxVisible(): number;
@@ -343,6 +392,7 @@ declare class Editor implements Component, Focusable {
     handleInput(data: string): void;
     private layoutText;
     getText(): string;
+    private expandPasteMarkers;
     getExpandedText(): string;
     getLines(): string[];
     getCursor(): {
@@ -351,6 +401,7 @@ declare class Editor implements Component, Focusable {
     };
     setText(text: string): void;
     insertTextAtCursor(text: string): void;
+    private normalizeText;
     private insertTextAtCursorInternal;
     private insertCharacter;
     private handlePaste;
@@ -369,6 +420,7 @@ declare class Editor implements Component, Focusable {
     private deleteWordForward;
     private handleForwardDelete;
     private buildVisualLineMap;
+    private findVisualLineAt;
     private findCurrentVisualLine;
     private moveCursor;
     private pageScroll;
@@ -384,10 +436,20 @@ declare class Editor implements Component, Focusable {
     private isSlashMenuAllowed;
     private isAtStartOfMessage;
     private isInSlashCommandContext;
+    private getBestAutocompleteMatchIndex;
+    private createAutocompleteList;
     private tryTriggerAutocomplete;
     private handleTabCompletion;
     private handleSlashCommandCompletion;
     private forceFileAutocomplete;
+    private requestAutocomplete;
+    private startAutocompleteRequest;
+    private getAutocompleteDebounceMs;
+    private runAutocompleteRequest;
+    private isAutocompleteRequestCurrent;
+    private applyAutocompleteSuggestions;
+    private cancelAutocompleteRequest;
+    private clearAutocompleteUi;
     private cancelAutocomplete;
     isShowingAutocomplete(): boolean;
     private updateAutocomplete;
@@ -418,6 +480,7 @@ declare function setCellDimensions(dims: CellDimensions): void;
 declare function detectCapabilities(): TerminalCapabilities;
 declare function getCapabilities(): TerminalCapabilities;
 declare function resetCapabilitiesCache(): void;
+declare function setCapabilities(caps: TerminalCapabilities): void;
 declare function allocateImageId(): number;
 declare function encodeKitty(base64Data: string, options?: {
     columns?: number;
@@ -444,6 +507,7 @@ declare function renderImage(base64Data: string, imageDimensions: ImageDimension
     rows: number;
     imageId?: number;
 } | null;
+declare function hyperlink(text: string, url: string): string;
 declare function imageFallback(mimeType: string, dimensions?: ImageDimensions, filename?: string): string;
 
 interface ImageTheme {
@@ -639,10 +703,15 @@ declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: 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 Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
 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}`;
+type BaseKey = Letter | Digit | SymbolKey | SpecialKey;
+type ModifierName = 'ctrl' | 'shift' | 'alt' | 'super';
+type ModifiedKeyId<Key extends string, RemainingModifiers extends ModifierName = ModifierName> = {
+    [M in RemainingModifiers]: `${M}+${Key}` | `${M}+${ModifiedKeyId<Key, Exclude<RemainingModifiers, M>>}`;
+}[RemainingModifiers];
+type KeyId = BaseKey | ModifiedKeyId<BaseKey>;
 declare const Key: {
     readonly escape: "escape";
     readonly esc: "esc";
@@ -708,36 +777,216 @@ declare const Key: {
     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 super: <K extends BaseKey>(key: K) => `super+${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 ctrlSuper: <K extends BaseKey>(key: K) => `ctrl+super+${K}`;
+    readonly superCtrl: <K extends BaseKey>(key: K) => `super+ctrl+${K}`;
+    readonly shiftSuper: <K extends BaseKey>(key: K) => `shift+super+${K}`;
+    readonly superShift: <K extends BaseKey>(key: K) => `super+shift+${K}`;
+    readonly altSuper: <K extends BaseKey>(key: K) => `alt+super+${K}`;
+    readonly superAlt: <K extends BaseKey>(key: K) => `super+alt+${K}`;
     readonly ctrlShiftAlt: <K extends BaseKey>(key: K) => `ctrl+shift+alt+${K}`;
+    readonly ctrlShiftSuper: <K extends BaseKey>(key: K) => `ctrl+shift+super+${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;
+declare function decodeKittyPrintable(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[];
+interface Keybindings {
+    'tui.editor.cursorUp': true;
+    'tui.editor.cursorDown': true;
+    'tui.editor.cursorLeft': true;
+    'tui.editor.cursorRight': true;
+    'tui.editor.cursorWordLeft': true;
+    'tui.editor.cursorWordRight': true;
+    'tui.editor.cursorLineStart': true;
+    'tui.editor.cursorLineEnd': true;
+    'tui.editor.jumpForward': true;
+    'tui.editor.jumpBackward': true;
+    'tui.editor.pageUp': true;
+    'tui.editor.pageDown': true;
+    'tui.editor.deleteCharBackward': true;
+    'tui.editor.deleteCharForward': true;
+    'tui.editor.deleteWordBackward': true;
+    'tui.editor.deleteWordForward': true;
+    'tui.editor.deleteToLineStart': true;
+    'tui.editor.deleteToLineEnd': true;
+    'tui.editor.yank': true;
+    'tui.editor.yankPop': true;
+    'tui.editor.undo': true;
+    'tui.input.newLine': true;
+    'tui.input.submit': true;
+    'tui.input.tab': true;
+    'tui.input.copy': true;
+    'tui.select.up': true;
+    'tui.select.down': true;
+    'tui.select.pageUp': true;
+    'tui.select.pageDown': true;
+    'tui.select.confirm': true;
+    'tui.select.cancel': true;
+}
+type Keybinding = keyof Keybindings;
+interface KeybindingDefinition {
+    defaultKeys: KeyId | KeyId[];
+    description?: string;
+}
+type KeybindingDefinitions = Record<string, KeybindingDefinition>;
+type KeybindingsConfig = Record<string, KeyId | KeyId[] | undefined>;
+declare const TUI_KEYBINDINGS: {
+    readonly 'tui.editor.cursorUp': {
+        readonly defaultKeys: "up";
+        readonly description: "Move cursor up";
+    };
+    readonly 'tui.editor.cursorDown': {
+        readonly defaultKeys: "down";
+        readonly description: "Move cursor down";
+    };
+    readonly 'tui.editor.cursorLeft': {
+        readonly defaultKeys: ["left", "ctrl+b"];
+        readonly description: "Move cursor left";
+    };
+    readonly 'tui.editor.cursorRight': {
+        readonly defaultKeys: ["right", "ctrl+f"];
+        readonly description: "Move cursor right";
+    };
+    readonly 'tui.editor.cursorWordLeft': {
+        readonly defaultKeys: ["alt+left", "ctrl+left", "alt+b"];
+        readonly description: "Move cursor word left";
+    };
+    readonly 'tui.editor.cursorWordRight': {
+        readonly defaultKeys: ["alt+right", "ctrl+right", "alt+f"];
+        readonly description: "Move cursor word right";
+    };
+    readonly 'tui.editor.cursorLineStart': {
+        readonly defaultKeys: ["home", "ctrl+a"];
+        readonly description: "Move to line start";
+    };
+    readonly 'tui.editor.cursorLineEnd': {
+        readonly defaultKeys: ["end", "ctrl+e"];
+        readonly description: "Move to line end";
+    };
+    readonly 'tui.editor.jumpForward': {
+        readonly defaultKeys: "ctrl+]";
+        readonly description: "Jump forward to character";
+    };
+    readonly 'tui.editor.jumpBackward': {
+        readonly defaultKeys: "ctrl+alt+]";
+        readonly description: "Jump backward to character";
+    };
+    readonly 'tui.editor.pageUp': {
+        readonly defaultKeys: "pageUp";
+        readonly description: "Page up";
+    };
+    readonly 'tui.editor.pageDown': {
+        readonly defaultKeys: "pageDown";
+        readonly description: "Page down";
+    };
+    readonly 'tui.editor.deleteCharBackward': {
+        readonly defaultKeys: "backspace";
+        readonly description: "Delete character backward";
+    };
+    readonly 'tui.editor.deleteCharForward': {
+        readonly defaultKeys: ["delete", "ctrl+d"];
+        readonly description: "Delete character forward";
+    };
+    readonly 'tui.editor.deleteWordBackward': {
+        readonly defaultKeys: ["ctrl+w", "alt+backspace"];
+        readonly description: "Delete word backward";
+    };
+    readonly 'tui.editor.deleteWordForward': {
+        readonly defaultKeys: ["alt+d", "alt+delete"];
+        readonly description: "Delete word forward";
+    };
+    readonly 'tui.editor.deleteToLineStart': {
+        readonly defaultKeys: "ctrl+u";
+        readonly description: "Delete to line start";
+    };
+    readonly 'tui.editor.deleteToLineEnd': {
+        readonly defaultKeys: "ctrl+k";
+        readonly description: "Delete to line end";
+    };
+    readonly 'tui.editor.yank': {
+        readonly defaultKeys: "ctrl+y";
+        readonly description: "Yank";
+    };
+    readonly 'tui.editor.yankPop': {
+        readonly defaultKeys: "alt+y";
+        readonly description: "Yank pop";
+    };
+    readonly 'tui.editor.undo': {
+        readonly defaultKeys: "ctrl+-";
+        readonly description: "Undo";
+    };
+    readonly 'tui.input.newLine': {
+        readonly defaultKeys: "shift+enter";
+        readonly description: "Insert newline";
+    };
+    readonly 'tui.input.submit': {
+        readonly defaultKeys: "enter";
+        readonly description: "Submit input";
+    };
+    readonly 'tui.input.tab': {
+        readonly defaultKeys: "tab";
+        readonly description: "Tab / autocomplete";
+    };
+    readonly 'tui.input.copy': {
+        readonly defaultKeys: "ctrl+c";
+        readonly description: "Copy selection";
+    };
+    readonly 'tui.select.up': {
+        readonly defaultKeys: "up";
+        readonly description: "Move selection up";
+    };
+    readonly 'tui.select.down': {
+        readonly defaultKeys: "down";
+        readonly description: "Move selection down";
+    };
+    readonly 'tui.select.pageUp': {
+        readonly defaultKeys: "pageUp";
+        readonly description: "Selection page up";
+    };
+    readonly 'tui.select.pageDown': {
+        readonly defaultKeys: "pageDown";
+        readonly description: "Selection page down";
+    };
+    readonly 'tui.select.confirm': {
+        readonly defaultKeys: "enter";
+        readonly description: "Confirm selection";
+    };
+    readonly 'tui.select.cancel': {
+        readonly defaultKeys: ["escape", "ctrl+c"];
+        readonly description: "Cancel selection";
+    };
 };
-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;
+interface KeybindingConflict {
+    key: KeyId;
+    keybindings: string[];
+}
+declare class KeybindingsManager {
+    private definitions;
+    private userBindings;
+    private keysById;
+    private conflicts;
+    constructor(definitions: KeybindingDefinitions, userBindings?: KeybindingsConfig);
+    private rebuild;
+    matches(data: string, keybinding: Keybinding): boolean;
+    getKeys(keybinding: Keybinding): KeyId[];
+    getDefinition(keybinding: Keybinding): KeybindingDefinition | undefined;
+    getConflicts(): KeybindingConflict[];
+    setUserBindings(userBindings: KeybindingsConfig): void;
+    getUserBindings(): KeybindingsConfig;
+    getResolvedBindings(): KeybindingsConfig;
+}
+declare function setKeybindings(keybindings: KeybindingsManager): void;
+declare function getKeybindings(): KeybindingsManager;
 
 type StdinBufferOptions = {
     timeout?: number;
@@ -752,12 +1001,14 @@ declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
     private readonly timeoutMs;
     private pasteMode;
     private pasteBuffer;
+    private pendingKittyPrintableCodepoint;
     constructor(options?: StdinBufferOptions);
     process(data: string | Buffer): void;
+    private emitDataSequence;
     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 };
+export { type AutocompleteItem, type AutocompleteProvider, type AutocompleteSuggestions, Box, CURSOR_MARKER, CancellableLoader, type CellDimensions, CombinedAutocompleteProvider, type Component, Container, type DefaultTextStyle, Editor, type EditorComponent, 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, type Keybinding, type KeybindingConflict, type KeybindingDefinition, type KeybindingDefinitions, type Keybindings, type KeybindingsConfig, KeybindingsManager, Loader, type LoaderIndicatorOptions, Markdown, type MarkdownTheme, type OverlayAnchor, type OverlayHandle, type OverlayMargin, type OverlayOptions, ProcessTerminal, type SelectItem, SelectList, type SelectListLayoutOptions, type SelectListTheme, type SelectListTruncatePrimaryContext, type SettingItem, SettingsList, type SettingsListTheme, type SizeValue, type SlashCommand, Spacer, StdinBuffer, type StdinBufferEventMap, type StdinBufferOptions, TUI, TUI_KEYBINDINGS, type Terminal, type TerminalCapabilities, Text, TruncatedText, allocateImageId, calculateImageRows, decodeKittyPrintable, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, fuzzyFilter, fuzzyMatch, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getKeybindings, getPngDimensions, getWebpDimensions, hyperlink, imageFallback, isFocusable, isKeyRelease, isKeyRepeat, isKittyProtocolActive, matchesKey, parseKey, renderImage, resetCapabilitiesCache, setCapabilities, setCellDimensions, setKeybindings, setKittyProtocolActive, truncateToWidth, visibleWidth, wrapTextWithAnsi };