Add a column to a table at the specified index

declare function addColumn(table: Table, atIndex: number, position?: 'before' | 'after'): Table;

Add a row to a table at the specified index

declare function addRow(table: Table, atIndex: number, position?: 'before' | 'after'): Table;

Alignment dropdown component — single button with popover panel

declare function AlignmentButtons(input: AlignmentButtonsProps): react_jsx_runtime.JSX.Element;

Calculate scaled dimensions to fit within bounds

declare function calculateFitDimensions(originalWidth: number, originalHeight: number, maxWidth: number, maxHeight: number): {
    width: number;
    height: number;
};

Clamp TableConfig to valid range

declare function clampTableConfig(config: TableConfig, maxRows?: number, maxColumns?: number): TableConfig;

declare function ColorPicker(input: ColorPickerProps): react_jsx_runtime.JSX.Element;

Create a document change tracker Simple utility for external change tracking

declare function createChangeTracker(): {
    markChanged: () => void;
    markSaved: () => void;
    getState: () => {
        changeCount: number;
        lastSaveTime: Date | null;
        hasUnsavedChanges: boolean;
    };
    reset: () => void;
};

Create a default TableConfig

declare function createDefaultTableConfig(rows?: number, columns?: number): TableConfig;

Create an error response

declare function createErrorResponse(error: string): AgentResponse;

Create a mock response for testing

declare function createMockResponse(newText: string, warnings?: string[]): AgentResponse;

Create a table context from a table and selection

declare function createTableContext(table: Table, selection: TableSelection): TableContext;

Create a toolbar item

declare function createToolbarItem(id: string, content: ReactNode, options?: Partial<Omit<ToolbarItem, 'id' | 'content'>>): ToolbarItem;

Create toolbar items from an array of configs

declare function createToolbarItems(configs: Array<{
    id: string;
    content: ReactNode;
    priority?: ToolbarItemPriority;
    minWidth?: number;
    alwaysVisible?: boolean;
    separatorAfter?: boolean;
    group?: string;
}>): ToolbarItem[];

Convert data URL to Blob

declare function dataUrlToBlob(dataUrl: string): Blob;

Create a delay promise for testing loading states

declare function delay(ms: number): Promise<void>;

Delete a column from a table

declare function deleteColumn(table: Table, columnIndex: number): Table;

Delete a row from a table

declare function deleteRow(table: Table, rowIndex: number): Table;

FindReplaceDialog component - Modal for finding and replacing text

declare function FindReplaceDialog(input: FindReplaceDialogProps): React__default.ReactElement | null;

declare function FontPicker(input: FontPickerProps): react_jsx_runtime.JSX.Element;

declare function FontSizePicker(input: FontSizePickerProps): react_jsx_runtime.JSX.Element;

Format file size for display

declare function formatFileSize(bytes: number): string;

Format page range for display

declare function formatPageRange(range: {
    start: number;
    end: number;
} | null, totalPages: number): string;

Format key combination for current platform

declare function formatKeys(keys: string): string;

Format table dimensions for display

declare function formatTableDimensions(config: TableConfig): string;

Get action shortcuts

declare function getActionShortcut(action: AIAction): string | undefined;

Get all available actions

declare function getAllActions(): AIAction[];

Get all categories

declare function getAllCategories(): ShortcutCategory[];

Get all indicator positions

declare function getAllPositions(): IndicatorPosition[];

Get all indicator variants

declare function getAllVariants(): IndicatorVariant[];

Get all loading sizes

declare function getAllLoadingSizes(): LoadingSize[];

Get all loading variants

declare function getAllLoadingVariants(): LoadingVariant[];

Get all paste option definitions

declare function getAllPasteOptions(): PasteOptionDef[];

Get category label translation key

declare function getCategoryLabel(category: ShortcutCategory): string;

Get cell at specific row and column index

declare function getCellAt(table: Table, rowIndex: number, columnIndex: number): TableCell | null;

Get column count from a table

declare function getColumnCount(table: Table): number;

Get common/frequently used shortcuts

declare function getCommonShortcuts(): KeyboardShortcut[];

Get default actions for selection

declare function getDefaultActions(): AIAction[];

Get default paste option

declare function getDefaultPasteOption(): PasteOption;

Get default print options

declare function getDefaultPrintOptions(): PrintOptions;

Get all default shortcuts

