/**
 * VolvoxGrid - High-performance pixel-rendering datagrid for the web.
 *
 * Wraps the Rust VolvoxGrid engine compiled to WebAssembly.  All grid state
 * lives inside WASM memory; this class manages the render loop, the
 * HTML canvas, and event forwarding.
 */
import { ArchiveRequest_Action, DropdownItemLayout, EditEndReason, EditorPresentation, EditorUpdateReason, RenderLayerBit, ThemePreset } from "./generated/volvoxgrid_ffi.js";
import { VolvoxGridServiceFfi } from "./generated/volvoxgrid_ffi.js";
export { DropdownItemLayout, ThemePreset } from "./generated/volvoxgrid_ffi.js";
export type VolvoxGridRowId = string | number;
export type VolvoxGridDataRow = Record<string, unknown> | ReadonlyArray<unknown>;
export interface VolvoxGridGetRowIdParams<TRow = VolvoxGridDataRow> {
    data: TRow;
    rowIndex: number;
}
export type VolvoxGridGetRowId<TRow = VolvoxGridDataRow> = (params: VolvoxGridGetRowIdParams<TRow>) => VolvoxGridRowId;
export interface VolvoxGridValueGetterParams<TRow = VolvoxGridDataRow> {
    data: TRow;
    rowIndex: number;
    colIndex: number;
    field?: string;
    column: VolvoxGridColumnDef<TRow>;
}
export interface VolvoxGridValueFormatterParams<TRow = VolvoxGridDataRow> extends VolvoxGridValueGetterParams<TRow> {
    value: unknown;
}
export interface VolvoxGridColumnDef<TRow = VolvoxGridDataRow> extends VolvoxGridColumnSpec {
    /** Object field name. Mirrors AG Grid/MUI/Kendo-style data-column APIs. */
    field?: string;
    /** Stable column id. Used as the engine column key when `key` is omitted. */
    colId?: string;
    /** User-facing header text. Used as the engine caption when `caption` is omitted. */
    headerName?: string;
    /** Host-side value projection for data rows. */
    valueGetter?: (params: VolvoxGridValueGetterParams<TRow>) => unknown;
    /** Host-side display formatting for values written through the easy data API. */
    valueFormatter?: (params: VolvoxGridValueFormatterParams<TRow>) => unknown;
}
export interface VolvoxGridSetDataOptions<TRow = VolvoxGridDataRow> {
    columns?: ReadonlyArray<VolvoxGridColumnDef<TRow>>;
    getRowId?: VolvoxGridGetRowId<TRow>;
    atomic?: boolean;
    loadDataOptions?: VolvoxGridLoadDataOptions;
}
export interface VolvoxGridUpdateRowsOptions<TRow = VolvoxGridDataRow> {
    getRowId?: VolvoxGridGetRowId<TRow>;
    addMissing?: boolean;
    atomic?: boolean;
}
export interface VolvoxGridTransaction<TRow = VolvoxGridDataRow> {
    add?: ReadonlyArray<TRow>;
    update?: ReadonlyArray<TRow>;
    remove?: ReadonlyArray<TRow | VolvoxGridRowId>;
}
export interface VolvoxGridTransactionResult {
    add: number[];
    update: number[];
    remove: number[];
}
export interface VolvoxGridTreeDataOptions<TRow = VolvoxGridDataRow> {
    columns?: ReadonlyArray<VolvoxGridColumnDef<TRow>>;
    getId?: (row: TRow, index: number) => VolvoxGridRowId;
    getParentId?: (row: TRow, index: number) => VolvoxGridRowId | null | undefined;
    getChildren?: (row: TRow, index: number) => ReadonlyArray<TRow> | null | undefined;
    idField?: string;
    parentIdField?: string;
    childrenField?: string;
    labelField?: string;
    replace?: boolean;
    collapseInitial?: boolean;
}
export type VolvoxGridProtoRequest = Uint8Array | ArrayBuffer | {
    gridId?: bigint | number;
    grid_id?: bigint | number;
    toBinary?: () => Uint8Array;
    toByteArray?: () => Uint8Array;
};
export interface VolvoxGridProtoMessageType<T> {
    fromBinary?: (data: Uint8Array) => T;
    parseFrom?: (data: Uint8Array) => T;
}
export interface VolvoxGridCallProtoOptions {
    /** Fill generated request.gridId/grid_id with the current engine id when it is unset. */
    injectGridId?: boolean;
    /** Mark the canvas dirty after the raw call. Defaults to the known RPC mutability. */
    dirty?: boolean;
    /** Permit zero-byte protobuf responses. Defaults true because empty protobufs are valid. */
    allowEmptyResponse?: boolean;
}
/**
 * Options for the data-first `new VolvoxGrid(host, options)` form.
 *
 * `host` may be any HTMLElement: pass a `<canvas>` to render into it directly,
 * or any container (e.g. a `<div>`) to have VolvoxGrid create a child canvas
 * that fills it. The grid resolves its own WebAssembly module from `wasmUrl`.
 *
 * Construction is asynchronous in this form. Await `grid.loaded` before
 * calling other methods:
 *
 * ```ts
 * const grid = new VolvoxGrid(document.getElementById("grid"), {
 *   rowCount: 100,
 *   colCount: 5,
 * });
 * await grid.loaded;
 * grid.setCellText(0, 0, "Hello");
 * ```
 */
export interface VolvoxGridOptions {
    /**
     * URL of the wasm-bindgen JS glue file produced by
     * `wasm-pack build --target web`.
     *
     * When omitted, defaults to the `wasm/volvoxgrid_wasm.js` shipped alongside
     * this module in the published npm package — resolved via
     * `new URL("../wasm/volvoxgrid_wasm.js", import.meta.url)`. That works for
     * CDN/unbundled ESM consumers (the package layout has `dist/` and `wasm/`
     * as siblings). For bundled apps where the JS is inlined and `import.meta.url`
     * no longer points at the package, pass an explicit URL — typically built
     * with your bundler's asset URL helper, e.g.
     * `new URL('volvoxgrid/wasm/volvoxgrid_wasm.js', import.meta.url).href`.
     */
    wasmUrl?: string;
    /** Initial row count for the grid body. Defaults to 10. */
    rowCount?: number;
    /** Initial column count for the grid body. Defaults to 5. */
    colCount?: number;
    /** Initial commercial-grid style column definitions. */
    columns?: ReadonlyArray<VolvoxGridColumnDef>;
    /** Alias for `columns`, matching AG Grid/MUI-style naming. */
    columnDefs?: ReadonlyArray<VolvoxGridColumnDef>;
    /** Initial row data. Alias: `data`. */
    rowData?: ReadonlyArray<VolvoxGridDataRow>;
    /** Initial row data. Alias: `rowData`. */
    data?: ReadonlyArray<VolvoxGridDataRow>;
    /** Stable row id callback used by `updateRows` and `applyTransaction`. */
    getRowId?: VolvoxGridGetRowId;
    /** Load `rowData` as tree data instead of flat rows. */
    treeData?: boolean | VolvoxGridTreeDataOptions;
}
export interface VolvoxGridCellRange {
    row1: number;
    col1: number;
    row2: number;
    col2: number;
}
export interface VolvoxGridCellTextEntry {
    row: number;
    col: number;
    text: string;
}
export interface VolvoxGridSelection {
    row: number;
    col: number;
    rowEnd: number;
    colEnd: number;
    topRow: number;
    leftCol: number;
    bottomRow: number;
    rightCol: number;
    mouseRow: number;
    mouseCol: number;
    ranges: VolvoxGridCellRange[];
}
export type VolvoxGridContextMenuTrigger = "secondary_click";
export interface VolvoxGridContextMenuRequest {
    trigger: VolvoxGridContextMenuTrigger;
    clientX: number;
    clientY: number;
    canvasX: number;
    canvasY: number;
    row: number;
    col: number;
    selection: VolvoxGridSelection;
}
export interface VolvoxGridNodeInfo {
    row: number;
    level: number;
    isExpanded: boolean;
    childCount: number;
    parentRow: number;
    firstChild: number;
    lastChild: number;
}
export interface VolvoxGridBeforeEditDetails {
    eventId: bigint;
    rawEvent: Uint8Array;
    row: number;
    col: number;
    cancel: boolean;
}
export interface VolvoxGridDropdownItem {
    value?: string;
    label?: string;
    details?: string[];
    disabled?: boolean;
}
export interface VolvoxGridDropdown {
    items: VolvoxGridDropdownItem[];
    allowCustomValue?: boolean;
    itemLayout?: DropdownItemLayout;
    searchable?: boolean;
}
/**
 * @deprecated Dropdown-open cancellation is no longer emitted. Use `onBeforeEdit`
 * or editor list data-source APIs instead.
 */
