## API Report File for "@eigenpal/docx-editor-react"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { AgentResponse } from '@eigenpal/docx-editor-core/types/agentApi';
import { AIAction } from '@eigenpal/docx-editor-core/types/agentApi';
import { ColorValue } from '@eigenpal/docx-editor-core/types/document';
import { createDefaultFindOptions } from '@eigenpal/docx-editor-core/utils/findReplace';
import { createDefaultListState } from '@eigenpal/docx-editor-core/utils/listState';
import { createSearchPattern } from '@eigenpal/docx-editor-core/utils/findReplace';
import { CSSProperties } from 'react';
import { Document as Document_2 } from '@eigenpal/docx-editor-core/types/document';
import { escapeRegexString } from '@eigenpal/docx-editor-core/utils/findReplace';
import { findAllMatches } from '@eigenpal/docx-editor-core/utils/findReplace';
import { findInDocument } from '@eigenpal/docx-editor-core/utils/findReplace';
import { findInParagraph } from '@eigenpal/docx-editor-core/utils/findReplace';
import { FindMatch } from '@eigenpal/docx-editor-core/utils/findReplace';
import { FindOptions } from '@eigenpal/docx-editor-core/utils/findReplace';
import { FindResult } from '@eigenpal/docx-editor-core/utils/findReplace';
import { FontOption } from '@eigenpal/docx-editor-core/utils/fontOptions';
import { getDefaultHighlightOptions } from '@eigenpal/docx-editor-core/utils/findReplace';
import { getMatchCountText } from '@eigenpal/docx-editor-core/utils/findReplace';
import { HighlightOptions } from '@eigenpal/docx-editor-core/utils/findReplace';
import { isEmptySearch } from '@eigenpal/docx-editor-core/utils/findReplace';
import { ListState } from '@eigenpal/docx-editor-core/utils/listState';
import { ParagraphAlignment } from '@eigenpal/docx-editor-core/types/document';
import { ParsedClipboardContent } from '@eigenpal/docx-editor-core/utils';
import * as React$1 from 'react';
import React__default from 'react';
import { ReactNode } from 'react';
import { replaceAllInContent } from '@eigenpal/docx-editor-core/utils/findReplace';
import { replaceFirstInContent } from '@eigenpal/docx-editor-core/utils/findReplace';
import { scrollToMatch } from '@eigenpal/docx-editor-core/utils/findReplace';
import { SectionProperties } from '@eigenpal/docx-editor-core/types/document';
import { SelectionContext } from '@eigenpal/docx-editor-core/types/agentApi';
import { Style } from '@eigenpal/docx-editor-core/types/document';
import { StyleType } from '@eigenpal/docx-editor-core/types/document';
import { Table } from '@eigenpal/docx-editor-core/types/document';
import { TableCell } from '@eigenpal/docx-editor-core/types/document';
import { TabStop } from '@eigenpal/docx-editor-core/types/document';
import { Theme } from '@eigenpal/docx-editor-core/types/document';
import { TranslationKey } from '@eigenpal/docx-editor-i18n';

// @public
export function addColumn(table: Table, atIndex: number, position?: 'before' | 'after'): Table;

// @public
export function addRow(table: Table, atIndex: number, position?: 'before' | 'after'): Table;

// @public
export function AlignmentButtons(input: AlignmentButtonsProps): React__default.JSX.Element;

// @public
export interface AlignmentButtonsProps {
    className?: string;
    compact?: boolean;
    disabled?: boolean;
    onChange?: (alignment: ParagraphAlignment) => void;
    showLabels?: boolean;
    style?: CSSProperties;
    value?: ParagraphAlignment;
}

// @public
export function calculateFitDimensions(originalWidth: number, originalHeight: number, maxWidth: number, maxHeight: number): {
    width: number;
    height: number;
};

// @public
export function clampTableConfig(config: TableConfig, maxRows?: number, maxColumns?: number): TableConfig;

// @public (undocumented)
export function ColorPicker(input: ColorPickerProps): React$1.JSX.Element;

// @public (undocumented)
export type ColorPickerMode = 'text' | 'highlight' | 'border';

// @public (undocumented)
export interface ColorPickerProps {
    autoLabel?: string;
    // (undocumented)
    className?: string;
    defaultColor?: ColorValue | string;
    // (undocumented)
    disabled?: boolean;
    icon?: string;
    // (undocumented)
    mode: ColorPickerMode;
    // (undocumented)
    onChange?: (color: ColorValue | string) => void;
    splitButton?: boolean;
    // (undocumented)
    style?: CSSProperties;
    // (undocumented)
    theme?: Theme | null;
    // (undocumented)
    title?: string;
    // (undocumented)
    value?: ColorValue | string;
}