declare function getDefaultShortcuts(): KeyboardShortcut[];

Get default menu item definitions (untranslated, use translation keys)

declare function getDefaultTextContextMenuItems(): TextContextMenuItem[];

Get accept string for file input

declare function getImageAcceptString(): string;

Get image dimensions from a data URL

declare function getImageDimensions(src: string): Promise<{
    width: number;
    height: number;
}>;

Get loading variant label

declare function getLoadingVariantLabel(variant: LoadingVariant): string;

declare function getMarginInUnits(marginTwips: number, unit: 'inch' | 'cm'): string;

Get paste option definition by id

declare function getPasteOption(id: PasteOption): PasteOptionDef | undefined;

Get recommended priority for common toolbar items

declare function getRecommendedPriority(itemType: string): ToolbarItemPriority;

declare function getRulerDimensions(sectionProps?: SectionProperties | null, zoom?: number): {
    width: number;
    leftMargin: number;
    rightMargin: number;
    contentWidth: number;
};

Get shortcuts by category

declare function getShortcutsByCategory(category: ShortcutCategory): KeyboardShortcut[];

Get supported image extensions

declare function getSupportedImageExtensions(): string[];

Get all symbol categories

declare function getSymbolCategories(): SymbolCategory[];

Get symbols by category name

declare function getSymbolsByCategory(categoryName: string): string[];

Get symbol Unicode info

declare function getSymbolInfo(symbol: string): {
    character: string;
    codePoint: string;
    decimal: number;
    hex: string;
};

Get common table presets

declare function getTablePresets(): {
    label: string;
    config: TableConfig;
}[];

declare function getTableSplitCellDialogConfig(table: Table, rowIndex: number, columnIndex: number): TableSplitConfig | null;

Get action label

declare function getTextActionLabel(action: TextContextAction): string;

Get action shortcut

declare function getTextActionShortcut(action: TextContextAction): string;

Get indicator variant label

declare function getVariantLabel(variant: IndicatorVariant): string;

declare function HorizontalRuler(input: HorizontalRulerProps): React__default.ReactElement;

HyperlinkDialog component - Modal for inserting/editing hyperlinks

declare function HyperlinkDialog(input: HyperlinkDialogProps): React__default.ReactElement | null;

InsertImageDialog - Modal for inserting images with preview and sizing

declare function InsertImageDialog(input: InsertImageDialogProps): React__default.ReactElement | null;

InsertSymbolDialog - Modal for inserting special characters

declare function InsertSymbolDialog(input: InsertSymbolDialogProps): React__default.ReactElement | null;

InsertTableDialog - Modal for inserting tables with visual grid selector

declare function InsertTableDialog(input: InsertTableDialogProps): React__default.ReactElement | null;

Check if action is available for selection

declare function isActionAvailable(_action: AIAction, selectedText: string, _selectionContext?: SelectionContext): boolean;

Check if paste special shortcut

declare function isPasteSpecialShortcut(event: KeyboardEvent): boolean;

Check if browser supports good print functionality

declare function isPrintSupported(): boolean;

Check if action is available

declare function isTextActionAvailable(action: TextContextAction, hasSelection: boolean, isEditable: boolean): boolean;

Check if a file is a valid image

declare function isValidImageFile(file: File): boolean;

Validate TableConfig

declare function isValidTableConfig(config: TableConfig, maxRows?: number, maxColumns?: number): boolean;

declare function LineSpacingPicker(input: LineSpacingPickerProps): react_jsx_runtime.JSX.Element;

List buttons component for bullet/numbered list controls

declare function ListButtons(input: ListButtonsProps): react_jsx_runtime.JSX.Element;

Merge cells in a selection

declare function mergeCells(table: Table, selection: TableSelection): Table;

Create print-optimized document view in a new window

declare function openPrintWindow(title: string | undefined, content: string): Window | null;

declare function parseMarginFromUnits(value: string, unit: 'inch' | 'cm'): number | null;

Create page range from string (e.g., "1-5", "3", "1,3,5")

declare function parsePageRange(input: string, maxPages: number): {
    start: number;
    end: number;
} | null;

declare function positionToMargin(positionPx: number, side: 'left' | 'right', pageWidthPx: number, zoom: number): number;

PrintButton - Standalone print button for toolbar

declare function PrintButton(input: PrintButtonProps): React__default.ReactElement;

PrintStyles - Injects print-specific CSS

