@opentui/core 0.1.10 → 0.1.12

package/lib/ascii.font.d.ts

@@ -1,5 +1,6 @@
 import { OptimizedBuffer } from "../buffer";
 import { RGBA } from "./RGBA";
+export type ASCIIFontName = "tiny" | "block" | "shade" | "slick";
 export declare const fonts: {
     tiny: {
         name: string;

package/lib/word-jumps.d.ts

@@ -0,0 +1,2 @@
+export declare function nextWordEndCrossLines(text: string, caret: number): number;
+export declare function previousWordStartCrossLines(text: string, caret: number): number;

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -38,11 +38,11 @@
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.10",
-    "@opentui/core-darwin-arm64": "0.1.10",
-    "@opentui/core-linux-x64": "0.1.10",
-    "@opentui/core-linux-arm64": "0.1.10",
-    "@opentui/core-win32-x64": "0.1.10",
-    "@opentui/core-win32-arm64": "0.1.10"
+    "@opentui/core-darwin-x64": "0.1.12",
+    "@opentui/core-darwin-arm64": "0.1.12",
+    "@opentui/core-linux-x64": "0.1.12",
+    "@opentui/core-linux-arm64": "0.1.12",
+    "@opentui/core-win32-x64": "0.1.12",
+    "@opentui/core-win32-arm64": "0.1.12"
   }
 }

package/renderables/ASCIIFont.d.ts

@@ -1,11 +1,11 @@
 import type { RenderableOptions } from "../Renderable";
-import { type fonts } from "../lib/ascii.font";
+import { type fonts, type ASCIIFontName } from "../lib/ascii.font";
 import { RGBA } from "../lib/RGBA";
 import { FrameBufferRenderable } from "./FrameBuffer";