// @public (undocumented)
export const ContextMenu: React__default.FC<ContextMenuProps>;

// @public
export interface ContextMenuProps {
    actions?: AIAction[];
    className?: string;
    isOpen: boolean;
    onAction: (action: AIAction, customPrompt?: string) => void;
    onClose: () => void;
    position: {
        x: number;
        y: number;
    };
    selectedText: string;
    selectionContext?: SelectionContext;
    showCustomPrompt?: boolean;
}

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

export { createDefaultFindOptions }

export { createDefaultListState }

// @public
export function createDefaultTableConfig(rows?: number, columns?: number): TableConfig;

// @public
export function createErrorResponse(error: string): AgentResponse;

// @public
export function createMockResponse(newText: string, warnings?: string[]): AgentResponse;

export { createSearchPattern }

// @public
export function createTableContext(table: Table, selection: TableSelection): TableContext;

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

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

// @public
export function dataUrlToBlob(dataUrl: string): Blob;

// @public
export function delay(ms: number): Promise<void>;

// @public
export function deleteColumn(table: Table, columnIndex: number): Table;

// @public
export function deleteRow(table: Table, rowIndex: number): Table;

// @public
export interface DialogKeyboardShortcut {
    altKeys?: string;
    category: ShortcutCategory;
    common?: boolean;
    description: string;
    descriptionKey?: TranslationKey;
    id: string;
    keys: string;
    name: string;
    nameKey?: TranslationKey;
}

// @public (undocumented)
export interface DocumentNameProps {
    // (undocumented)
    editable?: boolean;
    // (undocumented)
    onChange?: (value: string) => void;
    // (undocumented)
    placeholder?: string;
    // (undocumented)
    value: string;
}

// @public (undocumented)
export const EditorToolbar: EditorToolbarComponent;

// @public
export interface EditorToolbarProps extends ToolbarProps {
}

export { escapeRegexString }

export { findAllMatches }

export { findInDocument }

export { findInParagraph }

export { FindMatch }

export { FindOptions }

// @public
export function FindReplaceDialog(input: FindReplaceDialogProps): React__default.ReactElement | null;

// @public
export interface FindReplaceDialogProps {
    className?: string;
    currentResult?: FindResult | null;
    initialSearchText?: string;
    isOpen: boolean;
    onClearHighlights?: () => void;
    onClose: () => void;
    onFind: (searchText: string, options: FindOptions) => FindResult | null;
    onFindNext: () => FindMatch | null;
    onFindPrevious: () => FindMatch | null;
    onHighlightMatches?: (matches: FindMatch[]) => void;
    onReplace: (replaceText: string) => boolean;
    onReplaceAll: (searchText: string, replaceText: string, options: FindOptions) => number;
    replaceMode?: boolean;
    style?: CSSProperties;
}

// @public
export interface FindReplaceOptions {
    initialReplaceMode?: boolean;
    onCurrentMatchChange?: (match: FindMatch | null, index: number) => void;
    onMatchesChange?: (matches: FindMatch[]) => void;
}

// @public
export interface FindReplaceState {
    currentIndex: number;
    isOpen: boolean;
    matches: FindMatch[];
    options: FindOptions;
    replaceMode: boolean;
    replaceText: string;
    searchText: string;
}

export { FindResult }

export { FontOption }

// @public (undocumented)
export function FontPicker(input: FontPickerProps): React$1.JSX.Element;

// @public
export interface FontPickerProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    fonts?: FontOption[];
    // (undocumented)
    onChange?: (fontFamily: string) => void;
    // (undocumented)
    placeholder?: string;
    // (undocumented)
    showPreview?: boolean;
    // (undocumented)
    value?: string;
    // (undocumented)
    width?: number | string;
}

// @public (undocumented)
export function FontSizePicker(input: FontSizePickerProps): React$1.JSX.Element;

// @public
export interface FontSizePickerProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    maxSize?: number;
    // (undocumented)
    minSize?: number;
    // (undocumented)
    onChange?: (size: number) => void;
    // (undocumented)
    placeholder?: string;
    // (undocumented)
    sizes?: number[];
    // (undocumented)
    value?: number;
    // (undocumented)
    width?: number | string;
}

// @public
export function formatFileSize(bytes: number): string;

// @public
export function formatPrintPageRange(range: {
    start: number;
    end: number;
} | null, totalPages: number): string;

// @public
export function formatShortcutKeys(keys: string): string;

// @public
export function formatTableDimensions(config: TableConfig): string;

// @public
export function getActionShortcut(action: AIAction): string | undefined;