declare function PrintStyles(): React__default.ReactElement;

Search symbols by query

declare function searchSymbols(query: string): string[];

Backward-compatible helper for callers that still use the older merged-cell split behavior directly.

User-facing Split cell is now dialog-driven. For document-model tables, use `getTableSplitCellDialogConfig()` and `splitTableCell()` instead.

declare function splitCell(table: Table, rowIndex: number, columnIndex: number): Table;

declare function splitTableCell(table: Table, rowIndex: number, columnIndex: number, rows: number, cols: number): Table;

declare function StylePicker(input: StylePickerProps): react_jsx_runtime.JSX.Element;

Get symbol from Unicode code point string

declare function symbolFromCodePoint(codePointStr: string): string | null;

declare function TableBorderColorPicker(input: TableBorderColorPickerProps): react_jsx_runtime.JSX.Element;

declare function TableBorderPicker(input: TableBorderPickerProps): react_jsx_runtime.JSX.Element;

declare function TableBorderWidthPicker(input: TableBorderWidthPickerProps): react_jsx_runtime.JSX.Element;

declare function TableCellFillPicker(input: TableCellFillPickerProps): react_jsx_runtime.JSX.Element;

declare function TableInsertButtons(input: TableInsertButtonsProps): react_jsx_runtime.JSX.Element;

declare function TableMergeButton(input: TableMergeButtonProps): react_jsx_runtime.JSX.Element;

declare function TableMoreDropdown(input: TableMoreDropdownProps): react_jsx_runtime.JSX.Element;

TableToolbar - Shows table manipulation controls when cursor is in a table

declare function TableToolbar(input: TableToolbarProps): React__default.ReactElement | null;

Icon-based formatting toolbar — undo/redo, zoom, styles, fonts, bold/italic/underline, colors, alignment, lists, table/image context, clear formatting.

declare function Toolbar(explicitProps: ToolbarProps): react_jsx_runtime.JSX.Element;

Individual toolbar button with shadcn styling

declare function ToolbarButton(input: ToolbarButtonProps): react_jsx_runtime.JSX.Element;

Toolbar button group with modern styling

declare function ToolbarGroup$1(input: ToolbarGroupProps$1): react_jsx_runtime.JSX.Element;

Toolbar separator

declare function ToolbarSeparator(): react_jsx_runtime.JSX.Element;

Trigger browser print dialog for the current document

declare function triggerPrint(): void;

Hook to manage context menu state

declare function useContextMenu(): {
    isOpen: boolean;
    position: {
        x: number;
        y: number;
    };
    selectedText: string;
    selectionContext: SelectionContext | undefined;
    openMenu: (e: React__default.MouseEvent | MouseEvent, text: string, context?: SelectionContext) => void;
    closeMenu: () => void;
};

Hook for managing find/replace dialog state

declare function useFindReplace(hookOptions?: FindReplaceOptions): UseFindReplaceReturn;

Hook for managing Hyperlink dialog state

declare function useHyperlinkDialog(): UseHyperlinkDialogReturn;

Hook for managing Insert Image dialog state

declare function useInsertImageDialog(): {
    isOpen: boolean;
    open: () => void;
    close: () => void;
    toggle: () => void;
};

Hook for managing Insert Symbol dialog state with recent symbols

declare function useInsertSymbolDialog(maxRecent?: number): {
    isOpen: boolean;
    recentSymbols: string[];
    open: () => void;
    close: () => void;
    toggle: () => void;
    addRecent: (symbol: string) => void;
};

Hook for managing Insert Table dialog state

declare function useInsertTableDialog(): {
    isOpen: boolean;
    open: () => void;
    close: () => void;
    toggle: () => void;
};

Hook to manage keyboard shortcuts dialog

declare function useKeyboardShortcutsDialog(options?: UseKeyboardShortcutsDialogOptions): UseKeyboardShortcutsDialogReturn;

Hook to manage loading states

declare function useLoading(options?: UseLoadingOptions): UseLoadingReturn;

Hook to manage multiple concurrent loading operations

declare function useLoadingOperations(): {
    operations: LoadingOperation[];
    isAnyLoading: boolean;
    startOperation: (id: string, message?: string) => void;
    updateOperation: (id: string, updates: Partial<LoadingOperation>) => void;
    endOperation: (id: string) => void;
    getOperation: (id: string) => LoadingOperation | undefined;
};

