@fairyhunter13/opentui-core 0.1.114 → 0.1.115

package/renderables/Box.d.ts

@@ -0,0 +1,81 @@
+import { type RenderableOptions, Renderable } from "../Renderable.js";
+import type { OptimizedBuffer } from "../buffer.js";
+import { type BorderCharacters, type BorderSides, type BorderSidesConfig, type BorderStyle } from "../lib/index.js";
+import { type ColorInput, RGBA } from "../lib/RGBA.js";
+import type { RenderContext } from "../types.js";
+export interface BoxOptions<TRenderable extends Renderable = BoxRenderable> extends RenderableOptions<TRenderable> {
+    backgroundColor?: string | RGBA;
+    borderStyle?: BorderStyle;
+    border?: boolean | BorderSides[];
+    borderColor?: string | RGBA;
+    customBorderChars?: BorderCharacters;
+    shouldFill?: boolean;
+    title?: string;
+    titleAlignment?: "left" | "center" | "right";
+    bottomTitle?: string;
+    bottomTitleAlignment?: "left" | "center" | "right";
+    focusedBorderColor?: ColorInput;
+    focusable?: boolean;
+    gap?: number | `${number}%`;
+    rowGap?: number | `${number}%`;
+    columnGap?: number | `${number}%`;
+}
+export declare class BoxRenderable extends Renderable {
+    protected _backgroundColor: RGBA;
+    protected _border: boolean | BorderSides[];
+    protected _borderStyle: BorderStyle;
+    protected _borderColor: RGBA;
+    protected _focusedBorderColor: RGBA;
+    private _customBorderCharsObj;
+    protected _customBorderChars?: Uint32Array;
+    protected borderSides: BorderSidesConfig;
+    shouldFill: boolean;
+    protected _title?: string;
+    protected _titleAlignment: "left" | "center" | "right";
+    protected _bottomTitle?: string;
+    protected _bottomTitleAlignment: "left" | "center" | "right";
+    protected _defaultOptions: {
+        backgroundColor: string;
+        borderStyle: "single";
+        border: false;
+        borderColor: string;
+        shouldFill: true;
+        titleAlignment: "left";
+        bottomTitleAlignment: "left";
+        focusedBorderColor: string;
+    };
+    constructor(ctx: RenderContext, options: BoxOptions);
+    private initializeBorder;
+    get customBorderChars(): BorderCharacters | undefined;
+    set customBorderChars(value: BorderCharacters | undefined);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: RGBA | string | undefined);
+    get border(): boolean | BorderSides[];
+    set border(value: boolean | BorderSides[]);
+    get borderStyle(): BorderStyle;
+    set borderStyle(value: BorderStyle);
+    get borderColor(): RGBA;
+    set borderColor(value: RGBA | string);
+    get focusedBorderColor(): RGBA;
+    set focusedBorderColor(value: RGBA | string);
+    get title(): string | undefined;
+    set title(value: string | undefined);
+    get titleAlignment(): "left" | "center" | "right";
+    set titleAlignment(value: "left" | "center" | "right");
+    get bottomTitle(): string | undefined;
+    set bottomTitle(value: string | undefined);
+    get bottomTitleAlignment(): "left" | "center" | "right";
+    set bottomTitleAlignment(value: "left" | "center" | "right");
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected getScissorRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    private applyYogaBorders;
+    private applyYogaGap;
+    set gap(gap: number | `${number}%` | undefined);
+    set rowGap(rowGap: number | `${number}%` | undefined);
+    set columnGap(columnGap: number | `${number}%` | undefined);
+}

package/renderables/Code.d.ts