// @public
export function getAllActions(): AIAction[];

// @public
export function getAllCategories(): ShortcutCategory[];

// @public
export function getAllIndicatorPositions(): IndicatorPosition[];

// @public
export function getAllIndicatorVariants(): IndicatorVariant[];

// @public
export function getAllLoadingSizes(): LoadingSize[];

// @public
export function getAllLoadingVariants(): LoadingVariant[];

// @public
export function getAllPasteOptions(): PasteOptionDef[];

// @public
export function getCategoryLabel(category: ShortcutCategory): string;

// @public
export function getCellAt(table: Table, rowIndex: number, columnIndex: number): TableCell | null;

// @public
export function getColumnCount(table: Table): number;

// @public
export function getCommonShortcuts(): DialogKeyboardShortcut[];

// @public
export function getDefaultActions(): AIAction[];

export { getDefaultHighlightOptions }

// @public
export function getDefaultPasteOption(): PasteOption;

// @public
export function getDefaultPrintOptions(): PrintOptions;

// @public
export function getDefaultShortcuts(): DialogKeyboardShortcut[];

// @public
export function getDefaultTextContextMenuItems(): TextContextMenuItem[];

// @public
export function getImageAcceptString(): string;

// @public
export function getImageDimensions(src: string): Promise<{
    width: number;
    height: number;
}>;

// @public
export function getLoadingVariantLabel(variant: LoadingVariant): string;

// @public (undocumented)
export function getMarginInUnits(marginTwips: number, unit: 'inch' | 'cm'): string;

export { getMatchCountText }

// @public
export function getPasteOption(id: PasteOption): PasteOptionDef | undefined;

// @public
export function getRecommendedPriority(itemType: string): ToolbarItemPriority;

// @public (undocumented)
export function getRulerDimensions(sectionProps?: SectionProperties | null, zoom?: number): {
    width: number;
    leftMargin: number;
    rightMargin: number;
    contentWidth: number;
};

// @public
export function getShortcutsByCategory(category: ShortcutCategory): DialogKeyboardShortcut[];

// @public
export function getSupportedImageExtensions(): string[];

// @public
export function getSymbolCategories(): SymbolCategory[];

// @public
export function getSymbolsByCategory(categoryName: string): string[];

// @public
export function getSymbolUnicodeInfo(symbol: string): {
    character: string;
    codePoint: string;
    decimal: number;
    hex: string;
};

// @public
export function getTablePresets(): {
    label: string;
    config: TableConfig;
}[];

// @public (undocumented)
export function getTableSplitCellDialogConfig(table: Table, rowIndex: number, columnIndex: number): TableSplitConfig | null;

// @public
export function getTextActionLabel(action: TextContextAction): string;

// @public
export function getTextActionShortcut(action: TextContextAction): string;

// @public
export function getVariantLabel(variant: IndicatorVariant): string;

export { HighlightOptions }

// @public (undocumented)
export function HorizontalRuler(input: HorizontalRulerProps): React__default.ReactElement;

// @public
export interface HorizontalRulerProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    editable?: boolean;
    // (undocumented)
    firstLineIndent?: number;
    // (undocumented)
    hangingIndent?: boolean;
    // (undocumented)
    indentLeft?: number;
    // (undocumented)
    indentRight?: number;
    // (undocumented)
    onFirstLineIndentChange?: (indentTwips: number) => void;
    // (undocumented)
    onIndentLeftChange?: (indentTwips: number) => void;
    // (undocumented)
    onIndentRightChange?: (indentTwips: number) => void;
    // (undocumented)
    onLeftMarginChange?: (marginTwips: number) => void;
    // (undocumented)
    onRightMarginChange?: (marginTwips: number) => void;
    // (undocumented)
    onTabStopRemove?: (positionTwips: number) => void;
    // (undocumented)
    sectionProps?: SectionProperties | null;
    // (undocumented)
    showFirstLineIndent?: boolean;
    // (undocumented)
    style?: CSSProperties;
    // (undocumented)
    tabStops?: TabStop[] | null;
    // (undocumented)
    unit?: 'inch' | 'cm';
    // (undocumented)
    zoom?: number;
}

// @public
export interface HyperlinkData {
    bookmark?: string;
    displayText?: string;
    tooltip?: string;
    url?: string;
}

// @public
export function HyperlinkDialog(input: HyperlinkDialogProps): React__default.ReactElement | null;

// @public
export interface HyperlinkDialogProps {
    bookmarks?: BookmarkOption[];
    className?: string;
    initialData?: HyperlinkData;
    isEditing?: boolean;
    isOpen: boolean;
    onClose: () => void;
    onRemove?: () => void;
    onSubmit: (data: HyperlinkData) => void;
    selectedText?: string;
    style?: CSSProperties;
}

