@fairyhunter13/opentui-core 0.1.91 → 0.1.92

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 opentui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NativeSpanFeed.d.ts

@@ -0,0 +1,41 @@
+import { type Pointer } from "bun:ffi";
+import type { NativeSpanFeedOptions } from "./zig-structs";
+export type { GrowthPolicy, NativeSpanFeedOptions, NativeSpanFeedStats } from "./zig-structs";
+export type DataHandler = (data: Uint8Array) => void | Promise<void>;
+/**
+ * Zero-copy wrapper over Zig memory; not a full stream interface.
+ */
+export declare class NativeSpanFeed {
+    static create(options?: NativeSpanFeedOptions): NativeSpanFeed;
+    static attach(streamPtr: bigint | number, _options?: NativeSpanFeedOptions): NativeSpanFeed;
+    readonly streamPtr: Pointer;
+    private readonly lib;
+    private readonly eventHandler;
+    private chunkMap;
+    private chunkSizes;
+    private dataHandlers;
+    private errorHandlers;
+    private drainBuffer;
+    private stateBuffer;
+    private closed;
+    private destroyed;
+    private draining;
+    private pendingDataAvailable;
+    private pendingClose;
+    private closing;
+    private pendingAsyncHandlers;
+    private inCallback;
+    private closeQueued;
+    private constructor();
+    private ensureDrainBuffer;
+    onData(handler: DataHandler): () => void;
+    onError(handler: (code: number) => void): () => void;
+    close(): void;
+    private processPendingClose;
+    private performClose;
+    private finalizeDestroy;
+    private handleEvent;
+    private decrementRefcount;
+    private drainOnce;
+    drainAll(): void;
+}

package/Renderable.d.ts