Hook to manage paste special dialog

declare function usePasteSpecial(options?: UsePasteSpecialOptions): UsePasteSpecialReturn;

Hook to manage response preview state

declare function useResponsePreview(): {
    state: ResponsePreviewState;
    showPreview: (originalText: string, action: AIAction, position?: {
        x: number;
        y: number;
    }) => void;
    setResponse: (response: AgentResponse) => void;
    setError: (error: string) => void;
    hidePreview: () => void;
};

Hook to calculate which items fit in the toolbar

declare function useResponsiveToolbar(options: UseResponsiveToolbarOptions): UseResponsiveToolbarReturn;

Hook to manage text context menu state

declare function useTextContextMenu(options?: UseTextContextMenuOptions): UseTextContextMenuReturn;

Hook to track unsaved changes in a document

declare function useUnsavedChanges(options?: UseUnsavedChangesOptions): UseUnsavedChangesReturn;

declare function ZoomControl(input: ZoomControlProps): react_jsx_runtime.JSX.Element;

Props for the AlignmentButtons component

interface AlignmentButtonsProps

interface ColorPickerProps

Context menu props

interface ContextMenuProps

Keyboard shortcut definition

interface KeyboardShortcut

interface DocumentNameProps

Props for the EditorToolbar compound component. Extends ToolbarProps with title bar-specific fields.

interface EditorToolbarProps extends ToolbarProps

Props for the FindReplaceDialog component

interface FindReplaceDialogProps

Options for the useFindReplace hook

interface FindReplaceOptions

State for the find/replace hook

interface FindReplaceState

interface FontPickerProps

Font Size Picker Component (Google Docs Style)

A font size control with minus/plus buttons and editable input. Features: - Minus button to decrease font size - Plus button to increase font size - Editable input for custom sizes - Click input to show dropdown with preset sizes

interface FontSizePickerProps

HorizontalRuler Component — Google Docs style

3 handles only: - Left side: first-line indent (▼ down at top) + left indent (▲ up at bottom) - Right side: right indent (▼ down at top)

Margins shown as gray zones on the ruler edges. Drag the boundary between gray/white to adjust page margins. Drag tooltip shows value during any drag.

interface HorizontalRulerProps

Hyperlink data structure for dialog

interface HyperlinkData

Props for the HyperlinkDialog component

interface HyperlinkDialogProps

Image data for insertion

interface ImageData

Props for InsertImageDialog

interface InsertImageDialogProps

Props for InsertSymbolDialog

interface InsertSymbolDialogProps

Props for InsertTableDialog

interface InsertTableDialogProps

Dialog props

interface KeyboardShortcutsDialogProps

interface LineSpacingOption

interface LineSpacingPickerProps

Props for the ListButtons component

interface ListButtonsProps

Loading indicator props

interface LoadingIndicatorProps

Loading operation state

interface LoadingOperation

interface LogoProps

Paste special dialog props

interface PasteSpecialDialogProps

PrintButton props

interface PrintButtonProps

Print options

interface PrintOptions

Response preview props

interface ResponsePreviewProps

State for response preview

interface ResponsePreviewState

interface ToolbarGroupProps

Props for ResponsiveToolbar component

interface ResponsiveToolbarProps

interface StyleOption

interface StylePickerProps

Symbol category

interface SymbolCategory

interface TableBorderColorPickerProps

interface TableBorderPickerProps

interface TableBorderWidthPickerProps

interface TableCellFillPickerProps

Table configuration for insertion

interface TableConfig

Context for table operations

interface TableContext

interface TableInsertButtonsProps

interface TableMergeButtonProps

interface TableMoreDropdownProps

Selection within a table

interface TableSelection

interface TableSplitConfig

Props for TableToolbar component

interface TableToolbarProps

Menu item configuration

interface TextContextMenuItem

Context menu props

interface TextContextMenuProps

interface TitleBarProps

interface TitleBarRightProps

Toolbar item configuration

interface ToolbarItem

Props for the Toolbar (formatting rail) component

interface ToolbarProps

Unsaved indicator props

interface UnsavedIndicatorProps

Return type for the useFindReplace hook

interface UseFindReplaceReturn

Hook options

interface UseKeyboardShortcutsDialogOptions

Hook return value

interface UseKeyboardShortcutsDialogReturn

Options for useLoading hook