// @public
interface ImageData_2 {
    alt?: string;
    fileName?: string;
    height: number;
    mimeType?: string;
    src: string;
    width: number;
}
export { ImageData_2 as ImageData }

// @public
export type IndicatorPosition = 'inline' | 'absolute-top-right' | 'absolute-top-left';

// @public
export type IndicatorVariant = 'dot' | 'badge' | 'text' | 'icon';

// @public
export function InsertImageDialog(input: InsertImageDialogProps): React__default.ReactElement | null;

// @public
export interface InsertImageDialogProps {
    accept?: string;
    className?: string;
    isOpen: boolean;
    maxHeight?: number;
    maxWidth?: number;
    onClose: () => void;
    onInsert: (data: ImageData_2) => void;
    style?: CSSProperties;
}

// @public
export function InsertSymbolDialog(input: InsertSymbolDialogProps): React__default.ReactElement | null;

// @public
export interface InsertSymbolDialogProps {
    className?: string;
    isOpen: boolean;
    onClose: () => void;
    onInsert: (symbol: string) => void;
    recentSymbols?: string[];
    style?: CSSProperties;
}

// @public
export function InsertTableDialog(input: InsertTableDialogProps): React__default.ReactElement | null;

// @public
export interface InsertTableDialogProps {
    className?: string;
    isOpen: boolean;
    maxColumns?: number;
    maxGridColumns?: number;
    maxGridRows?: number;
    maxRows?: number;
    onClose: () => void;
    onInsert: (config: TableConfig) => void;
    style?: CSSProperties;
}

// @public
export function isActionAvailable(_action: AIAction, selectedText: string, _selectionContext?: SelectionContext): boolean;

export { isEmptySearch }

// @public
export function isPasteSpecialShortcut(event: KeyboardEvent): boolean;

// @public
export function isPrintSupported(): boolean;

// @public
export function isTextActionAvailable(action: TextContextAction, hasSelection: boolean, isEditable: boolean): boolean;

// @public
export function isValidImageFile(file: File): boolean;

// @public
export function isValidTableConfig(config: TableConfig, maxRows?: number, maxColumns?: number): boolean;

// @public (undocumented)
export const KeyboardShortcutsDialog: React__default.FC<KeyboardShortcutsDialogProps>;

// @public
export interface KeyboardShortcutsDialogProps {
    className?: string;
    customShortcuts?: DialogKeyboardShortcut[];
    isOpen: boolean;
    onClose: () => void;
    showSearch?: boolean;
}

// @public
export interface LineSpacingOption {
    // (undocumented)
    label: string;
    // (undocumented)
    labelKey?: TranslationKey;
    // (undocumented)
    twipsValue: number;
    // (undocumented)
    value: number;
}

// @public (undocumented)
export function LineSpacingPicker(input: LineSpacingPickerProps): React$1.JSX.Element;

// @public (undocumented)
export interface LineSpacingPickerProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onChange?: (twipsValue: number) => void;
    // (undocumented)
    options?: LineSpacingOption[];
    // (undocumented)
    value?: number;
    // (undocumented)
    width?: number | string;
}

// @public
export function ListButtons(input: ListButtonsProps): React__default.JSX.Element;

// @public
export interface ListButtonsProps {
    className?: string;
    compact?: boolean;
    disabled?: boolean;
    hasIndent?: boolean;
    listState?: ListState;
    onBulletList?: () => void;
    onIndent?: () => void;
    onNumberedList?: () => void;
    onOutdent?: () => void;
    showIndentButtons?: boolean;
    style?: CSSProperties;
}

export { ListState }

// @public (undocumented)
export const LoadingIndicator: React__default.FC<LoadingIndicatorProps>;

// @public
export interface LoadingIndicatorProps {
    className?: string;
    color?: string;
    isLoading: boolean;
    message?: string;
    overlay?: boolean;
    overlayOpacity?: number;
    progress?: number;
    showProgressText?: boolean;
    size?: LoadingSize;
    style?: React__default.CSSProperties;
    variant?: LoadingVariant;
}

// @public
export interface LoadingOperation {
    // (undocumented)
    id: string;
    // (undocumented)
    message?: string;
    // (undocumented)
    progress?: number;
    // (undocumented)
    startTime: number;
}

// @public
export type LoadingSize = 'small' | 'medium' | 'large';

// @public
export type LoadingVariant = 'spinner' | 'dots' | 'bar' | 'pulse' | 'progress';