export interface VolvoxGridBeforeDropdownOpenDetails {
    eventId: bigint;
    rawEvent: Uint8Array;
    row: number;
    col: number;
    x: number;
    y: number;
    width: number;
    height: number;
    dropdown: VolvoxGridDropdown;
    currentValue: string;
    selectedIndex: number;
    cancel: boolean;
}
export interface VolvoxGridCellEditValidatingDetails {
    eventId: bigint;
    rawEvent: Uint8Array;
    row: number;
    col: number;
    editText: string;
    cancel: boolean;
}
export interface VolvoxGridEditorSessionStartedDetails {
    sessionId: bigint;
    row: number;
    col: number;
    initialText: string;
    presentation: EditorPresentation;
    validationErrors: VolvoxGridValidationError[];
    stateVersion: bigint;
    rawEvent: Uint8Array;
}
export interface VolvoxGridValidationError {
    code: string;
    message: string;
    blocking: boolean;
}
export interface VolvoxGridEditorSessionUpdatedDetails {
    sessionId: bigint;
    text?: string;
    visible?: boolean;
    reason: EditorUpdateReason;
    validationErrors: VolvoxGridValidationError[];
    stateVersion: bigint;
    rawEvent: Uint8Array;
}
export interface VolvoxGridEditorSessionEndedDetails {
    sessionId: bigint;
    reason: EditEndReason;
    committedText?: string;
    stateVersion: bigint;
    rawEvent: Uint8Array;
}
export interface VolvoxGridBeforeSortDetails {
    eventId: bigint;
    rawEvent: Uint8Array;
    col: number;
    cancel: boolean;
}
export interface VolvoxGridCompareDetails {
    row1: number;
    row2: number;
    col: number;
}
export type VolvoxGridCompareCallback = (details: VolvoxGridCompareDetails) => number;
/**
 * Typed event map for `grid.on(name, listener)`. The value type for each key is
 * the argument passed to the listener.
 *
 * Cancelable events (`beforeEdit`, `cellEditValidating`, `beforeSort`) pass a
 * mutable details object — set `details.cancel = true` from any listener to
 * veto the action. If multiple listeners are registered, any one of them can
 * cancel.
 */