@@ -0,0 +1,78 @@
+import { type RenderContext } from "../types.js";
+import { SyntaxStyle } from "../syntax-style.js";
+import { TreeSitterClient } from "../lib/tree-sitter/index.js";
+import { TextBufferRenderable, type TextBufferOptions } from "./TextBufferRenderable.js";
+import type { OptimizedBuffer } from "../buffer.js";
+import type { SimpleHighlight } from "../lib/tree-sitter/types.js";
+import type { TextChunk } from "../text-buffer.js";
+export interface HighlightContext {
+    content: string;
+    filetype: string;
+    syntaxStyle: SyntaxStyle;
+}
+export type OnHighlightCallback = (highlights: SimpleHighlight[], context: HighlightContext) => SimpleHighlight[] | undefined | Promise<SimpleHighlight[] | undefined>;
+export interface ChunkRenderContext extends HighlightContext {
+    highlights: SimpleHighlight[];
+}
+export type OnChunksCallback = (chunks: TextChunk[], context: ChunkRenderContext) => TextChunk[] | undefined | Promise<TextChunk[] | undefined>;
+export interface CodeOptions extends TextBufferOptions {
+    content?: string;
+    filetype?: string;
+    syntaxStyle: SyntaxStyle;
+    treeSitterClient?: TreeSitterClient;
+    conceal?: boolean;
+    drawUnstyledText?: boolean;
+    streaming?: boolean;
+    onHighlight?: OnHighlightCallback;
+    onChunks?: OnChunksCallback;
+}
+export declare class CodeRenderable extends TextBufferRenderable {
+    private _content;
+    private _filetype?;
+    private _syntaxStyle;
+    private _isHighlighting;
+    private _treeSitterClient;
+    private _highlightsDirty;
+    private _highlightSnapshotId;
+    private _conceal;
+    private _drawUnstyledText;
+    private _shouldRenderTextBuffer;
+    private _streaming;
+    private _hadInitialContent;
+    private _lastHighlights;
+    private _onHighlight?;
+    private _onChunks?;
+    private _highlightingPromise;
+    protected _contentDefaultOptions: {
+        content: string;
+        conceal: true;
+        drawUnstyledText: true;
+        streaming: false;
+    };
+    constructor(ctx: RenderContext, options: CodeOptions);
+    get content(): string;
+    set content(value: string);
+    get filetype(): string | undefined;
+    set filetype(value: string | undefined);
+    get syntaxStyle(): SyntaxStyle;
+    set syntaxStyle(value: SyntaxStyle);
+    get conceal(): boolean;
+    set conceal(value: boolean);
+    get drawUnstyledText(): boolean;
+    set drawUnstyledText(value: boolean);
+    get streaming(): boolean;
+    set streaming(value: boolean);
+    get treeSitterClient(): TreeSitterClient;
+    set treeSitterClient(value: TreeSitterClient);
+    get onHighlight(): OnHighlightCallback | undefined;
+    set onHighlight(value: OnHighlightCallback | undefined);
+    get onChunks(): OnChunksCallback | undefined;
+    set onChunks(value: OnChunksCallback | undefined);
+    get isHighlighting(): boolean;
+    get highlightingDone(): Promise<void>;
+    protected transformChunks(chunks: TextChunk[], context: ChunkRenderContext): Promise<TextChunk[]>;
+    private ensureVisibleTextBeforeHighlight;
+    private startHighlight;
+    getLineHighlights(lineIdx: number): import("../types.js").Highlight[];
+    protected renderSelf(buffer: OptimizedBuffer): void;
+}

package/renderables/Diff.d.ts