// @public
export interface LogoProps {
    // (undocumented)
    children: ReactNode;
}

// @public
export function mergeCells(table: Table, selection: TableSelection): Table;

// @public
export function openPrintWindow(title: string | undefined, content: string): Window | null;

// @public (undocumented)
export function parseMarginFromUnits(value: string, unit: 'inch' | 'cm'): number | null;

// @public
export function parsePageRange(input: string, maxPages: number): {
    start: number;
    end: number;
} | null;

// @public
export type PasteOption = 'formatted' | 'plainText';

// @public (undocumented)
export const PasteSpecialDialog: React__default.FC<PasteSpecialDialogProps>;

// @public
export interface PasteSpecialDialogProps {
    className?: string;
    isOpen: boolean;
    onClose: () => void;
    onPaste: (content: ParsedClipboardContent, asPlainText: boolean) => void;
    position?: {
        x: number;
        y: number;
    };
}

// @public (undocumented)
export function positionToMargin(positionPx: number, side: 'left' | 'right', pageWidthPx: number, zoom: number): number;

// @public
export function PrintButton(input: PrintButtonProps): React__default.ReactElement;

// @public
export interface PrintButtonProps {
    className?: string;
    compact?: boolean;
    disabled?: boolean;
    label?: string;
    onPrint: () => void;
    showIcon?: boolean;
    style?: CSSProperties;
}

// @public
export interface PrintOptions {
    includeFooters?: boolean;
    includeHeaders?: boolean;
    includePageNumbers?: boolean;
    margins?: 'default' | 'none' | 'minimum';
    pageRange?: {
        start: number;
        end: number;
    } | null;
    printBackground?: boolean;
    scale?: number;
}

// @public
export function PrintStyles(): React__default.ReactElement;

export { replaceAllInContent }

export { replaceFirstInContent }

// @public (undocumented)
export const ResponsePreview: React__default.FC<ResponsePreviewProps>;

// @public
export interface ResponsePreviewProps {
    action: AIAction;
    allowEdit?: boolean;
    className?: string;
    error?: string;
    isLoading: boolean;
    onAccept: (newText: string) => void;
    onReject: () => void;
    onRetry?: () => void;
    originalText: string;
    position?: {
        x: number;
        y: number;
    };
    response: AgentResponse | null;
    showDiff?: boolean;
}

// @public
export interface ResponsePreviewState {
    // (undocumented)
    action: AIAction;
    // (undocumented)
    error?: string;
    // (undocumented)
    isLoading: boolean;
    // (undocumented)
    isVisible: boolean;
    // (undocumented)
    originalText: string;
    // (undocumented)
    position?: {
        x: number;
        y: number;
    };
    // (undocumented)
    response: AgentResponse | null;
}

// @public (undocumented)
export const ResponsiveToolbar: React__default.FC<ResponsiveToolbarProps>;

// @public (undocumented)
export const ResponsiveToolbarGroup: React__default.FC<ResponsiveToolbarGroupProps>;

// @public (undocumented)
export interface ResponsiveToolbarGroupProps {
    children: ReactNode;
    className?: string;
    gap?: number;
    separatorAfter?: boolean;
    style?: CSSProperties;
}

// @public
export interface ResponsiveToolbarProps {
    alwaysShowOverflow?: boolean;
    backgroundColor?: string;
    borderBottom?: string;
    className?: string;
    height?: number | string;
    itemGap?: number;
    items: ToolbarItem[];
    overflowButtonWidth?: number;
    overflowItems?: ToolbarItem[];
    padding?: number | string;
    renderOverflowButton?: (itemCount: number, isOpen: boolean, onClick: () => void) => ReactNode;
    renderOverflowMenu?: (items: ToolbarItem[], onClose: () => void) => ReactNode;
    style?: CSSProperties;
}

export { scrollToMatch }

// @public
export function searchSymbols(query: string): string[];

// @public
export type ShortcutCategory = 'editing' | 'formatting' | 'navigation' | 'clipboard' | 'selection' | 'view' | 'file' | 'other';

// @public
export function splitCell(table: Table, rowIndex: number, columnIndex: number): Table;

// @public (undocumented)
export function splitTableCell(table: Table, rowIndex: number, columnIndex: number, rows: number, cols: number): Table;

// @public
export interface StyleOption {
    bold?: boolean;
    color?: string;
    fontSize?: number;
    // (undocumented)
    isDefault?: boolean;
    italic?: boolean;
    // (undocumented)
    name: string;
    // (undocumented)
    nameKey?: TranslationKey;
    // (undocumented)
    priority?: number;
    // (undocumented)
    qFormat?: boolean;
    // (undocumented)
    styleId: string;
    // (undocumented)
    type: StyleType;
}