export interface VolvoxGridEventMap {
    beforeEdit: VolvoxGridBeforeEditDetails;
    cellEditValidating: VolvoxGridCellEditValidatingDetails;
    beforeSort: VolvoxGridBeforeSortDetails;
    editorSessionStarted: VolvoxGridEditorSessionStartedDetails;
    editorSessionUpdated: VolvoxGridEditorSessionUpdatedDetails;
    editorSessionEnded: VolvoxGridEditorSessionEndedDetails;
    zoomChange: number;
    contextMenuRequest: VolvoxGridContextMenuRequest;
    gridEventRaw: Uint8Array;
}
export type VolvoxGridEventListener<K extends keyof VolvoxGridEventMap> = (event: VolvoxGridEventMap[K]) => void;
export interface VolvoxGridHeaderFeatures {
    sort?: boolean;
    reorder?: boolean;
    chooser?: boolean;
}
export interface VolvoxGridResizePolicy {
    columns?: boolean;
    rows?: boolean;
    uniform?: boolean;
}
export interface VolvoxGridRowIndicatorSlot {
    kind?: number;
    width?: number;
    visible?: boolean;
    customKey?: string;
    data?: Uint8Array;
}
export interface VolvoxGridRowIndicatorConfig {
    visible?: boolean;
    width?: number;
    background?: number;
    foreground?: number;
    gridLines?: number;
    gridColor?: number;
    autoSize?: boolean;
    allowResize?: boolean;
    allowSelect?: boolean;
    allowReorder?: boolean;
    slots?: ReadonlyArray<VolvoxGridRowIndicatorSlot>;
}
export interface VolvoxGridColumnIndicatorConfig {
    visible?: boolean;
    defaultRowHeight?: number;
    bandRows?: number;
    cellModes?: ReadonlyArray<number>;
    background?: number;
    foreground?: number;
    gridLines?: number;
    gridColor?: number;
    autoSize?: boolean;
    allowResize?: boolean;
    allowReorder?: boolean;
    allowMenu?: boolean;
}
export interface VolvoxGridFreezePolicy {
    columns?: boolean;
    rows?: boolean;
}
export interface VolvoxGridSelectionHoverMode {
    row?: boolean;
    column?: boolean;
    cell?: boolean;
}
export interface VolvoxGridRowSpec {
    height?: number;
    hidden?: boolean;
    isSubtotal?: boolean;
    outlineLevel?: number;
}
export interface VolvoxGridBarcodeEncoding {
    checkDigit?: number;
    textEncoding?: number;
    qrEcc?: number;
}
export interface VolvoxGridBarcodeRender {
    foreground?: number;
    background?: number;
    alignment?: number;
    moduleSize?: number;
    quietZone?: number;
    barHeight?: number;
    narrowBarWidth?: number;
    showSizeWarning?: boolean;
    sizeWarningColor?: number;
    useFullRect?: boolean;
}
export interface VolvoxGridBarcodeCaption {
    position?: number;
    text?: string;
    color?: number;
    fontSize?: number;
}
export interface VolvoxGridBarcode {
    symbology: number;
    value?: string;
    encoding?: VolvoxGridBarcodeEncoding;
    render?: VolvoxGridBarcodeRender;
    caption?: VolvoxGridBarcodeCaption;
}
export interface VolvoxGridCellUpdate {
    row: number;
    col: number;
    text?: string;
    style?: VolvoxGridCellStyle;
    barcode?: VolvoxGridBarcode;
}
export interface VolvoxGridUpdateCellsOptions {
    atomic?: boolean;
}
export interface VolvoxGridPadding {
    left?: number;
    top?: number;
    right?: number;
    bottom?: number;
}
export type VolvoxGridCellPadding = VolvoxGridPadding;
export interface VolvoxGridFont {
    family?: string;
    families?: string[];
    size?: number;
    bold?: boolean;
    italic?: boolean;
    underline?: boolean;
    strikethrough?: boolean;
    stretch?: number;
}
export interface VolvoxGridBorder {
    style?: number;
    colorArgb?: number;
}
export interface VolvoxGridBorders {
    all?: VolvoxGridBorder;
    top?: VolvoxGridBorder;
    right?: VolvoxGridBorder;
    bottom?: VolvoxGridBorder;
    left?: VolvoxGridBorder;
}
export interface VolvoxGridCellStyle {
    background?: number;
    foreground?: number;
    align?: number;
    font?: VolvoxGridFont;
    padding?: VolvoxGridPadding;
    borders?: VolvoxGridBorders;
    textEffect?: number;
    progress?: number;
    progressColor?: number;
    shrinkToFit?: boolean;
}
export type VolvoxGridHeaderMarkHeight = {
    mode: "ratio";
    value: number;
} | {
    mode: "px";
    value: number;
};
export interface VolvoxGridHeaderSeparator {
    enabled?: boolean;
    colorArgb?: number;
    widthPx?: number;
    height?: VolvoxGridHeaderMarkHeight;
    skipMerged?: boolean;
}
export type VolvoxGridHeaderSeparatorStyle = VolvoxGridHeaderSeparator;
export interface VolvoxGridHeaderResizeHandle {
    enabled?: boolean;
    colorArgb?: number;
    widthPx?: number;
    height?: VolvoxGridHeaderMarkHeight;
    hitWidthPx?: number;
    showOnlyWhenResizable?: boolean;
}
export type VolvoxGridHeaderResizeHandleStyle = VolvoxGridHeaderResizeHandle;
export interface VolvoxGridIconSlots {
    sortAscending?: string;
    sortDescending?: string;
    sortNone?: string;
    treeExpanded?: string;
    treeCollapsed?: string;
    menu?: string;
    filter?: string;
    filterActive?: string;
    columns?: string;
    dragHandle?: string;
    checkboxChecked?: string;
    checkboxUnchecked?: string;
    checkboxIndeterminate?: string;
}
export type VolvoxGridIconThemeSlots = VolvoxGridIconSlots;
export type VolvoxGridIconSlotName = keyof VolvoxGridIconSlots;
export interface VolvoxGridIconSourceNone {
    kind: "none";
}
export interface VolvoxGridIconSourceText {
    kind: "text";
    text: string;
}
export interface VolvoxGridIconSourceImage {
    kind: "image";
    format?: "png";
    data: Uint8Array;
}
export type VolvoxGridIconSource = VolvoxGridIconSourceNone | VolvoxGridIconSourceText | VolvoxGridIconSourceImage;
export type VolvoxGridIconAlign = "inlineEnd" | "inlineStart" | "start" | "end" | "center";
export interface VolvoxGridIconLayout {
    align?: VolvoxGridIconAlign;
    gapPx?: number;
}
export interface VolvoxGridIconTextStyle {
    fontName?: string;
    fontNames?: string[];
    fontSize?: number;
    bold?: boolean;
    italic?: boolean;
    colorArgb?: number;
}
export interface VolvoxGridIconSpec {
    source?: VolvoxGridIconSource;
    textStyle?: VolvoxGridIconTextStyle;
    layout?: VolvoxGridIconLayout;
}
export interface VolvoxGridIconThemeDefaults {
    textStyle?: VolvoxGridIconTextStyle;
    layout?: VolvoxGridIconLayout;
}
export interface VolvoxGridIconTheme {
    defaults?: VolvoxGridIconThemeDefaults;
    slots: Partial<Record<VolvoxGridIconSlotName, VolvoxGridIconSpec>>;
}
export interface VolvoxGridLoadDataCsvOptions {
    delimiter?: string;
    quoteChar?: string;
    trimWhitespace?: boolean;
}
export interface VolvoxGridLoadDataJsonOptions {
    dataPath?: string;
}
export interface VolvoxGridLoadDataFieldMapping {
    field: string;
    colIndex?: number;
    colKey?: string;
}
export interface VolvoxGridLoadDataOptions {
    csv?: VolvoxGridLoadDataCsvOptions;
    json?: VolvoxGridLoadDataJsonOptions;
    headerPolicy?: number;
    fieldMap?: ReadonlyArray<VolvoxGridLoadDataFieldMapping>;
    typePolicy?: number;
    coercion?: number;
    errorMode?: number;
    dateFormat?: string;
    decimalChar?: string;
    autoCreateColumns?: boolean;
    atomic?: boolean;
    skipRows?: number;
    maxRows?: number;
}
export type VolvoxGridLoadDataCellValue = {
    kind: "text";
    text: string;
} | {
    kind: "number";
    number: number;
} | {
    kind: "flag";
    flag: boolean;
} | {
    kind: "raw";
    raw: Uint8Array;
} | {
    kind: "timestamp";
    timestamp: bigint;
};
export interface VolvoxGridLoadDataViolation {
    row: number;
    col: number;
    expected: number;
    actual?: VolvoxGridLoadDataCellValue;
    reason: string;
}
export interface VolvoxGridLoadDataColumn {
    index?: number;
    width?: number;
    minWidth?: number;
    maxWidth?: number;
    caption?: string;
    align?: number;
    fixedAlign?: number;
    dataType?: number;
    format?: string;
    key?: string;
    sortOrder?: number;
    sortType?: number;
    dropdown?: VolvoxGridDropdown;
    dropdownItems?: string;
    editMask?: string;
    indent?: number;
    hidden?: boolean;
    span?: boolean;
    nullable?: boolean;
    coercionMode?: number;
    errorMode?: number;
}
export interface VolvoxGridLoadDataResult {
    status: number;
    rows: number;
    cols: number;
    rejected: number;
    violations: VolvoxGridLoadDataViolation[];
    warnings: string[];
    inferredColumns: VolvoxGridLoadDataColumn[];
}
export interface VolvoxGridSubtotalResult {
    rows: number[];
}
export interface VolvoxGridSubtotalLevel {
    groupCol?: number | null;
    caption?: string;
    backColor?: number;
    foreColor?: number;
}
export interface VolvoxGridAddSubtotalsOptions {
    aggregate?: number;
    clearExisting?: boolean;
    mergeColFrom?: number;
    mergeColTo?: number;
}
export interface VolvoxGridColumnSpec {
    caption?: string;
    key?: string;
    width?: number;
    align?: number;
    dataType?: number;
    format?: string;
    progressColor?: number;
    dropdownItems?: string;
    dropdown?: VolvoxGridDropdown;
    interaction?: number;
    hidden?: boolean;
    span?: boolean;
    nullable?: boolean;
}
export interface VolvoxGridRichTextRun {
    startIndex: number;
    foreground?: number;
    font?: VolvoxGridFont;
    baseline?: number;
    linkUrl?: string;
}
export interface VolvoxGridTreeCell {
    col: number;
    text?: string;
    style?: VolvoxGridCellStyle;
    richText?: ReadonlyArray<VolvoxGridRichTextRun>;
}
export interface VolvoxGridTreeNode {
    id: string;
    parentId?: string;
    hasChildren?: boolean;
    cells?: ReadonlyArray<VolvoxGridTreeCell>;
}
export interface VolvoxGridLoadTreeOptions {
    replace?: boolean;
    collapseInitial?: boolean;
}
export interface VolvoxGridOutlineConfig {
    treeIndicator?: number;
    treeColor?: number;
    groupTotalPosition?: number;
    multiTotals?: boolean;
    indicatorIndent?: number;
    maxLevels?: number;
    showLevelButtons?: boolean;
    labelColumn?: number;
    iconColumn?: number;
}
export interface VolvoxGridCornerIndicatorSlot {
    kind: number;
    width?: number;
    visible?: boolean;
}
export interface VolvoxGridCornerIndicatorConfig {
    visible?: boolean;
    background?: number;
    foreground?: number;
    slots?: ReadonlyArray<VolvoxGridCornerIndicatorSlot>;
}
export declare function dropdownFromLabels(items: string): VolvoxGridDropdown;
export declare class VolvoxGrid {
    private static readonly TOUCH_SCROLL_LINE_PX;
    private static readonly TOUCH_PAN_START_PX;
    private static readonly TOUCH_DOUBLE_TAP_MS;
    private static readonly TOUCH_DOUBLE_TAP_SLOP_PX;
    private static readonly ZOOM_MIN_SCALE;
    private static readonly ZOOM_MAX_SCALE;
    private static readonly ZOOM_STEP_MIN_SCALE;
    private static readonly ZOOM_STEP_MAX_SCALE;
    private static readonly ZOOM_STEP_NOISE_EPSILON;
    private static renderLayerBitNumber;
    private static engineSortOrder;
    /**
     * Resolves to the grid instance once the WebAssembly engine has loaded
     * and the grid is ready to receive method calls. For the legacy
     * `(canvas, wasmModule, rows, cols)` constructor form this is already
     * resolved by the time the constructor returns.
     */
    readonly loaded: Promise<this>;
    private wasm;
    private gridId;
    private canvas;
    private ctx;
    private useGpu;
    private _presentMode;
    private animFrame;
    private dirty;
    private destroyed;
    private resizeObserver;
    private lastFrameTs;
    private renderMemoryBuffer;
    private renderPixelView;
    private renderImageData;
    private renderPtr;
    private renderByteLength;
    private renderWidth;
    private renderHeight;
    private gpuCanvas;
    private cpuCanvas;
    private canvasOpacityBeforeOverlay;
    private readonly touchPoints;
    private touchMode;
    private activeTouchPointerId;
    private touchStartX;
    private touchStartY;
    private touchLastX;
    private touchLastY;
    private touchPanActive;
    private touchTapOnlyPointerId;
    private pinchLastDistance;
    private pinchLastCenterX;
    private pinchLastCenterY;
    private readonly zoomScaleByGrid;
    private readonly zoomBaseFontSizeByGrid;
    private lastTouchTapTime;
    private lastTouchTapX;
    private lastTouchTapY;
    private lastTouchTapRow;
    private lastTouchTapCol;
    private suppressNextTouchTapRecord;
    private lastMouseDownTime;
    private lastMouseDownX;
    private lastMouseDownY;
    private readonly zoomBaseRowHeightByGrid;
    private readonly zoomBaseColWidthByGrid;
    private readonly cellBackColorBatchEncoder;
    onZoomChange: ((scale: number) => void) | null;
    onContextMenuRequest: ((request: VolvoxGridContextMenuRequest) => void) | null;
    private rawGridEventListener;
    private beforeEditListener;
    private beforeDropdownOpenListener;
    private cellEditValidatingListener;
    private activeEditorSessionPresentation;
    private editorSessionStartedListener;
    private editorSessionUpdatedListener;
    private editorSessionEndedListener;
    private beforeSortListener;
    private compareListener;
    private readonly namedEventListeners;
    private eventPump;
    private manualEventDecisionEnabled;
    private dpr;
    private dprX;
    private dprY;
    private pendingCanvasWidth;
    private pendingCanvasHeight;
    private pendingDpr;
    private pendingDprX;
    private pendingDprY;
    private forcedRenderWidth;
    private forcedRenderHeight;
    private _maxDpr;
    private presentCssWidth;
    private presentCssHeight;
    private editInput;
    private editTextArea;
    private editSelect;
    private editDataList;
    private editDataListId;
    private activeEditor;
    private editorCellKey;
    private suppressEditorInput;
    /** When true, syncInputEditor skips select() so the host adapter controls caret/selection. */
    suppressEditorSelect: boolean;
    private suppressBlurCommit;
    private editComposing;
    private editComposingBaseText;
    private imeProxy;
    private skipNextCanvasImeRedirect;
    private lastPointerWasTouch;
    /** Called when IME composition starts editing on an idle cell.
     *  Adapters (e.g. VolvoxSheet) can hook into this to synchronously
     *  sync their own editing state before editInput gets focused. */
    onCompositionEditStart: (() => void) | null;
    private headerSeparatorStyle;
    private headerResizeHandleStyle;
    private iconThemeStyleCache;
    private selectionModeValue;
    private selectionVisibilityValue;
    private focusBorderValue;
    private cellSpanModeValue;
    private themePresetValue;
    private editTriggerValue;
    private tabBehaviorValue;
    private scrollBarsValue;
    private animationEnabledValue;
    private animationDurationMsValue;
    private textLayoutCacheCapValue;
    private dataColumns;
    private dataRows;
    private rowIdToIndex;
    private getRowIdCallback;
    private ffiClient;
    /** Cancelable edit-start hook for the web canvas host. */
    get onBeforeEdit(): ((details: VolvoxGridBeforeEditDetails) => void) | null;
    set onBeforeEdit(listener: ((details: VolvoxGridBeforeEditDetails) => void) | null);
    /**
     * @deprecated Dropdown-open cancellation is no longer emitted. Use `onBeforeEdit`
     * or editor list data-source APIs instead.
     */
    get onBeforeDropdownOpen(): ((details: VolvoxGridBeforeDropdownOpenDetails) => void) | null;
    set onBeforeDropdownOpen(listener: ((details: VolvoxGridBeforeDropdownOpenDetails) => void) | null);
    /** Cancelable edit-commit validation hook for the web canvas host. */
    get onCellEditValidating(): ((details: VolvoxGridCellEditValidatingDetails) => void) | null;
    set onCellEditValidating(listener: ((details: VolvoxGridCellEditValidatingDetails) => void) | null);
    /** Render-session editor lifecycle hook. Fired when the engine starts editing a cell. */
    get onEditorSessionStarted(): ((details: VolvoxGridEditorSessionStartedDetails) => void) | null;
    set onEditorSessionStarted(listener: ((details: VolvoxGridEditorSessionStartedDetails) => void) | null);
    /** Render-session editor lifecycle hook. Fired for geometry/value/visibility updates. */
    get onEditorSessionUpdated(): ((details: VolvoxGridEditorSessionUpdatedDetails) => void) | null;
    set onEditorSessionUpdated(listener: ((details: VolvoxGridEditorSessionUpdatedDetails) => void) | null);
    /** Render-session editor lifecycle hook. Fired when the engine ends an edit session. */
    get onEditorSessionEnded(): ((details: VolvoxGridEditorSessionEndedDetails) => void) | null;
    set onEditorSessionEnded(listener: ((details: VolvoxGridEditorSessionEndedDetails) => void) | null);
    /** Cancelable header-sort hook for the web canvas host. */
    get onBeforeSort(): ((details: VolvoxGridBeforeSortDetails) => void) | null;
    set onBeforeSort(listener: ((details: VolvoxGridBeforeSortDetails) => void) | null);
    /** Synchronous comparator used by SORT_TYPE_CUSTOM sorts. */
    get onCompare(): VolvoxGridCompareCallback | null;
    set onCompare(listener: VolvoxGridCompareCallback | null);
    /** Raw `GridEvent` stream hook for demo/sample hosts. */
    get onGridEventRaw(): ((rawEvent: Uint8Array) => void) | null;
    set onGridEventRaw(listener: ((rawEvent: Uint8Array) => void) | null);
    /**
     * Register a typed event listener. Returns an `off()` disposer for
     * convenience. Multiple listeners per event are supported. For cancelable
     * events, any listener that sets `details.cancel = true` vetoes the action.
     *
     * ```ts
     * grid.on("beforeEdit", (e) => { if (e.col === 0) e.cancel = true; });
     * grid.on("editorSessionEnded", (e) => console.log("committed", e.committedText));
     * ```
     */
    on<K extends keyof VolvoxGridEventMap>(event: K, listener: VolvoxGridEventListener<K>): () => void;
    /** Remove a listener previously registered via `on()` or `once()`. */
    off<K extends keyof VolvoxGridEventMap>(event: K, listener: VolvoxGridEventListener<K>): void;
    /** Register a listener that fires at most once. Returns an `off()` disposer. */
    once<K extends keyof VolvoxGridEventMap>(event: K, listener: VolvoxGridEventListener<K>): () => void;
    private emit;
    private hasNamedListener;
    /**
     * Data-first constructor: pass any HTMLElement and a `VolvoxGridOptions`
     * object describing the WASM module URL and initial dimensions. After
     * construction, await `grid.loaded` before calling other methods.
     *
     * ```ts
     * const grid = new VolvoxGrid(document.getElementById("grid"), {
     *   wasmUrl: "./wasm/volvoxgrid_wasm.js",
     *   rowCount: 100,
     *   colCount: 5,
     * });
     * await grid.loaded;
     * grid.setCellText(0, 0, "Hello");
     * ```
     */
    constructor(host: HTMLElement, options?: VolvoxGridOptions);
    /**
     * Low-level constructor: pass an already-loaded wasm-bindgen module
     * directly. `grid.loaded` resolves on the next microtask.
     *
     * @param canvas The canvas element to render into.
     * @param wasm   The initialised wasm-bindgen module (the default export
     *               from the wasm-pack generated JS glue).
     * @param rows   Initial row count.
     * @param cols   Initial column count.
     */
    constructor(canvas: HTMLCanvasElement, wasm: any, rows?: number, cols?: number);
    /**
     * Distinguish the data-first options form from the legacy wasm-module form.
     *
     * Wasm-bindgen modules expose `create_grid` / `create_grid_scaled` as
     * functions; an options object never does. Treat anything else (including
     * `undefined`) as the options form.
     */
    private static isOptionsForm;
    /**
     * If `host` is already a `<canvas>`, use it. Otherwise create a child canvas
     * that fills the host and reuse it on subsequent constructions of the same
     * host.
     */
    private static resolveHostCanvas;
    /**
     * Resolve the default wasm URL relative to *this* module so that npm/CDN
     * consumers find the package's sibling `wasm/` directory. The published
     * layout is `<pkg>/dist/index.js` + `<pkg>/wasm/volvoxgrid_wasm.js`, so
     * `../wasm/...` from `dist/index.js` lands on the right file.
     *
     * Falls back to a plain relative string when `import.meta.url` is not
     * available (older non-ESM hosts) — that path is unlikely to resolve, but
     * it preserves the previous behaviour rather than throwing.
     */
    private static defaultWasmUrl;
    /**
     * Dynamically import the wasm-bindgen JS glue at `wasmUrl` and run its
     * default initializer. Returns the imported namespace object, which is
     * the same shape the legacy constructor expects.
     */
    private static loadWasm;
    /**
     * Synchronous engine bring-up. Runs once `wasm` is available — either
     * passed directly via the legacy constructor or resolved by `loadWasm`.
     */
    private initEngine;
    private applyInitialOptions;
    setGridOption<K extends keyof VolvoxGridOptions>(key: K, value: VolvoxGridOptions[K]): void;
    updateGridOptions(options: Partial<VolvoxGridOptions>): void;
    setColumns<TRow = VolvoxGridDataRow>(columns: ReadonlyArray<VolvoxGridColumnDef<TRow>>): void;
    setColumnDefs<TRow = VolvoxGridDataRow>(columns: ReadonlyArray<VolvoxGridColumnDef<TRow>>): void;
    setData<TRow extends VolvoxGridDataRow>(rows: ReadonlyArray<TRow>, options?: VolvoxGridSetDataOptions<TRow>): VolvoxGridLoadDataResult;
    updateRows<TRow extends VolvoxGridDataRow>(rows: ReadonlyArray<TRow>, options?: VolvoxGridUpdateRowsOptions<TRow>): number[];
    applyTransaction<TRow extends VolvoxGridDataRow>(transaction: VolvoxGridTransaction<TRow>): VolvoxGridTransactionResult;
    setTreeData<TRow extends VolvoxGridDataRow>(rows: ReadonlyArray<TRow>, options?: VolvoxGridTreeDataOptions<TRow>): void;
    private writeRowsAsCells;
    private rowToCellUpdates;
    private cellTextForColumn;
    private mergeRowData;
    private rowIdFor;
    private resolveRowIndex;
    private rebuildRowIdIndex;
    private treeRowId;
    private treeParentId;
    private treeChildren;
    /** Engine-side grid ID for direct WASM calls. */
    get id(): number;
    /**
     * Low-level escape hatch — the underlying WebAssembly module instance.
     *
     * Advanced use only. Prefer the typed `VolvoxGrid` methods (e.g. `defineColumns`,
     * `updateCells`, `setSelectionHover`). Calling raw `volvox_*_pb` exports requires
     * hand-encoding protobuf messages using the `*Fields` constants exported from
     * `volvoxgrid/generated/volvoxgrid_ffi.js`. No API stability guarantees on this
     * path — wire format and exports may change between releases.
     */
    get rawWasm(): any;
    /**
     * Typed protobuf-level escape hatch built on the synurang-generated FFI client.
     *
     * Use this when you want full access to `proto/volvoxgrid.proto` RPCs without
     * dropping all the way to hand-encoding wasm exports. Pass typed
     * request messages from `volvoxgrid/generated/volvoxgrid_lite.js`; the
     * generated `VolvoxGridServiceFfi` handles serialization and routes the call
     * through the wasm `_pb` exports.
     *
     * The same caveats apply as `rawWasm`: wire format and method shapes follow
     * the proto file, which is not part of the stable facade contract.
     */
    get ffi(): VolvoxGridServiceFfi;
    get protoLastError(): string;
    withGridId<T extends {
        gridId?: bigint | number;
        grid_id?: bigint | number;
    }>(request: T): T;
    callProto(method: string, request: VolvoxGridProtoRequest, options?: VolvoxGridCallProtoOptions): Uint8Array;
    callProto<TResponse>(method: string, request: VolvoxGridProtoRequest, responseType: VolvoxGridProtoMessageType<TResponse>, options?: VolvoxGridCallProtoOptions): TResponse;
    callProtoBytes(method: string, request: VolvoxGridProtoRequest, options?: VolvoxGridCallProtoOptions): Uint8Array;
    private encodeProtoRequest;
    /** Last requested theme preset; manual style changes are not reflected here. */
    get themePreset(): ThemePreset;
    set themePreset(preset: ThemePreset);
    setThemePreset(preset: ThemePreset): void;
    syncCursorFromEngine(): void;
    get rowCount(): number;
    set rowCount(n: number);
    get colCount(): number;
    set colCount(n: number);
    get frozenRowCount(): number;
    set frozenRowCount(n: number);
    get frozenColCount(): number;
    set frozenColCount(n: number);
    get showColumnHeaders(): boolean;
    set showColumnHeaders(value: boolean);
    setColumnIndicatorTopConfig(config: VolvoxGridColumnIndicatorConfig): void;
    get columnIndicatorTopRowCount(): number;
    set columnIndicatorTopRowCount(value: number);
    get showRowIndicator(): boolean;
    set showRowIndicator(value: boolean);
    setRowIndicatorStartConfig(config: VolvoxGridRowIndicatorConfig): void;
    get rowIndicatorStartWidth(): number;
    set rowIndicatorStartWidth(value: number);
    get cursorRow(): number;
    set cursorRow(row: number);
    get cursorCol(): number;
    set cursorCol(col: number);
    private get selectionRowEndValue();
    private get selectionColEndValue();
    selectRange(row1: number, col1: number, row2?: number, col2?: number, show?: boolean): void;
    selectRanges(ranges: ReadonlyArray<VolvoxGridCellRange>, activeRow?: number, activeCol?: number, show?: boolean): void;
    getSelection(): VolvoxGridSelection;
    showCell(row: number, col: number): void;
    clearSelection(): void;
    get zoomScale(): number;
    set zoomScale(scale: number);
    /** Record the current font/default cell size as the 100% zoom baseline. */
    captureZoomBase(): void;
    private isAtZoomBase;
    setCellText(row: number, col: number, text: string): void;
    getCellText(row: number, col: number): string;
    private setTextArray;
    private getTextArray;
    setCells(cells: ReadonlyArray<VolvoxGridCellTextEntry>): void;
    loadTable(rows: number, cols: number, values: unknown[]): void;
    /** Parse CSV or JSON bytes and load them into the grid via the wasm LoadData RPC. */
    loadData(data: string | Uint8Array | ArrayBuffer, options?: VolvoxGridLoadDataOptions): VolvoxGridLoadDataResult;
    /** Parse CSV or JSON bytes and append them to the grid via the wasm AppendData RPC. */
    appendData(data: string | Uint8Array | ArrayBuffer, options?: VolvoxGridLoadDataOptions): VolvoxGridLoadDataResult;
    /** Insert rows before [index] (`-1` appends), optional tab-text per row. */
    insertRows(index: number, count?: number, text?: string[]): void;
    /** Remove [count] rows starting at [index]. */
    removeRows(index: number, count?: number): void;
    /** Move a column to [position]. */
    moveColumn(col: number, position: number): void;
    /** Move a row to [position]. */
    moveRow(row: number, position: number): void;
    setCellFlood(row: number, col: number, percent: number, color: number): void;
    /** Batch per-cell background colors via UpdateCells protobuf.
     *  `updates` is a flat triplet array: [row0, col0, argb0, row1, col1, argb1, ...]. */
    setCellBackColors(updates: ReadonlyArray<number>): void;
    setColWidth(col: number, w: number): void;
    setColumnCaption(col: number, caption: string): void;
    getColWidth(col: number): number;
    get defaultColWidth(): number;
    set defaultColWidth(w: number);
    setRowHeight(row: number, h: number): void;
    getRowHeight(row: number): number;
    get defaultRowHeight(): number;
    set defaultRowHeight(h: number);
    /**
     * Override the internal render buffer resolution while keeping the canvas'
     * CSS layout size unchanged. Pass null/null to restore automatic sizing.
     */
    setRenderResolution(width: number | null, height?: number | null): void;
    /**
     * Cap the device-pixel-ratio used for rendering.
     *
     * On high-DPR displays (e.g. 2.0) this can dramatically reduce
     * the pixel count and improve FPS.  Set to 0 (default) for no cap.
     * A value of 1.0 renders at CSS resolution; 1.5 is a good quality/perf
     * balance on 2x displays.
     */
    get maxDpr(): number;
    set maxDpr(value: number);
    get selectionMode(): number;
    set selectionMode(mode: number);
    get selectionVisibility(): number;
    set selectionVisibility(mode: number);
    get focusBorder(): number;
    set focusBorder(style: number);
    setFontName(name: string): void;
    setFontSize(size: number): void;
    get fontFallbackEnabled(): boolean;
    set fontFallbackEnabled(enabled: boolean);
    get fontFallbacksEnabled(): boolean;
    set fontFallbacksEnabled(enabled: boolean);
    setFontFallbackEnabled(enabled: boolean): void;
    get cellSpanMode(): number;
    set cellSpanMode(mode: number);
    mergeCells(r1: number, c1: number, r2: number, c2: number): void;
    unmergeCells(r1: number, c1: number, r2: number, c2: number): void;
    getMergedRegions(): {
        row1: number;
        col1: number;
        row2: number;
        col2: number;
    }[];
    /** Set legacy grid line mode: 0=none, 1=solid both, 2=inset both, 3=raised both, 4=solid horizontal, 5=solid vertical, 6=inset horizontal, 7=inset vertical, 8=raised horizontal, 9=raised vertical */
    setGridLines(mode: number): void;
    private applyProtoConfig;
    setHeaderFeatures(features: VolvoxGridHeaderFeatures): void;
    setResizePolicy(policy: VolvoxGridResizePolicy): void;
    setFreezePolicy(policy: VolvoxGridFreezePolicy): void;
    setOutlineConfig(config: VolvoxGridOutlineConfig): void;
    setCornerIndicatorTopStartConfig(config: VolvoxGridCornerIndicatorConfig): void;
    setIndicatorAppearance(appearance: number): void;
    setSelectionHover(mode: VolvoxGridSelectionHoverMode): void;
    private normalizeHeaderMarkHeight;
    private normalizeArgbColor;
    private applyHeaderSeparatorStyleToEngine;
    private applyHeaderResizeHandleStyleToEngine;
    setHeaderSeparator(style: VolvoxGridHeaderSeparator): void;
    setHeaderSeparatorStyle(style: VolvoxGridHeaderSeparatorStyle): void;
    getHeaderSeparator(): VolvoxGridHeaderSeparator;
    getHeaderSeparatorStyle(): VolvoxGridHeaderSeparatorStyle;
    setHeaderResizeHandle(style: VolvoxGridHeaderResizeHandle): void;
    setHeaderResizeHandleStyle(style: VolvoxGridHeaderResizeHandleStyle): void;
    getHeaderResizeHandle(): VolvoxGridHeaderResizeHandle;
    getHeaderResizeHandleStyle(): VolvoxGridHeaderResizeHandleStyle;
    setGroupCompare(compare: number): void;
    getGroupCompare(): number;
    get editTrigger(): number;
    set editTrigger(mode: number);
    get editable(): boolean;
    set editable(enabled: boolean);
    get tabBehavior(): number;
    set tabBehavior(mode: number);
    get editMaxLength(): number;
    set editMaxLength(maxChars: number);
    get editText(): string;
    set editText(text: string);
    set topRow(row: number);
    get topRow(): number;
    set leftCol(col: number);
    get leftCol(): number;
    getBottomRow(): number;
    getRightCol(): number;
    getRowPos(row: number): number;
    getColPos(col: number): number;
    setRowData<TRow extends VolvoxGridDataRow>(rows: ReadonlyArray<TRow>, options?: VolvoxGridSetDataOptions<TRow>): VolvoxGridLoadDataResult;
    setRowData(row: number, data: Uint8Array): void;
    getRowData(row: number): Uint8Array;
    setRowStatus(row: number, status: number): void;
    getRowStatus(row: number): number;
    setCellStyle(row: number, col: number, style: VolvoxGridCellStyle): void;
    /** Pin position constants. */
    static readonly PIN_NONE = 0;
    static readonly PIN_TOP = 1;
    static readonly PIN_BOTTOM = 2;
    static readonly PIN_COL_NONE = 0;
    static readonly PIN_COL_LEFT = 1;
    static readonly PIN_COL_RIGHT = 2;
    /** Sticky edge constants. */
    static readonly STICKY_NONE = 0;
    static readonly STICKY_TOP = 1;
    static readonly STICKY_BOTTOM = 2;
    static readonly STICKY_LEFT = 3;
    static readonly STICKY_RIGHT = 4;
    static readonly STICKY_BOTH = 5;
    /** Archive action constants. */
    static readonly ARCHIVE_SAVE = ArchiveRequest_Action.SAVE;
    static readonly ARCHIVE_LOAD = ArchiveRequest_Action.LOAD;
    static readonly ARCHIVE_DELETE = ArchiveRequest_Action.DELETE;
    static readonly ARCHIVE_LIST = ArchiveRequest_Action.LIST;
    /** Pin a row to the top or bottom section, or unpin it (0=none, 1=top, 2=bottom). */
    pinRow(row: number, pin: number): void;
    /** Check whether a row is pinned. Returns 0=none, 1=top, 2=bottom. */
    isRowPinned(row: number): number;
    /** Pin a column to the left or right section, or unpin it (0=none, 1=left, 2=right). */
    pinCol(col: number, pin: number): void;
    /** Check whether a column is pinned. Returns 0=none, 1=left, 2=right. */
    isColPinned(col: number): number;
    /** Set the sticky edge for a row (0=none, 1=TOP, 2=BOTTOM, 5=BOTH). */
    setRowSticky(row: number, edge: number): void;
    /** Set the sticky edge for a column (0=none, 3=LEFT, 4=RIGHT, 5=BOTH). */
    setColSticky(col: number, edge: number): void;
    /** Set cell-level sticky overrides. */
    setCellSticky(row: number, col: number, stickyRow: number, stickyCol: number): void;
    setDataSourceMode(mode: number): void;
    setDataMode(mode: number): void;
    getDataSourceMode(): number;
    getDataMode(): number;
    setVirtualMode(enabled: boolean): void;
    setVirtualData(enabled: boolean): void;
    getVirtualMode(): boolean;
    getVirtualData(): boolean;
    setPictureType(pictureType: number): void;
    getPictureType(): number;
    getPicture(): Uint8Array;
    setSortAscendingPicture(data: Uint8Array): void;
    getSortAscendingPicture(): Uint8Array;
    setSortDescendingPicture(data: Uint8Array): void;
    getSortDescendingPicture(): Uint8Array;
    private setIconPictureByApi;
    private getIconPictureByApi;
    setIconTheme(theme: VolvoxGridIconTheme): void;
    getIconTheme(): VolvoxGridIconTheme;
    setIconSlots(slots: VolvoxGridIconSlots): void;
    setIconThemeSlots(slots: VolvoxGridIconThemeSlots): void;
    getIconSlots(): VolvoxGridIconSlots;
    getIconThemeSlots(): VolvoxGridIconThemeSlots;
    private defineColumnsWithDefaultEditors;
    private columnsWithExplicitEditors;
    private applyDefaultEditorsForInferredColumns;
    defineColumns(columns: ReadonlyArray<VolvoxGridColumnSpec>): void;
    defineRows(rows: ReadonlyArray<VolvoxGridRowSpec>): void;
    updateCells(cells: ReadonlyArray<VolvoxGridCellUpdate>, options?: VolvoxGridUpdateCellsOptions): void;
    loadTree(nodes: ReadonlyArray<VolvoxGridTreeNode>, options?: VolvoxGridLoadTreeOptions): void;
    setColDataType(col: number, dataType: number, nullable?: boolean): void;
    setColDropdown(col: number, dropdown: VolvoxGridDropdown): void;
    setCellDropdown(row: number, col: number, dropdown: VolvoxGridDropdown): void;
    set flingImpulseGain(gain: number);
    set flingFriction(friction: number);
    /**
     * Set GPU present mode using proto RenderConfig.present_mode.
     *
     * 0=AUTO, 1=FIFO, 2=MAILBOX, 3=IMMEDIATE
     */
    get presentMode(): number;
    set presentMode(mode: number);
    /** Set renderer mode: 0=AUTO, 1=CPU, 2=GPU */
    get rendererMode(): number;
    set rendererMode(mode: number);
    get rendererBackend(): number;
    set rendererBackend(mode: number);
    /** Check if GPU renderer is available in this build. */
    hasGpuRenderer(): boolean;
    /**
     * Attempt to initialise GPU rendering via WebGPU.
     *
     * Creates a second (overlay) canvas for the WebGPU surface so that the
     * original canvas keeps its 2D context and CPU<->GPU toggling works at
     * runtime via the `rendererMode` property.
     *
     * On failure the grid falls back to the CPU path transparently.
     */
    tryInitGpu(): Promise<boolean>;
    private ensureOverlayParent;
    private ensureCpuCanvasOverlay;
    private getCpuSurfaceCanvas;
    /** Lazily acquire the 2D context (CPU fallback path). */
    private ensureCtx;
    /** Enable or disable the debug overlay. */
    get debugOverlay(): boolean;
    set debugOverlay(enabled: boolean);
    /** Enable or disable scroll blit. */
    get scrollBlit(): boolean;
    set scrollBlit(enabled: boolean);
    /** Enable or disable the engine's fast-scroll path. */
    get fastScrollEnabled(): boolean;
    set fastScrollEnabled(enabled: boolean);
    get animationEnabled(): boolean;
    /** Enable or disable layout animation. */
    set animationEnabled(enabled: boolean);
    get animationDurationMs(): number;
    set animationDurationMs(durationMs: number);
    get textLayoutCacheCap(): number;
    /** Set the text layout cache capacity. */
    set textLayoutCacheCap(cap: number);
    getVisibleRowRange(): {
        first: number;
        last: number;
    };
    hasCell(row: number, col: number): boolean;
    clearCellRange(row1: number, col1: number, row2: number, col2: number): void;
    /**
     * Pull queued GridEvent protobuf payloads from WASM EventStream.
     *
     * Returns raw `GridEvent` protobuf bytes. Callers can decode with their
     * generated protobuf runtime. Raw-stream consumers that need cancellation
     * must first call `setEventDecisionEnabled(true)` and then respond with
     * `sendRawEventDecision(...)` or `sendEventDecision(...)`. Send
     * `cancel=false` for unhandled cancelable events; send `cancel=true` only
     * when application code explicitly vetoes the action.
     */
    drainEventStreamRaw(maxEvents?: number): Uint8Array[];
    private hasCancelableEventListeners;
    private decisionChannelRequested;
    /** Enable EventDecision support for raw `drainEventStreamRaw()` consumers. */
    setEventDecisionEnabled(enabled: boolean): void;
    private syncCancelableEventDecisionSupport;
    private syncCustomCompareCallback;
    /** Send a decision for a cancelable raw event by event id. */
    sendEventDecision(eventId: bigint, cancel: boolean): boolean;
    /** Decode a raw `GridEvent` frame and send its cancel decision. */
    sendRawEventDecision(rawEvent: Uint8Array, cancel: boolean): boolean;
    private dispatchCancelableGridEvent;
    /** Flush pending cancelable event decisions queued by low-level WASM/service calls. */
    flushPendingEventDecisions(): boolean;
    /**
     * Drain queued grid events synchronously and dispatch to listeners. Call
     * this after programmatic state changes if you want listeners to fire
     * before the next animation frame; otherwise the pump fires within ~0.5ms
     * of the next task tick on its own.
     */
    flushEvents(): void;
    /** Request a drain on the next task tick. Coalesces. */
    scheduleEventFlush(): void;
    private flushEventQueues;
    private dispatchRawGridEvents;
    private flushCancelableEventDecisions;
    /** Proto clear API (scope/region enums). */
    clear(scope?: number, region?: number): void;
    sort(order: number, col: number, type?: number): void;
    sortMulti(cols: number[], orders: number[], types?: number[]): void;
    subtotal(aggregate: number, groupOnCol: number, aggregateCol: number, caption?: string, background?: number, foreground?: number, addOutline?: boolean, font?: VolvoxGridFont): VolvoxGridSubtotalResult;
    addSubtotals(amountCols: readonly number[], levels: readonly VolvoxGridSubtotalLevel[], options?: VolvoxGridAddSubtotalsOptions): void;
    private mergeSubtotalLevelZero;
    /** Expand/collapse tree rows to [level]. */
    outline(level: number): void;
    /** Auto-size a range of columns. */
    autoSize(colFrom?: number, colTo?: number, equal?: boolean, maxWidth?: number): void;
    /** Find a row by plain text in [col]. Returns -1 if not found. */
    findRowByText(text: string, options: {
        col: number;
        startRow?: number;
        caseSensitive?: boolean;
        fullMatch?: boolean;
    }): number;
    /** Find a row by regex in [col]. Returns -1 if not found. */
    findRowByRegex(pattern: string, options: {
        col: number;
        startRow?: number;
    }): number;
    /** Query node metadata for [row]. */
    getNode(row: number, relation?: number): VolvoxGridNodeInfo | null;
    /** Aggregate over a rectangular range. */
    aggregate(type: number, row1: number, col1: number, row2: number, col2: number): number;
    /** Return merged range containing [row, col]. */
    getMergedRange(row: number, col: number): VolvoxGridCellRange | null;
    setAutoSizeMouse(enabled: boolean): void;
    getAutoSizeMouse(): boolean;
    autoResizeCol(col: number): void;
    autoResizeRow(row: number): void;
    /** Pipe-delimited column setup: "<Name|>Amount;120|^Status" */
    setFormatString(fmt: string): void;
    getFormatString(): string;
    applyFormatString(): void;
    /** Display format for a column (e.g. "$#,##0.00", "0.0%") */
    setColFormat(col: number, format: string): void;
    getColFormat(col: number): string;
    setColProgressColor(col: number, color: number): void;
    setColFloodColor(col: number, color: number): void;
    /** Global edit mask (e.g. "(###) ###-####") */
    setEditMask(mask: string): void;
    getEditMask(): string;
    /** Per-column edit mask */
    setColEditMask(col: number, mask: string): void;
    /** Insert a row with tab-delimited text. atRow = -1 to append at end. */
    addItem(text: string, atRow?: number): void;
    /** Remove a row by grid row index. */
    removeItem(row: number): void;
    /** Get display text (applies ColFormat and combo translation). */
    getDisplayText(row: number, col: number): string;
    invalidate(): void;
    /** Immediately sync and focus the host editor input.
     *  Call after starting editing programmatically so the browser IME
     *  can target the <input> element without waiting for the next frame. */
    focusEditInput(): void;
    /** Suppress internal dirty-marking during bulk cell updates.
     *  Call setRedraw(false) before a batch, then setRedraw(true) + invalidate() after. */
    setRedraw(on: boolean): void;
    /** Render layer visibility bitmask. -1 means all layers enabled. */
    get renderLayerMask(): number;
    set renderLayerMask(mask: number);
    /** Check whether a render layer is enabled in the current mask. */
    isRenderLayerEnabled(layer: RenderLayerBit | number): boolean;
    /** Enable or disable one render layer while preserving the other bits. */
    setRenderLayerEnabled(layer: RenderLayerBit | number, enabled: boolean): void;
    get scrollBars(): number;
    /** Set scrollbar visibility: 0=none, 1=horizontal, 2=vertical, 3=both */
    set scrollBars(mode: number);
    /** Force a full engine repaint. */
    refresh(): void;
    /** Force synchronous layout calculation. */
    ensureLayout(): void;
    /** Notify engine that viewport dimensions changed. */
    resizeViewport(width: number, height: number): void;
    /** Load a built-in mutating demo by name ("stress"). */
    loadDemo(demo: string): void;
    /** Fetch raw embedded demo data bytes. */
    getDemoData(demo: string): Uint8Array;
    /** Archive snapshots (0=save, 1=load, 2=delete, 3=list). */
    archive(action: number, name?: string, data?: Uint8Array): Uint8Array;
    /**
     * Render the grid to a sequence of printable page images (PNG).
     * Returns a promise that resolves to a list of pages.
     */
    printGrid(options: {
        orientation?: number;
        marginLeft?: number;
        marginTop?: number;
        marginRight?: number;
        marginBottom?: number;
        header?: string;
        footer?: string;
        showPageNumbers?: boolean;
    }): Promise<{
        pageNumber: number;
        imageData: Uint8Array;
        width: number;
        height: number;
    }[]>;
    /**
     * Switch this view to another existing engine-side grid ID.
     *
     * This keeps the same canvas/render loop/event wiring and only changes
     * which native grid instance receives input and render calls.
     */
    useGrid(id: number): void;
    destroy(): void;
    private syncSize;
    private applyCanvasSize;
    private commitPendingSize;
    private matchOverlayCanvasPosition;
    private syncPresentCanvasPosition;
    private invalidateRenderCache;
    private getRenderImageData;
    private getDirtyRect;
    private render;
    private dispatchEditorSessionEvent;
    private renderViaRenderSession;
    private startRenderLoop;
    private resetTouchState;
    private clearLastTouchTap;
    private rememberTouchTap;
    private hitTestTouchCell;
    private isTouchDoubleTap;
    private ensureZoomBaseForGrid;
    private refreshZoomBaseForGrid;
    private applyZoomStep;
    private applyZoomScaleToCurrentGrid;
    private touchPinchMetrics;
    private beginPinchGesture;
    private updatePinchGesture;
    /** When canvas gets focus, redirect to imeProxy so OS IME toggle works. */
    private onCanvasFocusForIme;
    private dispatchKeyboardEventToCanvas;
    private focusCanvas;
    private onPointerDown;
    private onPointerMove;
    private onPointerUp;
    private onPointerCancel;
    private onWheel;
    private onContextMenu;
    private readonly schedulePumpFromDom;
    private setupEventListeners;
    private removeEventListeners;
    private modifierBits;
    private initHostEditors;
    private removeHostEditors;
    private parkIdleImeProxy;
    private restoreTextAreaEditorStyle;
    private syncHostEditor;
    private currentEditorPresentation;
    private inputEditorElement;
    private activeInputEditorElement;
    private syncInputEditor;
    private syncSelectEditor;
    private showInputEditor;
    private showSelectEditor;
    private hideHostEditors;
    /** Focus imeProxy if available, otherwise canvas. */
    private focusImeProxyOrCanvas;
    private getEditUiMode;
    private getEditTextAlign;
    private commitEditFromHost;
    private cancelEditFromHost;
    private syncInputSelectionFromEngine;
    private pushInputValueToEngine;
    private insertInputEditorText;
    private scrollTextAreaCaretIntoView;
    private readComboItems;
    private populateDataList;
    private populateSelect;
    private positionEditor;
}
//# sourceMappingURL=volvoxgrid.d.ts.map