@@ -0,0 +1,142 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+import { type LineColorConfig } from "./LineNumberRenderable.js";
+import { RGBA } from "../lib/RGBA.js";
+import { SyntaxStyle } from "../syntax-style.js";
+import type { TreeSitterClient } from "../lib/tree-sitter/index.js";
+import type { MouseEvent } from "../renderer.js";
+export interface DiffRenderableOptions extends RenderableOptions<DiffRenderable> {
+    diff?: string;
+    syncScroll?: boolean;
+    view?: "unified" | "split";
+    fg?: string | RGBA;
+    filetype?: string;
+    syntaxStyle?: SyntaxStyle;
+    wrapMode?: "word" | "char" | "none";
+    conceal?: boolean;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    treeSitterClient?: TreeSitterClient;
+    showLineNumbers?: boolean;
+    lineNumberFg?: string | RGBA;
+    lineNumberBg?: string | RGBA;
+    addedBg?: string | RGBA;
+    removedBg?: string | RGBA;
+    contextBg?: string | RGBA;
+    addedContentBg?: string | RGBA;
+    removedContentBg?: string | RGBA;
+    contextContentBg?: string | RGBA;
+    addedSignColor?: string | RGBA;
+    removedSignColor?: string | RGBA;
+    addedLineNumberBg?: string | RGBA;
+    removedLineNumberBg?: string | RGBA;
+}
+export declare class DiffRenderable extends Renderable {
+    private _diff;
+    private _syncScroll;
+    private _view;
+    private _parsedDiff;
+    private _parseError;
+    private _fg?;
+    private _filetype?;
+    private _syntaxStyle?;
+    private _wrapMode?;
+    private _conceal;
+    private _selectionBg?;
+    private _selectionFg?;
+    private _treeSitterClient?;
+    private _showLineNumbers;
+    private _lineNumberFg;
+    private _lineNumberBg;
+    private _addedBg;
+    private _removedBg;
+    private _contextBg;
+    private _addedContentBg;
+    private _removedContentBg;
+    private _contextContentBg;
+    private _addedSignColor;
+    private _removedSignColor;
+    private _addedLineNumberBg;
+    private _removedLineNumberBg;
+    private leftSide;
+    private rightSide;
+    private leftSideAdded;
+    private rightSideAdded;
+    private leftCodeRenderable;
+    private rightCodeRenderable;
+    private pendingRebuild;
+    private _lastWidth;
+    private errorTextRenderable;
+    private errorCodeRenderable;
+    private _waitingForHighlight;
+    private _lineInfoChangeHandler;
+    constructor(ctx: RenderContext, options: DiffRenderableOptions);
+    private parseDiff;
+    private buildView;
+    protected onMouseEvent(event: MouseEvent): void;
+    private isInsideSide;
+    protected onResize(width: number, height: number): void;
+    private requestRebuild;
+    private rebuildView;
+    private handleLineInfoChange;
+    private attachLineInfoListeners;
+    private detachLineInfoListeners;
+    destroyRecursively(): void;
+    private buildErrorView;
+    private createOrUpdateCodeRenderable;
+    private createOrUpdateSide;
+    private buildUnifiedView;
+    private buildSplitView;
+    get diff(): string;
+    set diff(value: string);
+    get syncScroll(): boolean;
+    set syncScroll(value: boolean);
+    get view(): "unified" | "split";
+    set view(value: "unified" | "split");
+    get filetype(): string | undefined;
+    set filetype(value: string | undefined);
+    get syntaxStyle(): SyntaxStyle | undefined;
+    set syntaxStyle(value: SyntaxStyle | undefined);
+    get wrapMode(): "word" | "char" | "none" | undefined;
+    set wrapMode(value: "word" | "char" | "none" | undefined);
+    get showLineNumbers(): boolean;
+    set showLineNumbers(value: boolean);
+    get addedBg(): RGBA;
+    set addedBg(value: string | RGBA);
+    get removedBg(): RGBA;
+    set removedBg(value: string | RGBA);
+    get contextBg(): RGBA;
+    set contextBg(value: string | RGBA);
+    get addedSignColor(): RGBA;
+    set addedSignColor(value: string | RGBA);
+    get removedSignColor(): RGBA;
+    set removedSignColor(value: string | RGBA);
+    get addedLineNumberBg(): RGBA;
+    set addedLineNumberBg(value: string | RGBA);
+    get removedLineNumberBg(): RGBA;
+    set removedLineNumberBg(value: string | RGBA);
+    get lineNumberFg(): RGBA;
+    set lineNumberFg(value: string | RGBA);
+    get lineNumberBg(): RGBA;
+    set lineNumberBg(value: string | RGBA);
+    get addedContentBg(): RGBA | null;
+    set addedContentBg(value: string | RGBA | null);
+    get removedContentBg(): RGBA | null;
+    set removedContentBg(value: string | RGBA | null);
+    get contextContentBg(): RGBA | null;
+    set contextContentBg(value: string | RGBA | null);
+    get selectionBg(): RGBA | undefined;
+    set selectionBg(value: string | RGBA | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: string | RGBA | undefined);
+    get conceal(): boolean;
+    set conceal(value: boolean);
+    get fg(): RGBA | undefined;
+    set fg(value: string | RGBA | undefined);
+    setLineColor(line: number, color: string | RGBA | LineColorConfig): void;
+    clearLineColor(line: number): void;
+    setLineColors(lineColors: Map<number, string | RGBA | LineColorConfig>): void;
+    clearAllLineColors(): void;
+    highlightLines(startLine: number, endLine: number, color: string | RGBA | LineColorConfig): void;
+    clearHighlightLines(startLine: number, endLine: number): void;
+}