// @public (undocumented)
export function StylePicker(input: StylePickerProps): React$1.JSX.Element;

// @public (undocumented)
export interface StylePickerProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onChange?: (styleId: string) => void;
    // (undocumented)
    styles?: Style[];
    // (undocumented)
    theme?: Theme | null;
    // (undocumented)
    value?: string;
    // (undocumented)
    width?: number | string;
}

// @public
export const SYMBOL_CATEGORIES: SymbolCategory[];

// @public
export interface SymbolCategory {
    label: string;
    name: string;
    symbols: string[];
}

// @public
export function symbolFromCodePoint(codePointStr: string): string | null;

// @public
export 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;
};

// @public (undocumented)
export function TableBorderColorPicker(input: TableBorderColorPickerProps): React$1.JSX.Element;

// @public (undocumented)
export interface TableBorderColorPickerProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onAction: (action: TableAction) => void;
    // (undocumented)
    theme?: Theme | null;
    value?: string;
}

// @public (undocumented)
export function TableBorderPicker(input: TableBorderPickerProps): React$1.JSX.Element;

// @public (undocumented)
export interface TableBorderPickerProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onAction: (action: TableAction) => void;
}

// @public (undocumented)
export function TableBorderWidthPicker(input: TableBorderWidthPickerProps): React$1.JSX.Element;

// @public (undocumented)
export interface TableBorderWidthPickerProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onAction: (action: TableAction) => void;
}

// @public (undocumented)
export function TableCellFillPicker(input: TableCellFillPickerProps): React$1.JSX.Element;

// @public (undocumented)
export interface TableCellFillPickerProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onAction: (action: TableAction) => void;
    // (undocumented)
    theme?: Theme | null;
    value?: string;
}

// @public
export interface TableConfig {
    columns: number;
    rows: number;
}

// @public
export interface TableContext {
    canSplitCell: boolean;
    columnCount: number;
    hasMultiCellSelection: boolean;
    rowCount: number;
    selection: TableSelection;
    table: Table;
}

// @public (undocumented)
export function TableInsertButtons(input: TableInsertButtonsProps): React__default.JSX.Element;

// @public
export interface TableInsertButtonsProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onAction: (action: TableAction) => void;
}

// @public (undocumented)
export function TableMergeButton(input: TableMergeButtonProps): React__default.JSX.Element;

// @public
export interface TableMergeButtonProps {
    // (undocumented)
    canMerge?: boolean;
    // (undocumented)
    canSplit?: boolean;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onAction: (action: TableAction) => void;
}

// @public (undocumented)
export function TableMoreDropdown(input: TableMoreDropdownProps): React$1.JSX.Element;

// @public (undocumented)
export interface TableMoreDropdownProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    onAction: (action: TableAction) => void;
    // (undocumented)
    tableContext?: {
        isInTable: boolean;
        rowCount?: number;
        columnCount?: number;
        canSplitCell?: boolean;
        hasMultiCellSelection?: boolean;
        table?: {
            attrs?: {
                justification?: string;
            };
        };
    } | null;
}

// @public
export interface TableSelection {
    columnIndex: number;
    rowIndex: number;
    selectedCells?: {
        startRow: number;
        startCol: number;
        endRow: number;
        endCol: number;
    };
    tableIndex: number;
}

// @public (undocumented)
export interface TableSplitConfig {
    // (undocumented)
    initialCols: number;
    // (undocumented)
    initialRows: number;
    // (undocumented)
    minCols: number;
    // (undocumented)
    minRows: number;
}

// @public
export function TableToolbar(input: TableToolbarProps): React__default.ReactElement | null;

// @public
export interface TableToolbarProps {
    children?: ReactNode;
    className?: string;
    compact?: boolean;
    context: TableContext | null;
    disabled?: boolean;
    onAction?: (action: TableAction, context: TableContext) => void;
    position?: 'top' | 'floating';
    showLabels?: boolean;
    style?: CSSProperties;
}

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

// @public (undocumented)
export const TextContextMenu: React__default.FC<TextContextMenuProps>;

// @public
export interface TextContextMenuItem {
    action: TextContextAction;
    disabled?: boolean;
    dividerAfter?: boolean;
    label: string;
    shortcut?: string;
}

// @public
export interface TextContextMenuProps {
    className?: string;
    hasClipboardContent?: boolean;
    hasSelection: boolean;
    isEditable: boolean;
    isOpen: boolean;
    items?: TextContextMenuItem[];
    onAction: (action: TextContextAction) => void;
    onClose: () => void;
    position: {
        x: number;
        y: number;
    };
}