-import type { SelectionState } from "../types";
-export interface ASCIIFontOptions extends RenderableOptions {
+import type { RenderContext, SelectionState } from "../types";
+export interface ASCIIFontOptions extends RenderableOptions<ASCIIFontRenderable> {
     text?: string;
-    font?: "tiny" | "block" | "shade" | "slick";
+    font?: ASCIIFontName;
     fg?: RGBA | RGBA[];
     bg?: RGBA;
     selectionBg?: string | RGBA;
@@ -21,7 +21,7 @@ export declare class ASCIIFontRenderable extends FrameBufferRenderable {
     private _selectionBg;
     private _selectionFg;
     private selectionHelper;
-    constructor(id: string, options: ASCIIFontOptions);
+    constructor(ctx: RenderContext, options: ASCIIFontOptions);
     get text(): string;
     set text(value: string);
     get font(): keyof typeof fonts;

package/renderables/Box.d.ts

@@ -2,7 +2,8 @@ import { type RenderableOptions, Renderable } from "../Renderable";
 import type { OptimizedBuffer } from "../buffer";
 import { type BorderCharacters, type BorderSides, type BorderSidesConfig, type BorderStyle } from "../lib";
 import { type ColorInput, RGBA } from "../lib/RGBA";
-export interface BoxOptions extends RenderableOptions {
+import type { RenderContext } from "../types";
+export interface BoxOptions extends RenderableOptions<BoxRenderable> {
     backgroundColor?: string | RGBA;
     borderStyle?: BorderStyle;
     border?: boolean | BorderSides[];
@@ -12,6 +13,9 @@ export interface BoxOptions extends RenderableOptions {
     title?: string;
     titleAlignment?: "left" | "center" | "right";
     focusedBorderColor?: ColorInput;
+    gap?: number | `${number}%`;
+    rowGap?: number | `${number}%`;
+    columnGap?: number | `${number}%`;
 }
 export declare class BoxRenderable extends Renderable {
     protected _backgroundColor: RGBA;
@@ -34,7 +38,7 @@ export declare class BoxRenderable extends Renderable {
         titleAlignment: "left";
         focusedBorderColor: string;
     };
-    constructor(id: string, options: BoxOptions);
+    constructor(ctx: RenderContext, options: BoxOptions);
     get customBorderChars(): BorderCharacters | undefined;
     set customBorderChars(value: BorderCharacters | undefined);
     get backgroundColor(): RGBA;
@@ -53,4 +57,8 @@ export declare class BoxRenderable extends Renderable {
     set titleAlignment(value: "left" | "center" | "right");
     protected renderSelf(buffer: OptimizedBuffer): void;
     private applyYogaBorders;
+    private applyYogaGap;
+    set gap(gap: number | `${number}%` | undefined);
+    set rowGap(rowGap: number | `${number}%` | undefined);
+    set columnGap(columnGap: number | `${number}%` | undefined);
 }

package/renderables/FrameBuffer.d.ts

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

package/renderables/Group.d.ts

@@ -1,4 +1,5 @@
 import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
 export declare class GroupRenderable extends Renderable {
-    constructor(id: string, options: RenderableOptions);
+    constructor(ctx: RenderContext, options: RenderableOptions);
 }

package/renderables/Input.d.ts

@@ -2,7 +2,8 @@ import { OptimizedBuffer } from "../buffer";
 import type { ParsedKey } from "../lib/parse.keypress";
 import { type ColorInput } from "../lib/RGBA";
 import { Renderable, type RenderableOptions } from "../Renderable";
-export interface InputRenderableOptions extends RenderableOptions {
+import type { RenderContext } from "../types";
+export interface InputRenderableOptions extends RenderableOptions<InputRenderable> {
     backgroundColor?: ColorInput;
     textColor?: ColorInput;
     focusedBackgroundColor?: ColorInput;
@@ -42,7 +43,7 @@ export declare class InputRenderable extends Renderable {
         maxLength: number;
         value: string;
     };
-    constructor(id: string, options: InputRenderableOptions);
+    constructor(ctx: RenderContext, options: InputRenderableOptions);
     private updateCursorPosition;
     focus(): void;
     blur(): void;
@@ -64,5 +65,6 @@ export declare class InputRenderable extends Renderable {
     set cursorColor(value: ColorInput);
     updateFromLayout(): void;
     protected onResize(width: number, height: number): void;
+    protected onRemove(): void;
     protected destroySelf(): void;
 }

package/renderables/Select.d.ts

@@ -3,12 +3,13 @@ import { fonts } from "../lib/ascii.font";
 import type { ParsedKey } from "../lib/parse.keypress";
 import { type ColorInput } from "../lib/RGBA";
 import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
 export interface SelectOption {
     name: string;
     description: string;
     value?: any;
 }
-export interface SelectRenderableOptions extends RenderableOptions {
+export interface SelectRenderableOptions extends RenderableOptions<SelectRenderable> {
     backgroundColor?: ColorInput;
     textColor?: ColorInput;
     focusedBackgroundColor?: ColorInput;
@@ -66,7 +67,7 @@ export declare class SelectRenderable extends Renderable {
         itemSpacing: number;
         fastScrollStep: number;
     };
-    constructor(id: string, options: SelectRenderableOptions);
+    constructor(ctx: RenderContext, options: SelectRenderableOptions);
     protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
     private refreshFrameBuffer;
     private renderScrollIndicatorToFrameBuffer;

package/renderables/TabSelect.d.ts

@@ -2,12 +2,13 @@ import { Renderable, type RenderableOptions } from "../Renderable";
 import { OptimizedBuffer } from "../buffer";
 import { type ColorInput } from "../lib/RGBA";
 import type { ParsedKey } from "../lib/parse.keypress";
+import type { RenderContext } from "../types";
 export interface TabSelectOption {
     name: string;
     description: string;
     value?: any;
 }
-export interface TabSelectRenderableOptions extends Omit<RenderableOptions, "height"> {
+export interface TabSelectRenderableOptions extends Omit<RenderableOptions<TabSelectRenderable>, "height"> {
     height?: number;
     options?: TabSelectOption[];
     tabWidth?: number;
@@ -45,7 +46,7 @@ export declare class TabSelectRenderable extends Renderable {
     private _showDescription;
     private _showUnderline;
     private _wrapSelection;
-    constructor(id: string, options: TabSelectRenderableOptions);
+    constructor(ctx: RenderContext, options: TabSelectRenderableOptions);
     private calculateDynamicHeight;
     protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
     private refreshFrameBuffer;

package/renderables/Text.d.ts

@@ -1,9 +1,9 @@
 import { Renderable, type RenderableOptions } from "../Renderable";
 import { StyledText } from "../lib/styled-text";
 import { RGBA } from "../lib/RGBA";
-import type { SelectionState } from "../types";
+import { type SelectionState, type RenderContext } from "../types";
 import type { OptimizedBuffer } from "../buffer";
-export interface TextOptions extends RenderableOptions {
+export interface TextOptions extends RenderableOptions<TextRenderable> {
     content?: StyledText | string;
     fg?: string | RGBA;
     bg?: string | RGBA;
@@ -24,7 +24,7 @@ export declare class TextRenderable extends Renderable {
     private textBuffer;
     private _plainText;
     private _lineInfo;
-    constructor(id: string, options: TextOptions);
+    constructor(ctx: RenderContext, options: TextOptions);
     get content(): StyledText;
     set content(value: StyledText | string);
     get fg(): RGBA;

package/renderables/composition/VRenderable.d.ts

@@ -0,0 +1,16 @@
+import { Renderable, type RenderableOptions } from "../../Renderable";
+import type { OptimizedBuffer } from "../../buffer";
+import type { RenderContext } from "../../types";
+export interface VRenderableOptions extends RenderableOptions<VRenderable> {
+    render?: (this: VRenderable | VRenderableOptions, buffer: OptimizedBuffer, deltaTime: number, renderable: VRenderable) => void;
+}
+/**
+ * A generic renderable that accepts a custom render function as a prop.
+ * This allows functional constructs to specify custom rendering behavior
+ * without needing to subclass Renderable.
+ */
+export declare class VRenderable extends Renderable {
+    private options;
+    constructor(ctx: RenderContext, options: VRenderableOptions);
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+}

package/renderables/composition/constructs.d.ts

@@ -0,0 +1,14 @@
+import { ASCIIFontRenderable, BoxRenderable, GroupRenderable, InputRenderable, SelectRenderable, TabSelectRenderable, TextRenderable, VRenderable, type ASCIIFontOptions, type BoxOptions, type TextOptions, type VRenderableOptions, type InputRenderableOptions, type SelectRenderableOptions, type TabSelectRenderableOptions, FrameBufferRenderable, type FrameBufferOptions } from "../";
+import type { RenderableOptions } from "../../Renderable";
+import { type VChild, type ProxiedVNode } from "./vnode";
+export declare function Generic(props?: VRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof VRenderable>;
+export declare function Group(props?: RenderableOptions<any>, ...children: VChild[]): ProxiedVNode<typeof GroupRenderable>;
+export declare function Box(props?: BoxOptions, ...children: VChild[]): ProxiedVNode<typeof BoxRenderable>;
+export declare function Text(props?: TextOptions & {
+    content?: any;
+}, ...children: VChild[]): ProxiedVNode<typeof TextRenderable>;
+export declare function ASCIIFont(props?: ASCIIFontOptions, ...children: VChild[]): ProxiedVNode<typeof ASCIIFontRenderable>;
+export declare function Input(props?: InputRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof InputRenderable>;
+export declare function Select(props?: SelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof SelectRenderable>;
+export declare function TabSelect(props?: TabSelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof TabSelectRenderable>;
+export declare function FrameBuffer(props: FrameBufferOptions, ...children: VChild[]): ProxiedVNode<typeof FrameBufferRenderable>;

package/renderables/composition/vnode.d.ts

@@ -0,0 +1,38 @@
+import { Renderable, type RenderableOptions } from "../../Renderable";
+import type { RenderContext } from "../../types";
+export type VChild = VNode | Renderable | VChild[] | null | undefined | false;
+export interface PendingCall {
+    method: string;
+    args: any[];
+    isProperty?: boolean;
+}
+export interface VNode<P = any, C = VChild[]> {
+    __isVNode: true;
+    type: Construct<P>;
+    props?: P;
+    children?: C;
+    __delegateMap?: Record<string, string>;
+    __pendingCalls?: PendingCall[];
+}
+export type ProxiedVNode<TCtor extends RenderableConstructor<any>> = VNode<TCtor extends RenderableConstructor<infer P> ? P : any> & {
+    [K in keyof InstanceType<TCtor>]: InstanceType<TCtor>[K] extends (...args: infer Args) => any ? (...args: Args) => ProxiedVNode<TCtor> : InstanceType<TCtor>[K];
+};
+export interface RenderableConstructor<P extends RenderableOptions<any> = RenderableOptions<any>> {
+    new (ctx: RenderContext, options: P): Renderable;
+}
+export type FunctionalConstruct<P = any> = (props: P, children?: VChild[]) => VNode;
+export type Construct<P = any> = RenderableConstructor<P extends RenderableOptions<any> ? P : never> | FunctionalConstruct<P>;
+export declare function h<TCtor extends RenderableConstructor<any>>(type: TCtor, props?: TCtor extends RenderableConstructor<infer P> ? P : never, ...children: VChild[]): ProxiedVNode<TCtor>;
+export declare function h<P>(type: FunctionalConstruct<P>, props?: P, ...children: VChild[]): VNode<P>;
+export declare function h<P>(type: Construct<P>, props?: P, ...children: VChild[]): VNode<P> | ProxiedVNode<any>;
+export declare function isVNode(node: any): node is VNode;
+export declare function ensureRenderable(ctx: RenderContext, node: Renderable | VNode<any, any[]>): Renderable;
+export declare function wrapWithDelegates<T extends InstanceType<RenderableConstructor>>(instance: T, delegateMap: Record<string, string> | undefined): T;
+export declare function instantiate(ctx: RenderContext, node: VChild): Renderable;
+export type DelegateMap<T> = Partial<Record<keyof T, string>>;
+export declare function delegate<TCtor extends RenderableConstructor<any>, K extends keyof InstanceType<TCtor>>(mapping: Partial<Record<K, string>>, vnode: ProxiedVNode<TCtor>): ProxiedVNode<TCtor>;
+export declare function delegate<TCtor extends RenderableConstructor<any>, K extends keyof InstanceType<TCtor>>(mapping: Partial<Record<K, string>>, vnode: VNode<any> & {
+    type: TCtor;
+}): VNode;
+export declare function delegate(mapping: Record<string, string>, vnode: VNode<any>): VNode;
+export declare function delegate(mapping: Record<string, string>, renderable: Renderable): Renderable;

package/renderables/index.d.ts

@@ -6,3 +6,6 @@ export * from "./ASCIIFont";
 export * from "./Input";
 export * from "./Select";
 export * from "./TabSelect";
+export * from "./composition/constructs";
+export * from "./composition/vnode";
+export * from "./composition/VRenderable";

package/renderer.d.ts

@@ -1,5 +1,5 @@
 import { Renderable, RootRenderable } from "./Renderable";
-import { type CursorStyle, DebugOverlayCorner } from "./types";
+import { type CursorStyle, DebugOverlayCorner, type RenderContext, type WidthMethod } from "./types";
 import { RGBA, type ColorInput } from "./lib/RGBA";
 import type { Pointer } from "bun:ffi";
 import { OptimizedBuffer } from "./buffer";
@@ -61,7 +61,7 @@ export declare function createCliRenderer(config?: CliRendererConfig): Promise<C
 export declare enum CliRenderEvents {
     DEBUG_OVERLAY_TOGGLE = "debugOverlay:toggle"
 }
-export declare class CliRenderer extends EventEmitter {
+export declare class CliRenderer extends EventEmitter implements RenderContext {
     private static animationFrameId;
     private lib;
     rendererPtr: Pointer;
@@ -109,7 +109,6 @@ export declare class CliRenderer extends EventEmitter {
     private animationRequest;
     private resizeTimeoutId;
     private resizeDebounceDelay;
-    private renderContext;
     private enableMouseMovement;
     private _useMouse;
     private _useAlternateScreen;
@@ -123,12 +122,16 @@ export declare class CliRenderer extends EventEmitter {
     private renderOffset;
     private _terminalWidth;
     private _terminalHeight;
+    private _terminalIsSetup;
     private realStdoutWrite;
     private captureCallback;
     private _useConsole;
     private mouseParser;
     private sigwinchHandler;
+    private _capabilities;
     constructor(lib: RenderLib, rendererPtr: Pointer, stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream, width: number, height: number, config?: CliRendererConfig);
+    addToHitGrid(x: number, y: number, width: number, height: number, id: number): void;
+    get widthMethod(): WidthMethod;
     private writeOut;
     needsUpdate(): void;
     get useConsole(): boolean;
@@ -144,14 +147,17 @@ export declare class CliRenderer extends EventEmitter {
     get experimental_splitHeight(): number;
     get liveRequestCount(): number;
     get currentControlState(): string;
+    get capabilities(): any | null;
     set experimental_splitHeight(splitHeight: number);
     private interceptStdoutWrite;
     private disableStdoutInterception;
     private flushStdoutCache;
     private enableMouse;
     private disableMouse;
+    enableKittyKeyboard(flags?: number): void;
+    disableKittyKeyboard(): void;
     set useThread(useThread: boolean);
-    private setupTerminal;
+    setupTerminal(): Promise<void>;
     private handleMouseData;
     private takeMemorySnapshot;
     private startMemorySnapshotTimer;
@@ -169,9 +175,9 @@ export declare class CliRenderer extends EventEmitter {
     dumpHitGrid(): void;
     dumpBuffers(timestamp?: number): void;
     dumpStdoutBuffer(timestamp?: number): void;
-    static setCursorPosition(x: number, y: number, visible?: boolean): void;
-    static setCursorStyle(style: CursorStyle, blinking?: boolean, color?: RGBA): void;
-    static setCursorColor(color: RGBA): void;
+    static setCursorPosition(renderer: CliRenderer, x: number, y: number, visible?: boolean): void;
+    static setCursorStyle(renderer: CliRenderer, style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    static setCursorColor(renderer: CliRenderer, color: RGBA): void;
     setCursorPosition(x: number, y: number, visible?: boolean): void;
     setCursorStyle(style: CursorStyle, blinking?: boolean, color?: RGBA): void;
     setCursorColor(color: RGBA): void;

package/text-buffer.d.ts

@@ -2,6 +2,7 @@ import type { StyledText } from "./lib/styled-text";
 import { RGBA } from "./lib/RGBA";
 import { type RenderLib } from "./zig";
 import { type Pointer } from "bun:ffi";
+import { type WidthMethod } from "./types";
 export interface TextChunk {
     __isChunk: true;
     text: Uint8Array;
@@ -23,7 +24,7 @@ export declare class TextBuffer {
         bg: Float32Array;
         attributes: Uint16Array;
     }, capacity: number);
-    static create(capacity?: number): TextBuffer;
+    static create(capacity: number | undefined, widthMethod: WidthMethod): TextBuffer;
     private syncBuffersAfterResize;
     setStyledText(text: StyledText): void;
     setDefaultFg(fg: RGBA | null): void;

package/types.d.ts

@@ -1,3 +1,4 @@
+import type { RGBA } from "./lib/RGBA";
 export declare const TextAttributes: {
     NONE: number;
     BOLD: number;
@@ -16,11 +17,19 @@ export declare enum DebugOverlayCorner {
     bottomLeft = 2,
     bottomRight = 3
 }
+export type WidthMethod = "wcwidth" | "unicode";
 export interface RenderContext {
     addToHitGrid: (x: number, y: number, width: number, height: number, id: number) => void;
-    width: () => number;
-    height: () => number;
+    width: number;
+    height: number;
     needsUpdate: () => void;
+    setCursorPosition: (x: number, y: number, visible: boolean) => void;
+    setCursorStyle: (style: CursorStyle, blinking: boolean) => void;
+    setCursorColor: (color: RGBA) => void;
+    widthMethod: WidthMethod;
+    capabilities: any | null;
+    requestLive: () => void;
+    dropLive: () => void;
 }
 export interface SelectionState {
     anchor: {

package/zig.d.ts

@@ -1,5 +1,5 @@
 import { type Pointer } from "bun:ffi";
-import type { CursorStyle, DebugOverlayCorner } from "./types";
+import { type CursorStyle, type DebugOverlayCorner, type WidthMethod } from "./types";
 import { RGBA } from "./lib/RGBA";
 import { OptimizedBuffer } from "./buffer";
 import { TextBuffer } from "./text-buffer";
@@ -14,7 +14,7 @@ export interface RenderLib {
     render: (renderer: Pointer, force: boolean) => void;
     getNextBuffer: (renderer: Pointer) => OptimizedBuffer;
     getCurrentBuffer: (renderer: Pointer) => OptimizedBuffer;
-    createOptimizedBuffer: (width: number, height: number, respectAlpha?: boolean) => OptimizedBuffer;
+    createOptimizedBuffer: (width: number, height: number, widthMethod: WidthMethod, respectAlpha?: boolean) => OptimizedBuffer;
     destroyOptimizedBuffer: (bufferPtr: Pointer) => void;
     drawFrameBuffer: (targetBufferPtr: Pointer, destX: number, destY: number, bufferPtr: Pointer, sourceX?: number, sourceY?: number, sourceWidth?: number, sourceHeight?: number) => void;
     getBufferWidth: (buffer: Pointer) => number;
@@ -39,9 +39,9 @@ export interface RenderLib {
         attributes: Uint8Array;
     };
     resizeRenderer: (renderer: Pointer, width: number, height: number) => void;
-    setCursorPosition: (x: number, y: number, visible: boolean) => void;
-    setCursorStyle: (style: CursorStyle, blinking: boolean) => void;
-    setCursorColor: (color: RGBA) => void;
+    setCursorPosition: (renderer: Pointer, x: number, y: number, visible: boolean) => void;
+    setCursorStyle: (renderer: Pointer, style: CursorStyle, blinking: boolean) => void;
+    setCursorColor: (renderer: Pointer, color: RGBA) => void;
     setDebugOverlay: (renderer: Pointer, enabled: boolean, corner: DebugOverlayCorner) => void;
     clearTerminal: (renderer: Pointer) => void;
     addToHitGrid: (renderer: Pointer, x: number, y: number, width: number, height: number, id: number) => void;
@@ -51,7 +51,10 @@ export interface RenderLib {
     dumpStdoutBuffer: (renderer: Pointer, timestamp?: number) => void;
     enableMouse: (renderer: Pointer, enableMovement: boolean) => void;
     disableMouse: (renderer: Pointer) => void;
-    createTextBuffer: (capacity: number) => TextBuffer;
+    enableKittyKeyboard: (renderer: Pointer, flags: number) => void;
+    disableKittyKeyboard: (renderer: Pointer) => void;
+    setupTerminal: (renderer: Pointer, useAlternateScreen: boolean) => void;
+    createTextBuffer: (capacity: number, widthMethod: WidthMethod) => TextBuffer;
     destroyTextBuffer: (buffer: Pointer) => void;
     textBufferGetCharPtr: (buffer: Pointer) => Pointer;
     textBufferGetFgPtr: (buffer: Pointer) => Pointer;
@@ -92,6 +95,8 @@ export interface RenderLib {
         width: number;
         height: number;
     }) => void;
+    getTerminalCapabilities: (renderer: Pointer) => any;
+    processCapabilityResponse: (renderer: Pointer, response: string) => void;
 }
 export declare function setRenderLibPath(libPath: string): void;
 export declare function resolveRenderLib(): RenderLib;