@@ -0,0 +1,334 @@
+import { EventEmitter } from "events";
+import { type Node as YogaNode } from "yoga-layout";
+import { OptimizedBuffer } from "./buffer.js";
+import type { KeyEvent, PasteEvent } from "./lib/KeyHandler.js";
+import type { Selection } from "./lib/selection.js";
+import { type AlignString, type FlexDirectionString, type JustifyString, type OverflowString, type PositionTypeString, type WrapString } from "./lib/yoga.options.js";
+import { type VNode } from "./renderables/composition/vnode.js";
+import type { MouseEvent } from "./renderer.js";
+import type { RenderContext } from "./types.js";
+declare const BrandedRenderable: unique symbol;
+export declare enum LayoutEvents {
+    LAYOUT_CHANGED = "layout-changed",
+    ADDED = "added",
+    REMOVED = "removed",
+    RESIZED = "resized"
+}
+export declare enum RenderableEvents {
+    FOCUSED = "focused",
+    BLURRED = "blurred"
+}
+export interface Position {
+    top?: number | "auto" | `${number}%`;
+    right?: number | "auto" | `${number}%`;
+    bottom?: number | "auto" | `${number}%`;
+    left?: number | "auto" | `${number}%`;
+}
+export interface BaseRenderableOptions {
+    id?: string;
+}
+export interface LayoutOptions extends BaseRenderableOptions {
+    flexGrow?: number;
+    flexShrink?: number;
+    flexDirection?: FlexDirectionString;
+    flexWrap?: WrapString;
+    alignItems?: AlignString;
+    justifyContent?: JustifyString;
+    alignSelf?: AlignString;
+    flexBasis?: number | "auto" | undefined;
+    position?: PositionTypeString;
+    overflow?: OverflowString;
+    top?: number | "auto" | `${number}%`;
+    right?: number | "auto" | `${number}%`;
+    bottom?: number | "auto" | `${number}%`;
+    left?: number | "auto" | `${number}%`;
+    minWidth?: number | "auto" | `${number}%`;
+    minHeight?: number | "auto" | `${number}%`;
+    maxWidth?: number | "auto" | `${number}%`;
+    maxHeight?: number | "auto" | `${number}%`;
+    margin?: number | "auto" | `${number}%`;
+    marginX?: number | "auto" | `${number}%`;
+    marginY?: number | "auto" | `${number}%`;
+    marginTop?: number | "auto" | `${number}%`;
+    marginRight?: number | "auto" | `${number}%`;
+    marginBottom?: number | "auto" | `${number}%`;
+    marginLeft?: number | "auto" | `${number}%`;
+    padding?: number | `${number}%`;
+    paddingX?: number | `${number}%`;
+    paddingY?: number | `${number}%`;
+    paddingTop?: number | `${number}%`;
+    paddingRight?: number | `${number}%`;
+    paddingBottom?: number | `${number}%`;
+    paddingLeft?: number | `${number}%`;
+    enableLayout?: boolean;
+}
+export interface RenderableOptions<T extends BaseRenderable = BaseRenderable> extends Partial<LayoutOptions> {
+    width?: number | "auto" | `${number}%`;
+    height?: number | "auto" | `${number}%`;
+    zIndex?: number;
+    visible?: boolean;
+    buffered?: boolean;
+    live?: boolean;
+    opacity?: number;
+    renderBefore?: (this: T, buffer: OptimizedBuffer, deltaTime: number) => void;
+    renderAfter?: (this: T, buffer: OptimizedBuffer, deltaTime: number) => void;
+    onMouse?: (this: T, event: MouseEvent) => void;
+    onMouseDown?: (this: T, event: MouseEvent) => void;
+    onMouseUp?: (this: T, event: MouseEvent) => void;
+    onMouseMove?: (this: T, event: MouseEvent) => void;
+    onMouseDrag?: (this: T, event: MouseEvent) => void;
+    onMouseDragEnd?: (this: T, event: MouseEvent) => void;
+    onMouseDrop?: (this: T, event: MouseEvent) => void;
+    onMouseOver?: (this: T, event: MouseEvent) => void;
+    onMouseOut?: (this: T, event: MouseEvent) => void;
+    onMouseScroll?: (this: T, event: MouseEvent) => void;
+    onPaste?: (this: T, event: PasteEvent) => void;
+    onKeyDown?: (key: KeyEvent) => void;
+    onSizeChange?: (this: T) => void;
+}
+export declare function isRenderable(obj: any): obj is Renderable;
+export declare abstract class BaseRenderable extends EventEmitter {
+    [BrandedRenderable]: boolean;
+    private static renderableNumber;
+    protected _id: string;
+    readonly num: number;
+    protected _dirty: boolean;
+    parent: BaseRenderable | null;
+    protected _visible: boolean;
+    constructor(options: BaseRenderableOptions);
+    abstract add(obj: BaseRenderable | unknown, index?: number): number;
+    abstract remove(id: string): void;
+    abstract insertBefore(obj: BaseRenderable | unknown, anchor: BaseRenderable | unknown): void;
+    abstract getChildren(): BaseRenderable[];
+    abstract getChildrenCount(): number;
+    abstract getRenderable(id: string): BaseRenderable | undefined;
+    abstract requestRender(): void;
+    abstract findDescendantById(id: string): BaseRenderable | undefined;
+    get id(): string;
+    set id(value: string);
+    get isDirty(): boolean;
+    protected markClean(): void;
+    protected markDirty(): void;
+    destroy(): void;
+    destroyRecursively(): void;
+    get visible(): boolean;
+    set visible(value: boolean);
+}
+export declare abstract class Renderable extends BaseRenderable {
+    static renderablesByNumber: Map<number, Renderable>;
+    protected _isDestroyed: boolean;
+    protected _ctx: RenderContext;
+    protected _translateX: number;
+    protected _translateY: number;
+    protected _x: number;
+    protected _y: number;
+    protected _width: number | "auto" | `${number}%`;
+    protected _height: number | "auto" | `${number}%`;
+    protected _widthValue: number;
+    protected _heightValue: number;
+    private _zIndex;
+    selectable: boolean;
+    protected buffered: boolean;
+    protected frameBuffer: OptimizedBuffer | null;
+    protected _focusable: boolean;
+    protected _focused: boolean;
+    protected keypressHandler: ((key: KeyEvent) => void) | null;
+    protected pasteHandler: ((event: PasteEvent) => void) | null;
+    private _live;
+    protected _liveCount: number;
+    private _sizeChangeListener;
+    private _mouseListener;
+    private _mouseListeners;
+    private _pasteListener;
+    private _keyListeners;
+    protected yogaNode: YogaNode;
+    protected _positionType: PositionTypeString;
+    protected _overflow: OverflowString;
+    protected _position: Position;
+    protected _opacity: number;
+    private _flexShrink;
+    private renderableMapById;
+    protected _childrenInLayoutOrder: Renderable[];
+    protected _childrenInZIndexOrder: Renderable[];
+    private needsZIndexSort;
+    parent: Renderable | null;
+    private childrenPrimarySortDirty;
+    private childrenSortedByPrimaryAxis;
+    private _shouldUpdateBefore;
+    onLifecyclePass: (() => void) | null;
+    renderBefore?: (this: Renderable, buffer: OptimizedBuffer, deltaTime: number) => void;
+    renderAfter?: (this: Renderable, buffer: OptimizedBuffer, deltaTime: number) => void;
+    constructor(ctx: RenderContext, options: RenderableOptions<any>);
+    get id(): string;
+    set id(value: string);
+    get focusable(): boolean;
+    set focusable(value: boolean);
+    get ctx(): RenderContext;
+    get visible(): boolean;
+    get primaryAxis(): "row" | "column";
+    set visible(value: boolean);
+    get opacity(): number;
+    set opacity(value: number);
+    hasSelection(): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    getSelectedText(): string;
+    shouldStartSelection(x: number, y: number): boolean;
+    focus(): void;
+    blur(): void;
+    get focused(): boolean;
+    get live(): boolean;
+    get liveCount(): number;
+    set live(value: boolean);
+    protected propagateLiveCount(delta: number): void;
+    handleKeyPress?(key: KeyEvent): boolean;
+    handlePaste?(event: PasteEvent): void;
+    findDescendantById(id: string): Renderable | undefined;
+    requestRender(): void;
+    get translateX(): number;
+    set translateX(value: number);
+    get translateY(): number;
+    set translateY(value: number);
+    get x(): number;
+    set x(value: number);
+    get top(): number | "auto" | `${number}%` | undefined;
+    set top(value: number | "auto" | `${number}%` | undefined);
+    get right(): number | "auto" | `${number}%` | undefined;
+    set right(value: number | "auto" | `${number}%` | undefined);
+    get bottom(): number | "auto" | `${number}%` | undefined;
+    set bottom(value: number | "auto" | `${number}%` | undefined);
+    get left(): number | "auto" | `${number}%` | undefined;
+    set left(value: number | "auto" | `${number}%` | undefined);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number | "auto" | `${number}%`);
+    get height(): number;
+    set height(value: number | "auto" | `${number}%`);
+    get zIndex(): number;
+    set zIndex(value: number);
+    private requestZIndexSort;
+    private ensureZIndexSorted;
+    getChildrenSortedByPrimaryAxis(): Renderable[];
+    private setupYogaProperties;
+    private setupMarginAndPadding;
+    set position(positionType: PositionTypeString | null | undefined);
+    get overflow(): OverflowString;
+    set overflow(overflow: OverflowString | null | undefined);
+    setPosition(position: Position): void;
+    private updateYogaPosition;
+    set flexGrow(grow: number | null | undefined);
+    set flexShrink(shrink: number | null | undefined);
+    set flexDirection(direction: FlexDirectionString | null | undefined);
+    set flexWrap(wrap: WrapString | null | undefined);
+    set alignItems(alignItems: AlignString | null | undefined);
+    set justifyContent(justifyContent: JustifyString | null | undefined);
+    set alignSelf(alignSelf: AlignString | null | undefined);
+    set flexBasis(basis: number | "auto" | null | undefined);
+    set minWidth(minWidth: number | `${number}%` | null | undefined);
+    set maxWidth(maxWidth: number | `${number}%` | null | undefined);
+    set minHeight(minHeight: number | `${number}%` | null | undefined);
+    set maxHeight(maxHeight: number | `${number}%` | null | undefined);
+    set margin(margin: number | "auto" | `${number}%` | null | undefined);
+    set marginX(marginX: number | "auto" | `${number}%` | null | undefined);
+    set marginY(marginY: number | "auto" | `${number}%` | null | undefined);
+    set marginTop(margin: number | "auto" | `${number}%` | null | undefined);
+    set marginRight(margin: number | "auto" | `${number}%` | null | undefined);
+    set marginBottom(margin: number | "auto" | `${number}%` | null | undefined);
+    set marginLeft(margin: number | "auto" | `${number}%` | null | undefined);
+    set padding(padding: number | `${number}%` | null | undefined);
+    set paddingX(paddingX: number | `${number}%` | null | undefined);
+    set paddingY(paddingY: number | `${number}%` | null | undefined);
+    set paddingTop(padding: number | `${number}%` | null | undefined);
+    set paddingRight(padding: number | `${number}%` | null | undefined);
+    set paddingBottom(padding: number | `${number}%` | null | undefined);
+    set paddingLeft(padding: number | `${number}%` | null | undefined);
+    getLayoutNode(): YogaNode;
+    updateFromLayout(): void;
+    protected onLayoutResize(width: number, height: number): void;
+    protected handleFrameBufferResize(width: number, height: number): void;
+    protected createFrameBuffer(): void;
+    /**
+     * This will be called during a render pass.
+     * Requesting a render during a render pass will drop the requested render.
+     * If you need to request a render during a render pass, use process.nextTick.
+     */
+    protected onResize(width: number, height: number): void;
+    private replaceParent;
+    add(obj: Renderable | VNode<any, any[]> | unknown, index?: number): number;
+    insertBefore(obj: Renderable | VNode<any, any[]> | unknown, anchor?: Renderable | unknown): number;
+    getRenderable(id: string): Renderable | undefined;
+    remove(id: string): void;
+    protected onRemove(): void;
+    getChildren(): Renderable[];
+    getChildrenCount(): number;
+    updateLayout(deltaTime: number, renderList?: RenderCommand[]): void;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected _getVisibleChildren(): number[];
+    protected onUpdate(deltaTime: number): void;
+    protected getScissorRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    get isDestroyed(): boolean;
+    destroy(): void;
+    destroyRecursively(): void;
+    protected destroySelf(): void;
+    processMouseEvent(event: MouseEvent): void;
+    protected onMouseEvent(event: MouseEvent): void;
+    set onMouse(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseDown(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseUp(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseMove(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseDrag(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseDragEnd(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseDrop(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseOver(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseOut(handler: ((event: MouseEvent) => void) | undefined);
+    set onMouseScroll(handler: ((event: MouseEvent) => void) | undefined);
+    set onPaste(handler: ((event: PasteEvent) => void) | undefined);
+    get onPaste(): ((event: PasteEvent) => void) | undefined;
+    set onKeyDown(handler: ((key: KeyEvent) => void) | undefined);
+    get onKeyDown(): ((key: KeyEvent) => void) | undefined;
+    set onSizeChange(handler: (() => void) | undefined);
+    get onSizeChange(): (() => void) | undefined;
+    private applyEventOptions;
+}
+interface RenderCommandBase {
+    action: "render" | "pushScissorRect" | "popScissorRect" | "pushOpacity" | "popOpacity";
+}
+interface RenderCommandPushScissorRect extends RenderCommandBase {
+    action: "pushScissorRect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    screenX: number;
+    screenY: number;
+}
+interface RenderCommandPopScissorRect extends RenderCommandBase {
+    action: "popScissorRect";
+}
+interface RenderCommandRender extends RenderCommandBase {
+    action: "render";
+    renderable: Renderable;
+}
+interface RenderCommandPushOpacity extends RenderCommandBase {
+    action: "pushOpacity";
+    opacity: number;
+}
+interface RenderCommandPopOpacity extends RenderCommandBase {
+    action: "popOpacity";
+}
+export type RenderCommand = RenderCommandPushScissorRect | RenderCommandPopScissorRect | RenderCommandRender | RenderCommandPushOpacity | RenderCommandPopOpacity;
+export declare class RootRenderable extends Renderable {
+    private renderList;
+    constructor(ctx: RenderContext);
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected propagateLiveCount(delta: number): void;
+    calculateLayout(): void;
+    resize(width: number, height: number): void;
+}
+export {};

package/animation/Timeline.d.ts

@@ -0,0 +1,126 @@
+import type { CliRenderer } from "../renderer.js";
+export interface TimelineOptions {
+    duration?: number;
+    loop?: boolean;
+    autoplay?: boolean;
+    onComplete?: () => void;
+    onPause?: () => void;
+}
+export interface AnimationOptions {
+    duration: number;
+    ease?: EasingFunctions;
+    onUpdate?: (animation: JSAnimation) => void;
+    onComplete?: () => void;
+    onStart?: () => void;
+    onLoop?: () => void;
+    loop?: boolean | number;
+    loopDelay?: number;
+    alternate?: boolean;
+    once?: boolean;
+    [key: string]: any;
+}
+export interface JSAnimation {
+    targets: any[];
+    deltaTime: number;
+    progress: number;
+    currentTime: number;
+}
+interface TimelineItem {
+    type: "animation" | "callback" | "timeline";
+    startTime: number;
+}
+interface TimelineTimelineItem extends TimelineItem {
+    type: "timeline";
+    timeline: Timeline;
+    timelineStarted?: boolean;
+}
+interface TimelineCallbackItem extends TimelineItem {
+    type: "callback";
+    callback: () => void;
+    executed: boolean;
+}
+interface TimelineAnimationItem extends TimelineItem {
+    type: "animation";
+    target: any[];
+    properties?: Record<string, number>;
+    initialValues?: Record<string, number>[];
+    duration?: number;
+    ease?: keyof typeof easingFunctions;
+    loop?: boolean | number;
+    loopDelay?: number;
+    alternate?: boolean;
+    onUpdate?: (animation: JSAnimation) => void;
+    onComplete?: () => void;
+    onStart?: () => void;
+    onLoop?: () => void;
+    completed?: boolean;
+    started?: boolean;
+    currentLoop?: number;
+    once?: boolean;
+}
+export type EasingFunctions = keyof typeof easingFunctions;
+declare const easingFunctions: {
+    linear: (t: number) => number;
+    inQuad: (t: number) => number;
+    outQuad: (t: number) => number;
+    inOutQuad: (t: number) => number;
+    inExpo: (t: number) => number;
+    outExpo: (t: number) => number;
+    inOutSine: (t: number) => number;
+    outBounce: (t: number) => number;
+    outElastic: (t: number) => number;
+    inBounce: (t: number) => number;
+    inCirc: (t: number) => number;
+    outCirc: (t: number) => number;
+    inOutCirc: (t: number) => number;
+    inBack: (t: number, s?: number) => number;
+    outBack: (t: number, s?: number) => number;
+    inOutBack: (t: number, s?: number) => number;
+};
+export declare class Timeline {
+    items: (TimelineAnimationItem | TimelineCallbackItem)[];
+    subTimelines: TimelineTimelineItem[];
+    currentTime: number;
+    isPlaying: boolean;
+    isComplete: boolean;
+    duration: number;
+    loop: boolean;
+    synced: boolean;
+    private autoplay;
+    private onComplete?;
+    private onPause?;
+    private stateChangeListeners;
+    constructor(options?: TimelineOptions);
+    addStateChangeListener(listener: (timeline: Timeline) => void): void;
+    removeStateChangeListener(listener: (timeline: Timeline) => void): void;
+    private notifyStateChange;
+    add(target: any, properties: AnimationOptions, startTime?: number | string): this;
+    once(target: any, properties: AnimationOptions): this;
+    call(callback: () => void, startTime?: number | string): this;
+    sync(timeline: Timeline, startTime?: number): this;
+    play(): this;
+    pause(): this;
+    resetItems(): void;
+    restart(): this;
+    update(deltaTime: number): void;
+}
+declare class TimelineEngine {
+    private timelines;
+    private renderer;
+    private frameCallback;
+    private isLive;
+    defaults: {
+        frameRate: number;
+    };
+    attach(renderer: CliRenderer): void;
+    detach(): void;
+    private updateLiveState;
+    private onTimelineStateChange;
+    register(timeline: Timeline): void;
+    unregister(timeline: Timeline): void;
+    clear(): void;
+    update(deltaTime: number): void;
+}
+export declare const engine: TimelineEngine;
+export declare function createTimeline(options?: TimelineOptions): Timeline;
+export {};

package/ansi.d.ts

@@ -0,0 +1,13 @@
+export declare const ANSI: {
+    switchToAlternateScreen: string;
+    switchToMainScreen: string;
+    reset: string;
+    scrollDown: (lines: number) => string;
+    scrollUp: (lines: number) => string;
+    moveCursor: (row: number, col: number) => string;
+    moveCursorAndClear: (row: number, col: number) => string;
+    setRgbBackground: (r: number, g: number, b: number) => string;
+    resetBackground: string;
+    bracketedPasteStart: string;
+    bracketedPasteEnd: string;
+};

package/buffer.d.ts

@@ -0,0 +1,107 @@
+import { RGBA } from "./lib/index.js";
+import { type RenderLib } from "./zig.js";
+import { type Pointer } from "bun:ffi";
+import { type BorderStyle, type BorderSides } from "./lib/index.js";
+import { type WidthMethod, type CapturedLine } from "./types.js";
+import type { TextBufferView } from "./text-buffer-view.js";
+import type { EditorView } from "./editor-view.js";
+export declare class OptimizedBuffer {
+    private static fbIdCounter;
+    id: string;
+    lib: RenderLib;
+    private bufferPtr;
+    private _width;
+    private _height;
+    private _widthMethod;
+    respectAlpha: boolean;
+    private _rawBuffers;
+    private _destroyed;
+    get ptr(): Pointer;
+    private guard;
+    get buffers(): {
+        char: Uint32Array;
+        fg: Float32Array;
+        bg: Float32Array;
+        attributes: Uint32Array;
+    };
+    constructor(lib: RenderLib, ptr: Pointer, width: number, height: number, options: {
+        respectAlpha?: boolean;
+        id?: string;
+        widthMethod?: WidthMethod;
+    });
+    static create(width: number, height: number, widthMethod: WidthMethod, options?: {
+        respectAlpha?: boolean;
+        id?: string;
+    }): OptimizedBuffer;
+    get widthMethod(): WidthMethod;
+    get width(): number;
+    get height(): number;
+    setRespectAlpha(respectAlpha: boolean): void;
+    getNativeId(): string;
+    getRealCharBytes(addLineBreaks?: boolean): Uint8Array;
+    getSpanLines(): CapturedLine[];
+    clear(bg?: RGBA): void;
+    setCell(x: number, y: number, char: string, fg: RGBA, bg: RGBA, attributes?: number): void;
+    setCellWithAlphaBlending(x: number, y: number, char: string, fg: RGBA, bg: RGBA, attributes?: number): void;
+    drawText(text: string, x: number, y: number, fg: RGBA, bg?: RGBA, attributes?: number, selection?: {
+        start: number;
+        end: number;
+        bgColor?: RGBA;
+        fgColor?: RGBA;
+    } | null): void;
+    fillRect(x: number, y: number, width: number, height: number, bg: RGBA): void;
+    drawFrameBuffer(destX: number, destY: number, frameBuffer: OptimizedBuffer, sourceX?: number, sourceY?: number, sourceWidth?: number, sourceHeight?: number): void;
+    destroy(): void;
+    drawTextBuffer(textBufferView: TextBufferView, x: number, y: number): void;
+    drawEditorView(editorView: EditorView, x: number, y: number): void;
+    drawSuperSampleBuffer(x: number, y: number, pixelDataPtr: Pointer, pixelDataLength: number, format: "bgra8unorm" | "rgba8unorm", alignedBytesPerRow: number): void;
+    drawPackedBuffer(dataPtr: Pointer, dataLen: number, posX: number, posY: number, terminalWidthCells: number, terminalHeightCells: number): void;
+    drawGrayscaleBuffer(posX: number, posY: number, intensities: Float32Array, srcWidth: number, srcHeight: number, fg?: RGBA | null, bg?: RGBA | null): void;
+    drawGrayscaleBufferSupersampled(posX: number, posY: number, intensities: Float32Array, srcWidth: number, srcHeight: number, fg?: RGBA | null, bg?: RGBA | null): void;
+    resize(width: number, height: number): void;
+    drawBox(options: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        borderStyle?: BorderStyle;
+        customBorderChars?: Uint32Array;
+        border: boolean | BorderSides[];
+        borderColor: RGBA;
+        backgroundColor: RGBA;
+        shouldFill?: boolean;
+        title?: string;
+        titleAlignment?: "left" | "center" | "right";
+    }): void;
+    pushScissorRect(x: number, y: number, width: number, height: number): void;
+    popScissorRect(): void;
+    clearScissorRects(): void;
+    pushOpacity(opacity: number): void;
+    popOpacity(): void;
+    getCurrentOpacity(): number;
+    clearOpacity(): void;
+    encodeUnicode(text: string): {
+        ptr: Pointer;
+        data: Array<{
+            width: number;
+            char: number;
+        }>;
+    } | null;
+    freeUnicode(encoded: {
+        ptr: Pointer;
+        data: Array<{
+            width: number;
+            char: number;
+        }>;
+    }): void;
+    drawGrid(options: {
+        borderChars: Uint32Array;
+        borderFg: RGBA;
+        borderBg: RGBA;
+        columnOffsets: Int32Array;
+        rowOffsets: Int32Array;
+        drawInner: boolean;
+        drawOuter: boolean;
+    }): void;
+    drawChar(char: number, x: number, y: number, fg: RGBA, bg: RGBA, attributes?: number): void;
+}