// @public (undocumented)
export interface TitleBarProps {
    // (undocumented)
    children: ReactNode;
}

// @public (undocumented)
export interface TitleBarRightProps {
    // (undocumented)
    children: ReactNode;
}

// @public
export function Toolbar(explicitProps: ToolbarProps): React__default.JSX.Element;

// @public
export function ToolbarButton(input: ToolbarButtonProps): React__default.JSX.Element;

// @public
export function ToolbarGroup(input: ToolbarGroupProps$1): React__default.JSX.Element;

// @public
export interface ToolbarItem {
    alwaysVisible?: boolean;
    content: ReactNode;
    group?: string;
    id: string;
    minWidth?: number;
    priority?: ToolbarItemPriority;
    separatorAfter?: boolean;
}

// @public
export type ToolbarItemPriority = 1 | 2 | 3 | 4 | 5;

// @public
export interface ToolbarProps {
    canRedo?: boolean;
    canUndo?: boolean;
    children?: ReactNode;
    className?: string;
    currentFormatting?: SelectionFormatting;
    disabled?: boolean;
    documentStyles?: Style[];
    editorRef?: React__default.RefObject<HTMLElement>;
    enableShortcuts?: boolean;
    fontFamilies?: ReadonlyArray<string | FontOption>;
    imageContext?: {
        wrapType: string;
        displayMode: string;
        cssFloat: string | null;
    } | null;
    inline?: boolean;
    onFormat?: (action: FormattingAction) => void;
    onImageTransform?: (action: 'rotateCW' | 'rotateCCW' | 'flipH' | 'flipV') => void;
    onImageWrapType?: (wrapType: string) => void;
    onInsertImage?: () => void;
    onInsertPageBreak?: () => void;
    onInsertSectionBreakContinuous?: () => void;
    onInsertSectionBreakNextPage?: () => void;
    onInsertShape?: (data: {
        shapeType: string;
        width: number;
        height: number;
        fillColor?: string;
        fillType?: string;
        outlineWidth?: number;
        outlineColor?: string;
    }) => void;
    onInsertTable?: (rows: number, columns: number) => void;
    onInsertTOC?: () => void;
    onOpen?: () => void;
    onOpenImageProperties?: () => void;
    onPageSetup?: () => void;
    onPrint?: () => void;
    onRedo?: () => void;
    onRefocusEditor?: () => void;
    onSave?: () => void;
    onTableAction?: (action: TableAction) => void;
    onUndo?: () => void;
    onWatermark?: () => void;
    onZoomChange?: (zoom: number) => void;
    showAlignmentButtons?: boolean;
    showFontPicker?: boolean;
    showFontSizePicker?: boolean;
    showHighlightColorPicker?: boolean;
    showLineSpacingPicker?: boolean;
    showListButtons?: boolean;
    showStylePicker?: boolean;
    showTableInsert?: boolean;
    showTextColorPicker?: boolean;
    showZoomControl?: boolean;
    style?: CSSProperties;
    tableContext?: {
        isInTable: boolean;
        rowCount?: number;
        columnCount?: number;
        canSplitCell?: boolean;
        hasMultiCellSelection?: boolean;
        cellBorderColor?: ColorValue;
        cellBackgroundColor?: string;
    } | null;
    theme?: Theme | null;
    zoom?: number;
}

// @public
export function ToolbarSeparator(): React__default.JSX.Element;

// @public
export function triggerPrint(): void;

// @public (undocumented)
export const UnsavedIndicator: React__default.FC<UnsavedIndicatorProps>;

// @public
export interface UnsavedIndicatorProps {
    className?: string;
    hasUnsavedChanges: boolean;
    label?: string;
    onClick?: () => void;
    position?: IndicatorPosition;
    savedColor?: string;
    savedLabel?: string;
    showPulse?: boolean;
    showWhenSaved?: boolean;
    size?: number;
    style?: React__default.CSSProperties;
    title?: string;
    unsavedColor?: string;
    variant?: IndicatorVariant;
}

// @public
export 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;
};

// @public
export function useFindReplace(hookOptions?: FindReplaceOptions): UseFindReplaceReturn;

// @public
export interface UseFindReplaceReturn {
    close: () => void;
    getCurrentMatch: () => FindMatch | null;
    goToMatch: (index: number) => void;
    goToNextMatch: () => number;
    goToPreviousMatch: () => number;
    hasMatches: () => boolean;
    openFind: (selectedText?: string) => void;
    openReplace: (selectedText?: string) => void;
    setMatches: (matches: FindMatch[], currentIndex?: number) => void;
    setOptions: (options: Partial<FindOptions>) => void;
    setReplaceText: (text: string) => void;
    setSearchText: (text: string) => void;
    state: FindReplaceState;
    toggle: () => void;
}