package/renderables/EditBufferRenderable.d.ts

@@ -0,0 +1,237 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import { Selection, type LocalSelectionBounds } from "../lib/selection.js";
+import { EditBuffer, type LogicalCursor } from "../edit-buffer.js";
+import { EditorView, type VisualCursor } from "../editor-view.js";
+import { RGBA } from "../lib/RGBA.js";
+import type { RenderContext, Highlight, CursorStyleOptions, LineInfoProvider, LineInfo } from "../types.js";
+import type { OptimizedBuffer } from "../buffer.js";
+import type { SyntaxStyle } from "../syntax-style.js";
+declare const BrandedEditBufferRenderable: unique symbol;
+export type EditorCapture = "escape" | "navigate" | "submit" | "tab";
+export interface EditorTraits {
+    capture?: readonly EditorCapture[];
+    suspend?: boolean;
+    status?: string;
+}
+export declare enum EditBufferRenderableEvents {
+    TRAITS_CHANGED = "traits-changed"
+}
+export declare function isEditBufferRenderable(obj: unknown): obj is EditBufferRenderable;
+export interface CursorChangeEvent {
+    line: number;
+    visualColumn: number;
+}
+export interface ContentChangeEvent {
+}
+export interface EditBufferOptions extends RenderableOptions<EditBufferRenderable> {
+    textColor?: string | RGBA;
+    backgroundColor?: string | RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+    attributes?: number;
+    wrapMode?: "none" | "char" | "word";
+    scrollMargin?: number;
+    scrollSpeed?: number;
+    showCursor?: boolean;
+    cursorColor?: string | RGBA;
+    cursorStyle?: CursorStyleOptions;
+    syntaxStyle?: SyntaxStyle;
+    tabIndicator?: string | number;
+    tabIndicatorColor?: string | RGBA;
+    onCursorChange?: (event: CursorChangeEvent) => void;
+    onContentChange?: (event: ContentChangeEvent) => void;
+}
+export declare abstract class EditBufferRenderable extends Renderable implements LineInfoProvider {
+    [BrandedEditBufferRenderable]: boolean;
+    protected _focusable: boolean;
+    selectable: boolean;
+    private _traits;
+    protected _textColor: RGBA;
+    protected _backgroundColor: RGBA;
+    protected _defaultAttributes: number;
+    protected _selectionBg: RGBA | undefined;
+    protected _selectionFg: RGBA | undefined;
+    protected _wrapMode: "none" | "char" | "word";
+    protected _scrollMargin: number;
+    protected _showCursor: boolean;
+    protected _cursorColor: RGBA;
+    protected _cursorStyle: CursorStyleOptions;
+    protected lastLocalSelection: LocalSelectionBounds | null;
+    protected _tabIndicator?: string | number;
+    protected _tabIndicatorColor?: RGBA;
+    private _cursorChangeListener;
+    private _contentChangeListener;
+    private _autoScrollVelocity;
+    private _autoScrollAccumulator;
+    private _scrollSpeed;
+    private _keyboardSelectionActive;
+    readonly editBuffer: EditBuffer;
+    readonly editorView: EditorView;
+    protected _defaultOptions: {
+        textColor: RGBA;
+        backgroundColor: string;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+        wrapMode: "none" | "char" | "word";
+        scrollMargin: number;
+        scrollSpeed: number;
+        showCursor: true;
+        cursorColor: RGBA;
+        cursorStyle: {
+            style: "block";
+            blinking: true;
+        };
+        tabIndicator: undefined;
+        tabIndicatorColor: undefined;
+    };
+    constructor(ctx: RenderContext, options: EditBufferOptions);
+    get lineInfo(): LineInfo;
+    private setupEventListeners;
+    get lineCount(): number;
+    get virtualLineCount(): number;
+    get scrollY(): number;
+    get plainText(): string;
+    get logicalCursor(): LogicalCursor;
+    get visualCursor(): VisualCursor;
+    get cursorOffset(): number;
+    set cursorOffset(offset: number);
+    get cursorCharacterOffset(): number | undefined;
+    get textColor(): RGBA;
+    set textColor(value: RGBA | string | undefined);
+    get selectionBg(): RGBA | undefined;
+    get traits(): EditorTraits;
+    set traits(value: EditorTraits);
+    set selectionBg(value: RGBA | string | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: RGBA | string | undefined);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: RGBA | string | undefined);
+    get attributes(): number;
+    set attributes(value: number);
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
+    get showCursor(): boolean;
+    set showCursor(value: boolean);
+    get cursorColor(): RGBA;
+    set cursorColor(value: RGBA | string);
+    get cursorStyle(): CursorStyleOptions;
+    set cursorStyle(style: CursorStyleOptions);
+    get tabIndicator(): string | number | undefined;
+    set tabIndicator(value: string | number | undefined);
+    get tabIndicatorColor(): RGBA | undefined;
+    set tabIndicatorColor(value: RGBA | string | undefined);
+    get scrollSpeed(): number;
+    set scrollSpeed(value: number);
+    protected onMouseEvent(event: any): void;
+    protected handleScroll(event: any): void;
+    protected onResize(width: number, height: number): void;
+    protected refreshLocalSelection(): boolean;
+    private updateLocalSelection;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    protected onUpdate(deltaTime: number): void;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    private refreshSelectionStyle;
+    private deleteSelectedText;
+    setSelection(start: number, end: number): void;
+    setSelectionInclusive(start: number, end: number): void;
+    clearSelection(): boolean;
+    deleteSelection(): boolean;
+    setCursor(row: number, col: number): void;
+    insertChar(char: string): void;
+    insertText(text: string): void;
+    deleteChar(): boolean;
+    deleteCharBackward(): boolean;
+    newLine(): boolean;
+    deleteLine(): boolean;
+    moveCursorLeft(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorRight(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorUp(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorDown(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoLine(line: number): void;
+    gotoLineStart(): void;
+    gotoLineTextEnd(): void;
+    gotoLineHome(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoLineEnd(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoVisualLineHome(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoVisualLineEnd(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoBufferHome(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoBufferEnd(options?: {
+        select?: boolean;
+    }): boolean;
+    selectAll(): boolean;
+    deleteToLineEnd(): boolean;
+    deleteToLineStart(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    moveWordForward(options?: {
+        select?: boolean;
+    }): boolean;
+    moveWordBackward(options?: {
+        select?: boolean;
+    }): boolean;
+    deleteWordForward(): boolean;
+    deleteWordBackward(): boolean;
+    private setupMeasureFunc;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected renderCursor(buffer: OptimizedBuffer): void;
+    focus(): void;
+    blur(): void;
+    protected onRemove(): void;
+    destroy(): void;
+    set onCursorChange(handler: ((event: CursorChangeEvent) => void) | undefined);
+    get onCursorChange(): ((event: CursorChangeEvent) => void) | undefined;
+    set onContentChange(handler: ((event: ContentChangeEvent) => void) | undefined);
+    get onContentChange(): ((event: ContentChangeEvent) => void) | undefined;
+    get syntaxStyle(): SyntaxStyle | null;
+    set syntaxStyle(style: SyntaxStyle | null);
+    addHighlight(lineIdx: number, highlight: Highlight): void;
+    addHighlightByCharRange(highlight: Highlight): void;
+    removeHighlightsByRef(hlRef: number): void;
+    clearLineHighlights(lineIdx: number): void;
+    clearAllHighlights(): void;
+    getLineHighlights(lineIdx: number): Array<Highlight>;
+    /**
+     * Set text and completely reset the buffer state (clears history, resets add_buffer).
+     * Use this for initial text setting or when you want a clean slate.
+     */
+    setText(text: string): void;
+    /**
+     * Replace text while preserving undo history (creates an undo point).
+     * Use this when you want the setText operation to be undoable.
+     */
+    replaceText(text: string): void;
+    clear(): void;
+    deleteRange(startLine: number, startCol: number, endLine: number, endCol: number): void;
+    getTextRange(startOffset: number, endOffset: number): string;
+    getTextRangeByCoords(startRow: number, startCol: number, endRow: number, endCol: number): string;
+    protected updateSelectionForMovement(shiftPressed: boolean, isBeforeMovement: boolean): void;
+}
+export {};

package/renderables/FrameBuffer.d.ts

@@ -0,0 +1,16 @@
+import { type RenderableOptions, Renderable } from "../Renderable.js";
+import { OptimizedBuffer } from "../buffer.js";
+import type { RenderContext } from "../types.js";
+export interface FrameBufferOptions extends RenderableOptions<FrameBufferRenderable> {
+    width: number;
+    height: number;
+    respectAlpha?: boolean;
+}
+export declare class FrameBufferRenderable extends Renderable {
+    frameBuffer: OptimizedBuffer;
+    protected respectAlpha: boolean;
+    constructor(ctx: RenderContext, options: FrameBufferOptions);
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected destroySelf(): void;
+}

package/renderables/Input.d.ts

@@ -0,0 +1,67 @@
+import type { PasteEvent } from "../lib/KeyHandler.js";
+import type { RenderContext } from "../types.js";
+import { TextareaRenderable, type TextareaOptions, type TextareaAction, type KeyBinding as TextareaKeyBinding } from "./Textarea.js";
+export type InputAction = TextareaAction;
+export type InputKeyBinding = TextareaKeyBinding;
+export interface InputRenderableOptions extends Omit<TextareaOptions, "height" | "minHeight" | "maxHeight" | "initialValue"> {
+    /** Initial text value (newlines are stripped) */
+    value?: string;
+    /** Maximum number of characters allowed */
+    maxLength?: number;
+    /** Placeholder text (Input only supports string, not StyledText) */
+    placeholder?: string;
+}
+export declare enum InputRenderableEvents {
+    INPUT = "input",
+    CHANGE = "change",
+    ENTER = "enter"
+}
+/**
+ * InputRenderable - A single-line text input component.
+ *
+ * Extends TextareaRenderable with single-line constraints:
+ * - Height is always 1
+ * - No text wrapping
+ * - Newlines are stripped from input
+ * - Enter key submits instead of inserting newline
+ *
+ * Inherits all keybindings from TextareaRenderable.
+ */
+export declare class InputRenderable extends TextareaRenderable {
+    private _maxLength;
+    private _lastCommittedValue;
+    private static readonly defaultOptions;
+    constructor(ctx: RenderContext, options: InputRenderableOptions);
+    /**
+     * Prevent newlines in single-line input
+     */
+    newLine(): boolean;
+    /**
+     * Handle paste - strip newlines and enforce maxLength
+     */
+    handlePaste(event: PasteEvent): void;
+    /**
+     * Insert text - strip newlines and enforce maxLength
+     */
+    insertText(text: string): void;
+    get value(): string;
+    set value(value: string);
+    focus(): void;
+    blur(): void;
+    submit(): boolean;
+    deleteCharBackward(): boolean;
+    deleteChar(): boolean;
+    deleteLine(): boolean;
+    deleteWordBackward(): boolean;
+    deleteWordForward(): boolean;
+    deleteToLineStart(): boolean;
+    deleteToLineEnd(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    deleteCharacter(direction: "backward" | "forward"): void;
+    set maxLength(maxLength: number);
+    get maxLength(): number;
+    set placeholder(placeholder: string);
+    get placeholder(): string;
+    set initialValue(value: string);
+}