interface UseLoadingOptions

Return value of useLoading hook

interface UseLoadingReturn

Options for usePasteSpecial hook

interface UsePasteSpecialOptions

Hook return value for paste special

interface UsePasteSpecialReturn

Options for useResponsiveToolbar hook

interface UseResponsiveToolbarOptions

Return value of useResponsiveToolbar hook

interface UseResponsiveToolbarReturn

Hook options for text context menu

interface UseTextContextMenuOptions

Hook return value

interface UseTextContextMenuReturn

Hook options for tracking unsaved changes

interface UseUnsavedChangesOptions

Hook return value

interface UseUnsavedChangesReturn

interface ZoomControlProps

type ColorPickerMode = 'text' | 'highlight' | 'border';

Indicator position type

type IndicatorPosition = 'inline' | 'absolute-top-right' | 'absolute-top-left';

Indicator variant type

type IndicatorVariant = 'dot' | 'badge' | 'text' | 'icon';

Loading indicator size

type LoadingSize = 'small' | 'medium' | 'large';

Loading indicator variant

type LoadingVariant = 'spinner' | 'dots' | 'bar' | 'pulse' | 'progress';

Paste option type

type PasteOption = 'formatted' | 'plainText';

Shortcut category

type ShortcutCategory = 'editing' | 'formatting' | 'navigation' | 'clipboard' | 'selection' | 'view' | 'file' | 'other';

Table editing action types

type TableAction = 'addRowAbove' | 'addRowBelow' | 'addColumnLeft' | 'addColumnRight' | 'deleteRow' | 'deleteColumn' | 'mergeCells' | 'splitCell' | 'deleteTable' | 'selectTable' | 'selectRow' | 'selectColumn' | 'borderAll' | 'borderOutside' | 'borderInside' | 'borderNone' | 'borderTop' | 'borderBottom' | 'borderLeft' | 'borderRight' | {
    type: 'cellFillColor';
    color: string | null;
} | {
    type: 'borderColor';
    color: string;
} | {
    type: 'borderWidth';
    size: number;
} | {
    type: 'cellBorder';
    side: 'top' | 'bottom' | 'left' | 'right' | 'all';
    style: string;
    size: number;
    color: string;
} | {
    type: 'cellVerticalAlign';
    align: 'top' | 'center' | 'bottom';
} | {
    type: 'cellMargins';
    margins: {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    };
} | {
    type: 'cellTextDirection';
    direction: string | null;
} | {
    type: 'toggleNoWrap';
} | {
    type: 'rowHeight';
    height: number | null;
    rule?: 'auto' | 'atLeast' | 'exact';
} | {
    type: 'toggleHeaderRow';
} | {
    type: 'distributeColumns';
} | {
    type: 'autoFitContents';
} | {
    type: 'tableProperties';
    props: {
        width?: number | null;
        widthType?: string | null;
        justification?: 'left' | 'center' | 'right' | null;
    };
} | {
    type: 'openTableProperties';
} | {
    type: 'applyTableStyle';
    styleId: string;
};

Context menu action types

type TextContextAction = 'cut' | 'copy' | 'paste' | 'pasteAsPlainText' | 'selectAll' | 'delete' | 'separator' | 'addRowAbove' | 'addRowBelow' | 'deleteRow' | 'addColumnLeft' | 'addColumnRight' | 'deleteColumn' | 'mergeCells' | 'splitCell' | 'addComment';

Priority level for toolbar items Lower numbers = higher priority (shown first, hidden last)

type ToolbarItemPriority = 1 | 2 | 3 | 4 | 5;

ContextMenu: React__default.FC<ContextMenuProps>

EditorToolbar: EditorToolbarComponent

KeyboardShortcutsDialog: React__default.FC<KeyboardShortcutsDialogProps>

LoadingIndicator: React__default.FC<LoadingIndicatorProps>

PasteSpecialDialog: React__default.FC<PasteSpecialDialogProps>

ResponsePreview: React__default.FC<ResponsePreviewProps>

ResponsiveToolbar: React__default.FC<ResponsiveToolbarProps>

ToolbarGroup: React__default.FC<ToolbarGroupProps>

Default symbol categories

SYMBOL_CATEGORIES: SymbolCategory[]

TextContextMenu: React__default.FC<TextContextMenuProps>

UnsavedIndicator: React__default.FC<UnsavedIndicatorProps>