// @public
export function useHyperlinkDialog(): UseHyperlinkDialogReturn;

// @public
export function useInsertImageDialog(): {
    isOpen: boolean;
    open: () => void;
    close: () => void;
    toggle: () => void;
};

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

// @public
export function useInsertTableDialog(): {
    isOpen: boolean;
    open: () => void;
    close: () => void;
    toggle: () => void;
};

// @public
export function useKeyboardShortcutsDialog(options?: UseKeyboardShortcutsDialogOptions): UseKeyboardShortcutsDialogReturn;

// @public
export interface UseKeyboardShortcutsDialogOptions {
    enabled?: boolean;
    openShortcut?: string;
}

// @public
export interface UseKeyboardShortcutsDialogReturn {
    close: () => void;
    handleKeyDown: (event: KeyboardEvent) => void;
    isOpen: boolean;
    open: () => void;
    toggle: () => void;
}

// @public
export function useLoading(options?: UseLoadingOptions): UseLoadingReturn;

// @public
export 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;
};

// @public
export interface UseLoadingOptions {
    initialLoading?: boolean;
    minDuration?: number;
    onEnd?: () => void;
    onStart?: () => void;
}

// @public
export interface UseLoadingReturn {
    isLoading: boolean;
    message: string | null;
    progress: number;
    setMessage: (message: string | null) => void;
    setProgress: (progress: number) => void;
    startLoading: (message?: string) => void;
    stopLoading: () => void;
    withLoading: <T>(operation: () => Promise<T>, message?: string) => Promise<T>;
}

// @public
export function usePasteSpecial(options?: UsePasteSpecialOptions): UsePasteSpecialReturn;

// @public
export interface UsePasteSpecialOptions {
    enabled?: boolean;
    onPaste?: (content: ParsedClipboardContent, asPlainText: boolean) => void;
}

// @public
export interface UsePasteSpecialReturn {
    closeDialog: () => void;
    handleKeyDown: (event: KeyboardEvent) => boolean;
    isOpen: boolean;
    openDialog: () => void;
    pasteAsPlainText: () => Promise<void>;
}

// @public
export 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;
};

// @public
export function useResponsiveToolbar(options: UseResponsiveToolbarOptions): UseResponsiveToolbarReturn;

// @public
export interface UseResponsiveToolbarOptions {
    containerRef: React__default.RefObject<HTMLElement | null>;
    itemGap?: number;
    items: ToolbarItem[];
    overflowButtonWidth?: number;
}

// @public
export interface UseResponsiveToolbarReturn {
    hasOverflow: boolean;
    overflowItems: ToolbarItem[];
    recalculate: () => void;
    visibleItems: ToolbarItem[];
}

// @public
export function useTextContextMenu(options?: UseTextContextMenuOptions): UseTextContextMenuReturn;

// @public
export interface UseTextContextMenuOptions {
    containerRef?: React__default.RefObject<HTMLElement>;
    enabled?: boolean;
    isEditable?: boolean;
    onAction?: (action: TextContextAction) => void;
}

// @public
export interface UseTextContextMenuReturn {
    closeMenu: () => void;
    handleAction: (action: TextContextAction) => void;
    hasSelection: boolean;
    isOpen: boolean;
    onContextMenu: (event: React__default.MouseEvent) => void;
    openMenu: (event: React__default.MouseEvent | MouseEvent) => void;
    position: {
        x: number;
        y: number;
    };
}

// @public
export function useUnsavedChanges(options?: UseUnsavedChangesOptions): UseUnsavedChangesReturn;

// @public
export interface UseUnsavedChangesOptions {
    document?: Document_2 | null;
    enabled?: boolean;
    onChangeStatusChange?: (hasChanges: boolean) => void;
    warnBeforeLeave?: boolean;
    warningMessage?: string;
}

// @public
export interface UseUnsavedChangesReturn {
    changeCount: number;
    hasUnsavedChanges: boolean;
    lastSavedDocument: Document_2 | null;
    markAsChanged: () => void;
    markAsSaved: () => void;
    resetTracking: (newDocument?: Document_2 | null) => void;
}

// @public (undocumented)
export function ZoomControl(input: ZoomControlProps): React$1.JSX.Element;

// @public (undocumented)
export interface ZoomControlProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    compact?: boolean;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    levels?: ZoomLevel[];
    // (undocumented)
    onChange?: (zoom: number) => void;
    // (undocumented)
    value?: number;
}

```
