@eigenpal/docx-js-editor 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,4579 @@
+import * as prosemirror_view from 'prosemirror-view';
+import { EditorView, DecorationSet } from 'prosemirror-view';
+import * as prosemirror_state from 'prosemirror-state';
+import { EditorState, Command, Plugin, PluginKey } from 'prosemirror-state';
+import * as React$1 from 'react';
+import React__default, { CSSProperties, ReactNode, Component, ErrorInfo } from 'react';
+import { T as TextFormatting, e as Paragraph, f as Table, a1 as SectionProperties, an as HeaderFooter, h as Document, ab as Theme, U as ParagraphFormatting, a2 as SelectionContext, a8 as TableCell, ao as ParagraphAlignment, a4 as Style, A as AIAction, l as AgentResponse, ap as StyleType, aq as BorderSpec, ar as ShadingProperties, R as Run, as as BreakContent, $ as RunContent } from './types-BJXChtaM.js';
+export { i as AIActionRequest, j as AgentCommand, k as AgentContext, m as ApplyStyleCommand, B as BlockContent, at as BookmarkEnd, au as BookmarkStart, C as CorePlugin, q as DeleteTextCommand, D as DocumentBody, r as DocxPackage, E as Endnote, av as Field, aw as FooterReference, F as Footnote, t as FormatTextCommand, ax as HeaderReference, H as Hyperlink, I as Image, u as InsertHyperlinkCommand, v as InsertImageCommand, w as InsertTableCommand, x as InsertTextCommand, L as ListLevel, d as McpSession, M as McpToolDefinition, N as McpToolHandler, O as McpToolResult, Q as NumberingDefinitions, S as ParagraphContext, g as Position, Y as Range, Z as Relationship, _ as ReplaceTextCommand, a3 as SetVariableCommand, ay as Shape, a5 as StyleDefinitions, a7 as SuggestedAction, a9 as TableRow, az as TextBox, aa as TextContent, aA as ThemeColorScheme, aB as ThemeFont, aC as ThemeFontScheme } from './types-BJXChtaM.js';
+import { D as DocumentAgent } from './colorResolver-Yakhydrt.js';
+export { A as AgentContextOptions, C as CreateEmptyDocumentOptions, E as ExtendedSelectionContext, P as ProcessTemplateOptions, e as ProcessTemplateResult, f as SelectionContextOptions, g as blendColors, h as buildExtendedSelectionContext, i as buildSelectionContext, k as colorsEqual, n as createDocumentWithText, o as createEmptyDocument, p as createRgbColor, r as createThemeColor, s as darkenColor, t as emuToPixels, u as emuToTwips, v as executeCommand, w as executeCommands, x as formatPx, y as getAgentContext, z as getContrastingColor, B as getDocumentSummary, J as getTemplateTags, K as halfPointsToPixels, L as isBlack, M as isWhite, N as lightenColor, O as parseColorString, Q as parseDocx, R as pixelsToEmu, U as pixelsToTwips, V as pointsToPixels, X as processTemplate, Z as processTemplateAsBlob, _ as processTemplateDetailed, $ as resolveColor, a0 as resolveHighlightColor, a1 as resolveShadingColor, a2 as serializeDocumentBody, a3 as serializeDocx, a4 as serializeSectionProperties, a5 as twipsToEmu, a6 as twipsToPixels, a7 as validateTemplate } from './colorResolver-Yakhydrt.js';
+import { Node as Node$1 } from 'prosemirror-model';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+export { P as PluginRegistry, p as pluginRegistry, r as registerPlugins } from './registry-D3zhko7n.js';
+export { docxtemplaterPlugin } from './core-plugins.js';
+
+/**
+ * PageNumberIndicator Component
+ *
+ * Displays the current page number and total page count.
+ * Can be used as a floating indicator or status bar element.
+ */
+
+/**
+ * Position options for the indicator
+ */
+type PageIndicatorPosition = 'bottom-left' | 'bottom-center' | 'bottom-right' | 'top-left' | 'top-center' | 'top-right';
+/**
+ * Style variant for the indicator
+ */
+type PageIndicatorVariant = 'default' | 'minimal' | 'badge' | 'pill';
+/**
+ * Props for PageNumberIndicator
+ */
+interface PageNumberIndicatorProps {
+    /** Current page number (1-indexed) */
+    currentPage: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Position of the indicator (default: 'bottom-center') */
+    position?: PageIndicatorPosition;
+    /** Style variant (default: 'default') */
+    variant?: PageIndicatorVariant;
+    /** Whether to show as floating overlay (default: true) */
+    floating?: boolean;
+    /** Whether to show "Page" prefix (default: true) */
+    showPrefix?: boolean;
+    /** Custom format function for the display text */
+    formatText?: (current: number, total: number) => string;
+    /** Callback when page number is clicked (for navigation) */
+    onClick?: () => void;
+    /** Whether the indicator is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Custom content (overrides default display) */
+    children?: ReactNode;
+}
+/**
+ * PageNumberIndicator - Displays current page and total pages
+ */
+declare function PageNumberIndicator({ currentPage, totalPages, position, variant, floating, showPrefix, formatText, onClick, disabled, className, style, children, }: PageNumberIndicatorProps): React__default.ReactElement;
+/**
+ * Format page number with ordinal suffix (1st, 2nd, 3rd, etc.)
+ */
+declare function formatPageOrdinal(page: number): string;
+/**
+ * Create a custom format function
+ */
+declare function createPageFormat(template: string): (current: number, total: number) => string;
+/**
+ * Get percentage progress through document
+ */
+declare function getPageProgress(current: number, total: number): number;
+/**
+ * Check if at first page
+ */
+declare function isFirstPage(current: number): boolean;
+/**
+ * Check if at last page
+ */
+declare function isLastPage(current: number, total: number): boolean;
+/**
+ * Calculate which page is visible given scroll position
+ */
+declare function calculateVisiblePage(scrollTop: number, pageHeights: number[], pageGap?: number): number;
+/**
+ * Calculate scroll position to center a page
+ */
+declare function calculateScrollToPage(pageNumber: number, pageHeights: number[], containerHeight: number, pageGap?: number): number;
+
+/**
+ * PageNavigator Component
+ *
+ * Provides UI for navigating between pages in a paginated document.
+ * Includes:
+ * - Previous/Next page buttons
+ * - Current page display (clickable to show input)
+ * - Page number input for direct navigation
+ * - Keyboard navigation support
+ */
+
+/**
+ * Position options for the navigator
+ */
+type PageNavigatorPosition = 'bottom-left' | 'bottom-center' | 'bottom-right' | 'top-left' | 'top-center' | 'top-right';
+/**
+ * Style variant for the navigator
+ */
+type PageNavigatorVariant = 'default' | 'compact' | 'minimal';
+/**
+ * Props for PageNavigator
+ */
+interface PageNavigatorProps {
+    /** Current page number (1-indexed) */
+    currentPage: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Callback when page navigation is requested */
+    onNavigate: (pageNumber: number) => void;
+    /** Position of the navigator (default: 'bottom-center') */
+    position?: PageNavigatorPosition;
+    /** Style variant (default: 'default') */
+    variant?: PageNavigatorVariant;
+    /** Whether to show as floating overlay (default: true) */
+    floating?: boolean;
+    /** Whether to show previous/next buttons (default: true) */
+    showButtons?: boolean;
+    /** Whether the navigator is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * PageNavigator - Navigation controls for paginated documents
+ */
+declare function PageNavigator({ currentPage, totalPages, onNavigate, position, variant, floating, showButtons, disabled, className, style, }: PageNavigatorProps): React__default.ReactElement;
+/**
+ * Calculate page number from keyboard input
+ */
+declare function parsePageInput(input: string): number | null;
+/**
+ * Validate page number
+ */
+declare function isValidPageNumber(page: number, totalPages: number): boolean;
+/**
+ * Clamp page number to valid range
+ */
+declare function clampPageNumber(page: number, totalPages: number): number;
+/**
+ * Get navigation info for keyboard shortcuts
+ */
+declare function getNavigationShortcuts(): Array<{
+    key: string;
+    description: string;
+}>;
+/**
+ * Format page range for display
+ */
+declare function formatPageRange$1(start: number, end: number, total: number): string;
+/**
+ * Calculate progress percentage
+ */
+declare function calculateProgress(current: number, total: number): number;
+
+/**
+ * Line Breaker
+ *
+ * Breaks paragraphs into lines based on available width.
+ * Handles:
+ * - Word boundary line breaking
+ * - Multiple runs with different font sizes
+ * - Tab stops and their alignment
+ * - Non-breaking spaces and hyphens
+ * - Soft hyphens
+ */
+
+/**
+ * A fragment of content that can't be broken (word or inline element)
+ */
+interface LineFragment {
+    /** Type of fragment */
+    type: 'text' | 'tab' | 'break' | 'image' | 'field' | 'symbol' | 'space';
+    /** The content (text for text fragments) */
+    content: string;
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+    /** Baseline from top in pixels */
+    baseline: number;
+    /** Source run index */
+    runIndex: number;
+    /** Source content index within run */
+    contentIndex: number;
+    /** Character offset within text content (for text fragments) */
+    charOffset?: number;
+    /** Character count (for text fragments) */
+    charCount?: number;
+    /** Text formatting applied */
+    formatting?: TextFormatting;
+    /** Whether this is a break point */
+    canBreakAfter: boolean;
+    /** Whether this is a non-breaking element */
+    nonBreaking?: boolean;
+    /** Tab stop position (for tabs) */
+    tabStopPosition?: number;
+}
+/**
+ * A line of formatted text
+ */
+interface Line {
+    /** Fragments on this line */
+    fragments: LineFragment[];
+    /** Total width of the line */
+    width: number;
+    /** Height of the line (max of all fragments) */
+    height: number;
+    /** Baseline position from top */
+    baseline: number;
+    /** Y position from top of paragraph */
+    y: number;
+    /** Whether this is the last line of the paragraph */
+    isLastLine: boolean;
+    /** Whether this line ends with a hard break */
+    hasHardBreak: boolean;
+    /** Line number (0-indexed within paragraph) */
+    lineNumber: number;
+}
+
+/**
+ * Page Layout Engine
+ *
+ * Distributes document content across pages based on:
+ * - Page size and margins
+ * - Explicit page breaks
+ * - Natural page breaks (content overflow)
+ * - Headers and footers
+ * - Keep-with-next, keep-lines-together constraints
+ */
+
+/**
+ * A laid out page
+ */
+interface Page {
+    /** Page number (1-indexed) */
+    pageNumber: number;
+    /** Section this page belongs to */
+    sectionIndex: number;
+    /** Section properties for this page */
+    sectionProps: SectionProperties;
+    /** Content blocks on this page */
+    content: PageContent[];
+    /** Header for this page (if any) */
+    header: HeaderFooter | null;
+    /** Footer for this page (if any) */
+    footer: HeaderFooter | null;
+    /** Whether this is the first page of its section */
+    isFirstPageOfSection: boolean;
+    /** Whether this is the last page of the document */
+    isLastPage: boolean;
+    /** Page width in pixels */
+    widthPx: number;
+    /** Page height in pixels */
+    heightPx: number;
+    /** Content area width in pixels */
+    contentWidthPx: number;
+    /** Content area height in pixels */
+    contentHeightPx: number;
+    /** Content area top offset */
+    contentTopPx: number;
+    /** Content area left offset */
+    contentLeftPx: number;
+}
+/**
+ * Content positioned on a page
+ */
+interface PageContent {
+    /** Type of content */
+    type: 'paragraph' | 'table';
+    /** The original block */
+    block: Paragraph | Table;
+    /** Block index in the document */
+    blockIndex: number;
+    /** Y position on the page (relative to content area) */
+    y: number;
+    /** Height of this content */
+    height: number;
+    /** Whether this block continues from previous page */
+    isContinuation: boolean;
+    /** Whether this block continues on next page */
+    continuesOnNextPage: boolean;
+    /** Lines for paragraphs (if laid out) */
+    lines?: Line[];
+    /** First line index if continuation */
+    startLineIndex?: number;
+}
+/**
+ * Result of page layout
+ */
+interface PageLayoutResult {
+    /** All pages */
+    pages: Page[];
+    /** Total page count */
+    totalPages: number;
+    /** Page number field values by location */
+    pageNumberFields?: Map<string, number>;
+}
+
+/**
+ * PrintPreview Component
+ *
+ * Provides print preview functionality with:
+ * - Print-optimized rendering of document pages
+ * - Browser print dialog trigger
+ * - Print-specific CSS styles
+ * - Page scale adjustment for printing
+ */
+
+/**
+ * Print options
+ */
+interface PrintOptions {
+    /** Whether to include headers */
+    includeHeaders?: boolean;
+    /** Whether to include footers */
+    includeFooters?: boolean;
+    /** Whether to include page numbers */
+    includePageNumbers?: boolean;
+    /** Page range to print (null = all) */
+    pageRange?: {
+        start: number;
+        end: number;
+    } | null;
+    /** Scale factor for printing (1.0 = 100%) */
+    scale?: number;
+    /** Whether to show background colors */
+    printBackground?: boolean;
+    /** Margins mode */
+    margins?: 'default' | 'none' | 'minimum';
+}
+/**
+ * PrintPreview props
+ */
+interface PrintPreviewProps {
+    /** Document to print */
+    document: Document;
+    /** Theme for color resolution */
+    theme?: Theme | null;
+    /** Print options */
+    options?: PrintOptions;
+    /** Whether the preview is open */
+    isOpen: boolean;
+    /** Callback when preview is closed */
+    onClose: () => void;
+    /** Callback when print is triggered */
+    onPrint?: () => void;
+    /** Render function for paragraphs */
+    renderParagraph?: (paragraph: Paragraph, index: number, pageContent: PageContent) => ReactNode;
+    /** Render function for tables */
+    renderTable?: (table: Table, index: number, pageContent: PageContent) => ReactNode;
+    /** Render function for headers */
+    renderHeader?: (header: HeaderFooter, pageNumber: number, totalPages: number) => ReactNode;
+    /** Render function for footers */
+    renderFooter?: (footer: HeaderFooter, pageNumber: number, totalPages: number) => ReactNode;
+}
+/**
+ * PrintButton props
+ */
+interface PrintButtonProps {
+    /** Callback when print is triggered */
+    onPrint: () => void;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Button label */
+    label?: string;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Show icon */
+    showIcon?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+}
+/**
+ * PrintPreview - Modal showing print-optimized document view
+ */
+declare function PrintPreview({ document: doc, theme, options, isOpen, onClose, onPrint, renderParagraph, renderTable, renderHeader, renderFooter, }: PrintPreviewProps): React__default.ReactElement | null;
+/**
+ * PrintButton - Standalone print button for toolbar
+ */
+declare function PrintButton({ onPrint, disabled, label, className, style, showIcon, compact, }: PrintButtonProps): React__default.ReactElement;
+/**
+ * PrintStyles - Injects print-specific CSS
+ */
+declare function PrintStyles(): React__default.ReactElement;
+/**
+ * Trigger browser print dialog for the current document
+ */
+declare function triggerPrint(): void;
+/**
+ * Create print-optimized document view in a new window
+ */
+declare function openPrintWindow(title: string | undefined, content: string): Window | null;
+/**
+ * Get default print options
+ */
+declare function getDefaultPrintOptions(): PrintOptions;
+/**
+ * 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;
+/**
+ * Format page range for display
+ */
+declare function formatPageRange(range: {
+    start: number;
+    end: number;
+} | null, totalPages: number): string;
+/**
+ * Check if browser supports good print functionality
+ */
+declare function isPrintSupported(): boolean;
+
+/**
+ * Selection state for toolbar integration
+ */
+interface SelectionState {
+    /** Whether there's an active selection (not just cursor) */
+    hasSelection: boolean;
+    /** Whether selection spans multiple paragraphs */
+    isMultiParagraph: boolean;
+    /** Current text formatting at selection/cursor */
+    textFormatting: TextFormatting;
+    /** Current paragraph formatting */
+    paragraphFormatting: ParagraphFormatting;
+    /** Current paragraph style ID (e.g., 'Heading1', 'Normal') */
+    styleId: string | null;
+    /** Start paragraph index */
+    startParagraphIndex: number;
+    /** End paragraph index */
+    endParagraphIndex: number;
+}
+/**
+ * Ref interface for external control
+ */
+interface ProseMirrorEditorRef {
+    /** Focus the editor */
+    focus: () => void;
+    /** Blur the editor */
+    blur: () => void;
+    /** Get the current ProseMirror state */
+    getState: () => EditorState | null;
+    /** Get the current ProseMirror view */
+    getView: () => EditorView | null;
+    /** Undo the last change */
+    undo: () => boolean;
+    /** Redo the last undone change */
+    redo: () => boolean;
+    /** Check if undo is available */
+    canUndo: () => boolean;
+    /** Check if redo is available */
+    canRedo: () => boolean;
+    /** Execute a ProseMirror command */
+    executeCommand: (command: Command) => boolean;
+    /** Toggle bold mark */
+    toggleBold: () => boolean;
+    /** Toggle italic mark */
+    toggleItalic: () => boolean;
+    /** Toggle underline mark */
+    toggleUnderline: () => boolean;
+    /** Get the current Document from PM state */
+    getDocument: () => Document | null;
+    /** Get selection context for AI features */
+    getSelectionContext: () => SelectionContext | null;
+}
+
+/**
+ * Generic Plugin Interface for the DOCX Editor
+ *
+ * This module defines the EditorPlugin interface that allows
+ * external plugins to integrate with the ProseMirror-based editor.
+ */
+
+/**
+ * Coordinates returned by position lookup in the rendered DOM.
+ */
+interface PositionCoordinates {
+    x: number;
+    y: number;
+    height: number;
+}
+/**
+ * Context for accessing the rendered DOM in PagedEditor.
+ *
+ * This interface provides DOM-based position mapping that works with
+ * the LayoutPainter output (visible pages) rather than the hidden
+ * ProseMirror editor. Use this for rendering overlays, annotations,
+ * and other visual elements that need to be positioned relative to
+ * the actual rendered content.
+ *
+ * The rendered DOM uses data-pm-start/data-pm-end attributes on spans
+ * to map between ProseMirror positions and DOM elements.
+ */
+interface RenderedDomContext {
+    /** The container element holding all rendered pages. */
+    pagesContainer: HTMLElement;
+    /**
+     * Get pixel coordinates for a ProseMirror position in the rendered DOM.
+     * Returns null if the position cannot be found.
+     *
+     * @param pmPos - ProseMirror document position
+     * @returns Coordinates relative to the pages container, or null
+     */
+    getCoordinatesForPosition(pmPos: number): PositionCoordinates | null;
+    /**
+     * Find DOM elements that overlap with a ProseMirror position range.
+     * Useful for highlighting or overlaying content.
+     *
+     * @param from - Start ProseMirror position
+     * @param to - End ProseMirror position
+     * @returns Array of DOM elements that intersect with the range
+     */
+    findElementsForRange(from: number, to: number): Element[];
+    /**
+     * Get bounding rectangles for a range of text, accounting for line wraps.
+     * Returns rects relative to the pages container.
+     *
+     * @param from - Start ProseMirror position
+     * @param to - End ProseMirror position
+     * @returns Array of DOMRect-like objects for the range
+     */
+    getRectsForRange(from: number, to: number): Array<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    /** Current zoom level (1 = 100%). */
+    zoom: number;
+    /**
+     * Offset of the pages container from its parent viewport.
+     * Use this to adjust coordinates when rendering overlays in the viewport
+     * container rather than directly in the pages container.
+     */
+    getContainerOffset(): {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Props passed to plugin panel components.
+ */
+interface PluginPanelProps<TState = unknown> {
+    /** Current ProseMirror editor view */
+    editorView: EditorView | null;
+    /** Current ProseMirror document */
+    doc: Node$1 | null;
+    /** Scroll editor to a specific position */
+    scrollToPosition: (pos: number) => void;
+    /** Select a range in the editor */
+    selectRange: (from: number, to: number) => void;
+    /** Plugin-specific state (managed by the plugin) */
+    pluginState: TState;
+    /** Width of the panel in pixels */
+    panelWidth: number;
+    /**
+     * Context for the rendered DOM (LayoutPainter output).
+     * Use this for positioning annotations relative to the visible pages.
+     * May be null if layout hasn't completed yet.
+     */
+    renderedDomContext: RenderedDomContext | null;
+}
+/**
+ * Configuration for plugin panel rendering.
+ */
+interface PanelConfig {
+    /** Where to render the panel */
+    position: 'left' | 'right' | 'bottom';
+    /** Default width/height of the panel */
+    defaultSize: number;
+    /** Minimum size */
+    minSize?: number;
+    /** Maximum size */
+    maxSize?: number;
+    /** Whether the panel is resizable */
+    resizable?: boolean;
+    /** Whether the panel can be collapsed */
+    collapsible?: boolean;
+    /** Initial collapsed state */
+    defaultCollapsed?: boolean;
+}
+/**
+ * Generic interface for editor plugins.
+ *
+ * Implement this interface to create custom plugins that can:
+ * - Add ProseMirror plugins (decorations, keymaps, etc.)
+ * - Render panels alongside the document
+ * - React to editor state changes
+ * - Inject custom styles
+ *
+ * @typeParam TState - The type of plugin-specific state
+ */
+interface EditorPlugin<TState = any> {
+    /** Unique plugin identifier */
+    id: string;
+    /** Display name for the plugin */
+    name: string;
+    /**
+     * ProseMirror plugins to register with the editor.
+     * These are merged with the editor's internal plugins.
+     */
+    proseMirrorPlugins?: Plugin[];
+    /**
+     * React component to render in the annotation panel area.
+     * Receives editor state and callbacks for interaction.
+     */
+    Panel?: React.ComponentType<PluginPanelProps<TState>>;
+    /**
+     * Configuration for the panel (position, size, etc.)
+     */
+    panelConfig?: PanelConfig;
+    /**
+     * Called when the editor state changes.
+     * Use this to update plugin-specific state based on document changes.
+     *
+     * @param view - The current ProseMirror editor view
+     * @returns The new plugin state, or undefined to keep existing state
+     */
+    onStateChange?: (view: EditorView) => TState | undefined;
+    /**
+     * Initialize plugin state when the plugin is first loaded.
+     *
+     * @param view - The ProseMirror editor view (may be null initially)
+     * @returns Initial plugin state
+     */
+    initialize?: (view: EditorView | null) => TState;
+    /**
+     * Called when the plugin is being destroyed.
+     * Use this for cleanup (subscriptions, timers, etc.)
+     */
+    destroy?: () => void;
+    /**
+     * CSS styles to inject for this plugin.
+     * Can be a string of CSS or a URL to a stylesheet.
+     */
+    styles?: string;
+    /**
+     * Render an overlay on top of the rendered pages.
+     * Use this for highlights, annotations, or other visual elements
+     * that need to be positioned relative to the document content.
+     *
+     * The overlay is rendered inside the viewport, positioned absolutely
+     * over the pages container.
+     *
+     * @param context - The rendered DOM context for position lookup
+     * @param state - Current plugin state
+     * @param editorView - The editor view for dispatching transactions
+     * @returns React node to render as overlay, or null
+     */
+    renderOverlay?: (context: RenderedDomContext, state: TState, editorView: EditorView | null) => ReactNode;
+}
+/**
+ * Context value provided to plugins and panels.
+ */
+interface PluginContext {
+    /** All registered plugins */
+    plugins: EditorPlugin[];
+    /** Current editor view */
+    editorView: EditorView | null;
+    /** Set the editor view (called by editor on mount) */
+    setEditorView: (view: EditorView | null) => void;
+    /** Get plugin state by plugin ID */
+    getPluginState: <T>(pluginId: string) => T | undefined;
+    /** Update plugin state */
+    setPluginState: <T>(pluginId: string, state: T) => void;
+    /** Scroll to a position in the editor */
+    scrollToPosition: (pos: number) => void;
+    /** Select a range in the editor */
+    selectRange: (from: number, to: number) => void;
+}
+/**
+ * Props for the PluginHost component.
+ */
+interface PluginHostProps {
+    /** Plugins to enable */
+    plugins: EditorPlugin[];
+    /** The editor component (passed as child) */
+    children: React.ReactElement;
+    /** Class name for the host container */
+    className?: string;
+}
+/**
+ * Ref interface for the PluginHost component.
+ */
+interface PluginHostRef {
+    /** Get plugin state by plugin ID */
+    getPluginState: <T>(pluginId: string) => T | undefined;
+    /** Update plugin state for a plugin */
+    setPluginState: <T>(pluginId: string, state: T) => void;
+    /** Get the current editor view */
+    getEditorView: () => EditorView | null;
+    /** Force a refresh of all plugin states */
+    refreshPluginStates: () => void;
+}
+
+/**
+ * DocxEditor props
+ */
+interface DocxEditorProps {
+    /** Document buffer (ArrayBuffer from file read) */
+    documentBuffer?: ArrayBuffer | null;
+    /** Pre-parsed document (alternative to documentBuffer) */
+    document?: Document | null;
+    /** Callback when document is saved */
+    onSave?: (buffer: ArrayBuffer) => void;
+    /** Callback when document changes */
+    onChange?: (document: Document) => void;
+    /** Callback when selection changes */
+    onSelectionChange?: (state: SelectionState | null) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Callback when fonts are loaded */
+    onFontsLoaded?: () => void;
+    /** External ProseMirror plugins (from PluginHost) */
+    externalPlugins?: prosemirror_state.Plugin[];
+    /** Callback when editor view is ready (for PluginHost) */
+    onEditorViewReady?: (view: prosemirror_view.EditorView) => void;
+    /** Theme for styling */
+    theme?: Theme | null;
+    /** Whether to show toolbar (default: true) */
+    showToolbar?: boolean;
+    /** Whether to show variable panel (default: true) */
+    showVariablePanel?: boolean;
+    /** Whether to show zoom control (default: true) */
+    showZoomControl?: boolean;
+    /** Whether to show page number indicator (default: true) */
+    showPageNumbers?: boolean;
+    /** Whether to enable interactive page navigation (default: true) */
+    enablePageNavigation?: boolean;
+    /** Position of page number indicator (default: 'bottom-center') */
+    pageNumberPosition?: PageIndicatorPosition | PageNavigatorPosition;
+    /** Variant of page number indicator (default: 'default') */
+    pageNumberVariant?: PageIndicatorVariant | PageNavigatorVariant;
+    /** Whether to show page margin guides/boundaries (default: false) */
+    showMarginGuides?: boolean;
+    /** Color for margin guides (default: '#c0c0c0') */
+    marginGuideColor?: string;
+    /** Whether to show horizontal ruler (default: false) */
+    showRuler?: boolean;
+    /** Unit for ruler display (default: 'inch') */
+    rulerUnit?: 'inch' | 'cm';
+    /** Initial zoom level (default: 1.0) */
+    initialZoom?: number;
+    /** Whether the editor is read-only */
+    readOnly?: boolean;
+    /** Custom toolbar actions */
+    toolbarExtra?: ReactNode;
+    /** Variable panel position (default: 'right') */
+    variablePanelPosition?: 'left' | 'right';
+    /** Variable descriptions */
+    variableDescriptions?: Record<string, string>;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Placeholder when no document */
+    placeholder?: ReactNode;
+    /** Loading indicator */
+    loadingIndicator?: ReactNode;
+    /** Whether to show print button in toolbar (default: true) */
+    showPrintButton?: boolean;
+    /** Print options for print preview */
+    printOptions?: PrintOptions;
+    /** Callback when print is triggered */
+    onPrint?: () => void;
+    /** Callback when content is copied */
+    onCopy?: () => void;
+    /** Callback when content is cut */
+    onCut?: () => void;
+    /** Callback when content is pasted */
+    onPaste?: () => void;
+    /**
+     * Use paginated editor mode (experimental).
+     * When enabled, shows true paginated editing with visible page breaks.
+     * When disabled (default), uses standard ProseMirror editor.
+     */
+    usePaginatedEditor?: boolean;
+    /**
+     * Callback when rendered DOM context is ready (for plugin overlays).
+     * Used by PluginHost to get access to the rendered page DOM for positioning.
+     */
+    onRenderedDomContextReady?: (context: RenderedDomContext) => void;
+    /**
+     * Plugin overlays to render inside the editor viewport.
+     * Passed from PluginHost to render plugin-specific overlays.
+     */
+    pluginOverlays?: ReactNode;
+}
+/**
+ * DocxEditor ref interface
+ */
+interface DocxEditorRef {
+    /** Get the DocumentAgent for programmatic access */
+    getAgent: () => DocumentAgent | null;
+    /** Get the current document */
+    getDocument: () => Document | null;
+    /** Get the ProseMirror editor ref */
+    getEditorRef: () => ProseMirrorEditorRef | null;
+    /** Save the document to buffer */
+    save: () => Promise<ArrayBuffer | null>;
+    /** Set zoom level */
+    setZoom: (zoom: number) => void;
+    /** Get current zoom level */
+    getZoom: () => number;
+    /** Focus the editor */
+    focus: () => void;
+    /** Get current page number */
+    getCurrentPage: () => number;
+    /** Get total page count */
+    getTotalPages: () => number;
+    /** Scroll to a specific page */
+    scrollToPage: (pageNumber: number) => void;
+    /** Open print preview */
+    openPrintPreview: () => void;
+    /** Print the document directly */
+    print: () => void;
+}
+/**
+ * DocxEditor - Complete DOCX editor component
+ */
+declare const DocxEditor: React__default.ForwardRefExoticComponent<DocxEditorProps & React__default.RefAttributes<DocxEditorRef>>;
+
+/**
+ * Google Fonts Loader
+ *
+ * Dynamically loads fonts from Google Fonts API with:
+ * - Loading state tracking
+ * - Duplicate prevention
+ * - Callback notifications
+ * - Font availability detection
+ */
+/**
+ * Load a font from Google Fonts
+ *
+ * @param fontFamily - The font family name to load
+ * @param options - Optional configuration
+ * @returns Promise resolving to true if font loaded successfully, false otherwise
+ */
+declare function loadFont(fontFamily: string, options?: {
+    weights?: number[];
+    styles?: ('normal' | 'italic')[];
+}): Promise<boolean>;
+/**
+ * Load multiple fonts from Google Fonts
+ *
+ * @param families - Array of font family names to load
+ * @param options - Optional configuration
+ * @returns Promise resolving when all fonts are loaded (or failed)
+ */
+declare function loadFonts(families: string[], options?: {
+    weights?: number[];
+    styles?: ('normal' | 'italic')[];
+}): Promise<void>;
+/**
+ * Check if a font is loaded
+ *
+ * @param fontFamily - The font family name to check
+ * @returns true if the font is loaded, false otherwise
+ */
+declare function isFontLoaded(fontFamily: string): boolean;
+/**
+ * Check if any fonts are currently loading
+ *
+ * @returns true if any fonts are loading, false otherwise
+ */
+declare function isLoading(): boolean;
+/**
+ * Get list of all loaded fonts
+ *
+ * @returns Array of loaded font family names
+ */
+declare function getLoadedFonts(): string[];
+/**
+ * Register a callback to be notified when fonts are loaded
+ *
+ * @param callback - Function to call when fonts are loaded
+ * @returns Cleanup function to remove the callback
+ */
+declare function onFontsLoaded(callback: (fonts: string[]) => void): () => void;
+/**
+ * Check if a font is available on the system using canvas measurement
+ *
+ * This uses the technique of comparing text width with the target font
+ * vs a known fallback font. If they differ, the font is available.
+ *
+ * @param fontFamily - The font family name to check
+ * @param fallbackFont - Fallback font to compare against
+ * @returns true if font is available, false otherwise
+ */
+declare function canRenderFont(fontFamily: string, fallbackFont?: string): boolean;
+/**
+ * Load a font from a raw buffer (e.g., embedded in DOCX)
+ *
+ * @param fontFamily - The font family name
+ * @param buffer - Font file buffer (TTF, OTF, WOFF, WOFF2)
+ * @param options - Font options
+ * @returns Promise resolving when font is loaded
+ */
+declare function loadFontFromBuffer(fontFamily: string, buffer: ArrayBuffer, options?: {
+    weight?: number | string;
+    style?: 'normal' | 'italic';
+}): Promise<boolean>;
+/**
+ * Preload a list of common document fonts
+ *
+ * This preloads fonts commonly used in DOCX documents that have
+ * Google Fonts equivalents.
+ */
+declare function preloadCommonFonts(): Promise<void>;
+
+/**
+ * List type
+ */
+type ListType = 'bullet' | 'numbered' | 'none';
+/**
+ * List state for the current selection
+ */
+interface ListState {
+    /** Type of list (bullet, numbered, or none) */
+    type: ListType;
+    /** Current list level (0-8) */
+    level: number;
+    /** Whether the selection is in a list */
+    isInList: boolean;
+    /** Numbering ID if in a list */
+    numId?: number;
+}
+/**
+ * Props for the ListButtons component
+ */
+interface ListButtonsProps {
+    /** Current list state of the selection */
+    listState?: ListState;
+    /** Callback when bullet list is toggled */
+    onBulletList?: () => void;
+    /** Callback when numbered list is toggled */
+    onNumberedList?: () => void;
+    /** Callback to increase list indent */
+    onIndent?: () => void;
+    /** Callback to decrease list indent */
+    onOutdent?: () => void;
+    /** Whether the buttons are disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Show indent/outdent buttons */
+    showIndentButtons?: boolean;
+    /** Compact mode (smaller buttons) */
+    compact?: boolean;
+    /** Whether the current paragraph has left indentation (for enabling outdent) */
+    hasIndent?: boolean;
+}
+/**
+ * List buttons component for bullet/numbered list controls
+ */
+declare function ListButtons({ listState, onBulletList, onNumberedList, onIndent, onOutdent, disabled, className, style, showIndentButtons, compact, hasIndent, }: ListButtonsProps): react_jsx_runtime.JSX.Element;
+/**
+ * Create a default list state (not in a list)
+ */
+declare function createDefaultListState(): ListState;
+
+/**
+ * TableToolbar Component
+ *
+ * Provides controls for editing tables:
+ * - Add row above/below
+ * - Add column left/right
+ * - Delete row/column
+ * - Merge cells
+ * - Split cell
+ *
+ * Shows when cursor is in a table.
+ */
+
+/**
+ * Table editing action types
+ */
+type TableAction = 'addRowAbove' | 'addRowBelow' | 'addColumnLeft' | 'addColumnRight' | 'deleteRow' | 'deleteColumn' | 'mergeCells' | 'splitCell' | 'deleteTable' | 'borderAll' | 'borderOutside' | 'borderInside' | 'borderNone' | 'borderTop' | 'borderBottom' | 'borderLeft' | 'borderRight' | {
+    type: 'cellFillColor';
+    color: string | null;
+} | {
+    type: 'borderColor';
+    color: string;
+};
+/**
+ * Selection within a table
+ */
+interface TableSelection {
+    /** Index of the table in the document */
+    tableIndex: number;
+    /** Row index (0-indexed) */
+    rowIndex: number;
+    /** Column index (0-indexed) */
+    columnIndex: number;
+    /** Selected cell range for multi-cell selection */
+    selectedCells?: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    };
+}
+/**
+ * Context for table operations
+ */
+interface TableContext {
+    /** The table being edited */
+    table: Table;
+    /** Current selection within the table */
+    selection: TableSelection;
+    /** Whether multiple cells are selected (for merge) */
+    hasMultiCellSelection: boolean;
+    /** Whether current cell can be split */
+    canSplitCell: boolean;
+    /** Total number of rows */
+    rowCount: number;
+    /** Total number of columns */
+    columnCount: number;
+}
+/**
+ * Props for TableToolbar component
+ */
+interface TableToolbarProps {
+    /** Current table context (null if cursor not in table) */
+    context: TableContext | null;
+    /** Callback when a table action is triggered */
+    onAction?: (action: TableAction, context: TableContext) => void;
+    /** Whether the toolbar is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Show labels next to icons */
+    showLabels?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Position of the toolbar */
+    position?: 'top' | 'floating';
+    /** Custom render for additional buttons */
+    children?: ReactNode;
+}
+/**
+ * TableToolbar - Shows table manipulation controls when cursor is in a table
+ */
+declare function TableToolbar({ context, onAction, disabled, className, style, showLabels, compact, position, children, }: TableToolbarProps): React__default.ReactElement | null;
+/**
+ * Create a table context from a table and selection
+ */
+declare function createTableContext(table: Table, selection: TableSelection): TableContext;
+/**
+ * Get column count from a table
+ */
+declare function getColumnCount(table: Table): number;
+/**
+ * Get cell at specific row and column index
+ */
+declare function getCellAt(table: Table, rowIndex: number, columnIndex: number): TableCell | null;
+/**
+ * Add a row to a table at the specified index
+ */
+declare function addRow(table: Table, atIndex: number, position?: 'before' | 'after'): Table;
+/**
+ * Delete a row from a table
+ */
+declare function deleteRow(table: Table, rowIndex: number): Table;
+/**
+ * Add a column to a table at the specified index
+ */
+declare function addColumn(table: Table, atIndex: number, position?: 'before' | 'after'): Table;
+/**
+ * Delete a column from a table
+ */
+declare function deleteColumn(table: Table, columnIndex: number): Table;
+/**
+ * Merge cells in a selection
+ */
+declare function mergeCells(table: Table, selection: TableSelection): Table;
+/**
+ * Split a merged cell
+ */
+declare function splitCell(table: Table, rowIndex: number, columnIndex: number): Table;
+
+/**
+ * Current formatting state of the selection
+ */
+interface SelectionFormatting {
+    /** Whether selected text is bold */
+    bold?: boolean;
+    /** Whether selected text is italic */
+    italic?: boolean;
+    /** Whether selected text is underlined */
+    underline?: boolean;
+    /** Whether selected text has strikethrough */
+    strike?: boolean;
+    /** Whether selected text is superscript */
+    superscript?: boolean;
+    /** Whether selected text is subscript */
+    subscript?: boolean;
+    /** Font family of selected text */
+    fontFamily?: string;
+    /** Font size of selected text (in half-points) */
+    fontSize?: number;
+    /** Text color */
+    color?: string;
+    /** Highlight color */
+    highlight?: string;
+    /** Paragraph alignment */
+    alignment?: ParagraphAlignment;
+    /** List state of the current paragraph */
+    listState?: ListState;
+    /** Line spacing in twips (OOXML value, 240 = single spacing) */
+    lineSpacing?: number;
+    /** Paragraph style ID */
+    styleId?: string;
+    /** Paragraph left indentation in twips */
+    indentLeft?: number;
+}
+/**
+ * Formatting action types
+ */
+type FormattingAction = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'superscript' | 'subscript' | 'clearFormatting' | 'bulletList' | 'numberedList' | 'indent' | 'outdent' | 'insertLink' | {
+    type: 'fontFamily';
+    value: string;
+} | {
+    type: 'fontSize';
+    value: number;
+} | {
+    type: 'textColor';
+    value: string;
+} | {
+    type: 'highlightColor';
+    value: string;
+} | {
+    type: 'alignment';
+    value: ParagraphAlignment;
+} | {
+    type: 'lineSpacing';
+    value: number;
+} | {
+    type: 'applyStyle';
+    value: string;
+};
+/**
+ * Props for the Toolbar component
+ */
+interface ToolbarProps {
+    /** Current formatting of the selection */
+    currentFormatting?: SelectionFormatting;
+    /** Callback when a formatting action is triggered */
+    onFormat?: (action: FormattingAction) => void;
+    /** Callback for undo action */
+    onUndo?: () => void;
+    /** Callback for redo action */
+    onRedo?: () => void;
+    /** Whether undo is available */
+    canUndo?: boolean;
+    /** Whether redo is available */
+    canRedo?: boolean;
+    /** Whether the toolbar is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Whether to enable keyboard shortcuts (default: true) */
+    enableShortcuts?: boolean;
+    /** Ref to the editor container for keyboard events */
+    editorRef?: React__default.RefObject<HTMLElement>;
+    /** Custom toolbar items to render */
+    children?: ReactNode;
+    /** Whether to show font family picker (default: true) */
+    showFontPicker?: boolean;
+    /** Whether to show font size picker (default: true) */
+    showFontSizePicker?: boolean;
+    /** Whether to show text color picker (default: true) */
+    showTextColorPicker?: boolean;
+    /** Whether to show highlight color picker (default: true) */
+    showHighlightColorPicker?: boolean;
+    /** Whether to show alignment buttons (default: true) */
+    showAlignmentButtons?: boolean;
+    /** Whether to show list buttons (default: true) */
+    showListButtons?: boolean;
+    /** Whether to show line spacing picker (default: true) */
+    showLineSpacingPicker?: boolean;
+    /** Whether to show style picker (default: true) */
+    showStylePicker?: boolean;
+    /** Document styles for the style picker */
+    documentStyles?: Style[];
+    /** Theme for the style picker */
+    theme?: Theme | null;
+    /** Callback for print action */
+    onPrint?: () => void;
+    /** Whether to show print button (default: true) */
+    showPrintButton?: boolean;
+    /** Whether to show zoom control (default: true) */
+    showZoomControl?: boolean;
+    /** Current zoom level (1.0 = 100%) */
+    zoom?: number;
+    /** Callback when zoom changes */
+    onZoomChange?: (zoom: number) => void;
+    /** Callback to refocus the editor after toolbar interactions */
+    onRefocusEditor?: () => void;
+    /** Callback when a table should be inserted */
+    onInsertTable?: (rows: number, columns: number) => void;
+    /** Whether to show table insert button (default: true) */
+    showTableInsert?: boolean;
+    /** Table context when cursor is in a table */
+    tableContext?: {
+        isInTable: boolean;
+        rowCount?: number;
+        columnCount?: number;
+        canSplitCell?: boolean;
+        hasMultiCellSelection?: boolean;
+    } | null;
+    /** Callback when a table action is triggered */
+    onTableAction?: (action: TableAction) => void;
+}
+/**
+ * Props for individual toolbar buttons
+ */
+interface ToolbarButtonProps {
+    /** Whether the button is in active/pressed state */
+    active?: boolean;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Button title/tooltip */
+    title?: string;
+    /** Click handler */
+    onClick?: () => void;
+    /** Button content */
+    children: ReactNode;
+    /** Additional CSS class name */
+    className?: string;
+    /** ARIA label for accessibility */
+    ariaLabel?: string;
+}
+/**
+ * Props for toolbar button groups
+ */
+interface ToolbarGroupProps$1 {
+    /** Group label for accessibility */
+    label?: string;
+    /** Group content */
+    children: ReactNode;
+    /** Additional CSS class name */
+    className?: string;
+}
+/**
+ * Individual toolbar button with shadcn styling
+ */
+declare function ToolbarButton({ active, disabled, title, onClick, children, className, ariaLabel, }: ToolbarButtonProps): react_jsx_runtime.JSX.Element;
+/**
+ * Toolbar button group with modern styling
+ */
+declare function ToolbarGroup$1({ label, children, className }: ToolbarGroupProps$1): react_jsx_runtime.JSX.Element;
+/**
+ * Toolbar separator
+ */
+declare function ToolbarSeparator(): react_jsx_runtime.JSX.Element;
+/**
+ * Formatting toolbar with all controls
+ */
+declare function Toolbar({ currentFormatting, onFormat, onUndo, onRedo, canUndo, canRedo, disabled, className, style, enableShortcuts, editorRef, children, showFontPicker, showFontSizePicker, showTextColorPicker, showHighlightColorPicker, showAlignmentButtons, showListButtons, showLineSpacingPicker, showStylePicker, documentStyles, theme, onPrint, showPrintButton, showZoomControl, zoom, onZoomChange, onRefocusEditor, onInsertTable, showTableInsert, tableContext, onTableAction, }: ToolbarProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * VariablePanel Component
+ *
+ * A panel that lists detected template variables with input fields for values:
+ * - Lists detected variables from document
+ * - Input field for each value
+ * - Apply button to process template
+ * - Shows empty state when no variables
+ */
+
+/**
+ * Props for VariablePanel component
+ */
+interface VariablePanelProps {
+    /** Detected variable names */
+    variables: string[];
+    /** Current variable values */
+    values?: Record<string, string>;
+    /** Callback when values change */
+    onValuesChange?: (values: Record<string, string>) => void;
+    /** Callback when Apply button is clicked */
+    onApply?: (values: Record<string, string>) => void;
+    /** Callback when Reset button is clicked */
+    onReset?: () => void;
+    /** Whether Apply is in progress */
+    isApplying?: boolean;
+    /** Whether the panel is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Panel title */
+    title?: string;
+    /** Show empty state message */
+    emptyMessage?: string;
+    /** Show variable count */
+    showCount?: boolean;
+    /** Collapsible panel */
+    collapsible?: boolean;
+    /** Initially collapsed */
+    defaultCollapsed?: boolean;
+    /** Show search filter */
+    showSearch?: boolean;
+    /** Custom variable descriptions */
+    descriptions?: Record<string, string>;
+}
+/**
+ * VariablePanel - Panel for managing template variable values
+ */
+declare function VariablePanel({ variables, values: externalValues, onValuesChange, onApply, onReset, isApplying, disabled, className, style, title, emptyMessage, showCount, collapsible, defaultCollapsed, showSearch, descriptions, }: VariablePanelProps): React__default.ReactElement;
+
+/**
+ * DocumentViewer Component
+ *
+ * Full paginated document viewer:
+ * - Renders all pages vertically
+ * - Gap between pages
+ * - Scrollable container
+ * - Loading state while parsing
+ * - Placeholder when no document
+ * - Zoom control
+ */
+
+/**
+ * Props for the DocumentViewer component
+ */
+interface DocumentViewerProps {
+    /** The document to render */
+    document?: Document | null;
+    /** Theme for resolving colors and fonts */
+    theme?: Theme | null;
+    /** Zoom level (1.0 = 100%) */
+    zoom?: number;
+    /** Gap between pages in pixels */
+    pageGap?: number;
+    /** Whether to show page shadows */
+    showPageShadows?: boolean;
+    /** Whether to show page numbers */
+    showPageNumbers?: boolean;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Custom loading indicator */
+    loadingIndicator?: ReactNode;
+    /** Custom placeholder for no document */
+    placeholder?: ReactNode;
+    /** Custom paragraph renderer */
+    renderParagraph?: (paragraph: Paragraph, index: number, pageContent: PageContent) => ReactNode;
+    /** Custom table renderer */
+    renderTable?: (table: Table, index: number, pageContent: PageContent) => ReactNode;
+    /** Custom header renderer */
+    renderHeader?: (header: HeaderFooter, pageNumber: number) => ReactNode;
+    /** Custom footer renderer */
+    renderFooter?: (footer: HeaderFooter, pageNumber: number) => ReactNode;
+    /** Callback when page becomes visible */
+    onPageVisible?: (pageNumber: number) => void;
+    /** Callback when document is clicked */
+    onDocumentClick?: (e: React__default.MouseEvent, page: Page | null) => void;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * DocumentViewer component - renders paginated document view
+ */
+declare function DocumentViewer({ document, theme, zoom, pageGap, showPageShadows, showPageNumbers, isLoading, loadingIndicator, placeholder, renderParagraph, renderTable, renderHeader, renderFooter, onPageVisible, onDocumentClick, className, style: additionalStyle, }: DocumentViewerProps): React__default.ReactElement;
+/**
+ * Scroll to a specific page
+ */
+declare function scrollToPage(containerRef: React__default.RefObject<HTMLDivElement>, pageNumber: number, layoutResult: PageLayoutResult | null, zoom?: number, pageGap?: number): void;
+/**
+ * Get visible page numbers
+ */
+declare function getVisiblePages(containerRef: React__default.RefObject<HTMLDivElement>, layoutResult: PageLayoutResult | null, zoom?: number, pageGap?: number): number[];
+/**
+ * Calculate zoom to fit page width
+ */
+declare function calculateFitWidthZoom(containerWidth: number, pageWidth: number, padding?: number): number;
+/**
+ * Calculate zoom to fit whole page
+ */
+declare function calculateFitPageZoom(containerWidth: number, containerHeight: number, pageWidth: number, pageHeight: number, padding?: number): number;
+
+/**
+ * Context Menu Component
+ *
+ * Right-click context menu for AI actions on selected text.
+ * Shows AI options like rewrite, expand, summarize, translate, etc.
+ */
+
+/**
+ * Context menu props
+ */
+interface ContextMenuProps {
+    /** Whether the menu is visible */
+    isOpen: boolean;
+    /** Menu position */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Selected text */
+    selectedText: string;
+    /** Selection context for AI operations */
+    selectionContext?: SelectionContext;
+    /** Callback when an action is selected */
+    onAction: (action: AIAction, customPrompt?: string) => void;
+    /** Callback when menu is closed */
+    onClose: () => void;
+    /** Available actions (defaults to DEFAULT_AI_ACTIONS) */
+    actions?: AIAction[];
+    /** Whether to show custom prompt option */
+    showCustomPrompt?: boolean;
+    /** Additional className */
+    className?: string;
+}
+declare const ContextMenu: React__default.FC<ContextMenuProps>;
+/**
+ * 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;
+};
+/**
+ * Get action shortcuts
+ */
+declare function getActionShortcut(action: AIAction): string | undefined;
+/**
+ * Check if action is available for selection
+ */
+declare function isActionAvailable(_action: AIAction, selectedText: string, _selectionContext?: SelectionContext): boolean;
+/**
+ * Get default actions for selection
+ */
+declare function getDefaultActions(): AIAction[];
+/**
+ * Get all available actions
+ */
+declare function getAllActions(): AIAction[];
+
+/**
+ * Response Preview Component
+ *
+ * Shows AI response preview with diff view before applying changes.
+ * Allows user to accept, reject, or edit the response.
+ */
+
+/**
+ * Response preview props
+ */
+interface ResponsePreviewProps {
+    /** Original selected text */
+    originalText: string;
+    /** AI response (or null if loading/error) */
+    response: AgentResponse | null;
+    /** Action that was performed */
+    action: AIAction;
+    /** Whether the response is loading */
+    isLoading: boolean;
+    /** Error message if request failed */
+    error?: string;
+    /** Callback when user accepts the change */
+    onAccept: (newText: string) => void;
+    /** Callback when user rejects the change */
+    onReject: () => void;
+    /** Callback when user wants to retry */
+    onRetry?: () => void;
+    /** Allow editing before accepting */
+    allowEdit?: boolean;
+    /** Show diff view */
+    showDiff?: boolean;
+    /** Additional className */
+    className?: string;
+    /** Position for the preview */
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+declare const ResponsePreview: React__default.FC<ResponsePreviewProps>;
+/**
+ * State for response preview
+ */
+interface ResponsePreviewState {
+    isVisible: boolean;
+    originalText: string;
+    response: AgentResponse | null;
+    action: AIAction;
+    isLoading: boolean;
+    error?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * 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;
+};
+/**
+ * Create a mock response for testing
+ */
+declare function createMockResponse(newText: string, warnings?: string[]): AgentResponse;
+/**
+ * Create an error response
+ */
+declare function createErrorResponse(error: string): AgentResponse;
+
+/**
+ * Text Context Menu Component
+ *
+ * Right-click context menu for text editing operations.
+ * Shows Cut, Copy, Paste, and other text editing options.
+ */
+
+/**
+ * Context menu action types
+ */
+type TextContextAction = 'cut' | 'copy' | 'paste' | 'pasteAsPlainText' | 'selectAll' | 'delete' | 'separator';
+/**
+ * Menu item configuration
+ */
+interface TextContextMenuItem {
+    /** Action type */
+    action: TextContextAction;
+    /** Display label */
+    label: string;
+    /** Keyboard shortcut hint */
+    shortcut?: string;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Whether to show divider after this item */
+    dividerAfter?: boolean;
+}
+/**
+ * Context menu props
+ */
+interface TextContextMenuProps {
+    /** Whether the menu is visible */
+    isOpen: boolean;
+    /** Menu position */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Whether there's a selection (enables copy/cut) */
+    hasSelection: boolean;
+    /** Whether the editor is editable (enables paste/cut/delete) */
+    isEditable: boolean;
+    /** Whether clipboard has content (enables paste) */
+    hasClipboardContent?: boolean;
+    /** Callback when an action is selected */
+    onAction: (action: TextContextAction) => void;
+    /** Callback when menu is closed */
+    onClose: () => void;
+    /** Custom menu items (overrides default) */
+    items?: TextContextMenuItem[];
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Hook options for text context menu
+ */
+interface UseTextContextMenuOptions {
+    /** Whether the context menu is enabled */
+    enabled?: boolean;
+    /** Whether the editor is editable */
+    isEditable?: boolean;
+    /** Container element ref */
+    containerRef?: React__default.RefObject<HTMLElement>;
+    /** Callback when an action is triggered */
+    onAction?: (action: TextContextAction) => void;
+}
+/**
+ * Hook return value
+ */
+interface UseTextContextMenuReturn {
+    /** Whether the menu is open */
+    isOpen: boolean;
+    /** Menu position */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Whether there's a text selection */
+    hasSelection: boolean;
+    /** Open the context menu */
+    openMenu: (event: React__default.MouseEvent | MouseEvent) => void;
+    /** Close the context menu */
+    closeMenu: () => void;
+    /** Handle action selection */
+    handleAction: (action: TextContextAction) => void;
+    /** Context menu event handler for onContextMenu prop */
+    onContextMenu: (event: React__default.MouseEvent) => void;
+}
+declare const TextContextMenu: React__default.FC<TextContextMenuProps>;
+/**
+ * Hook to manage text context menu state
+ */
+declare function useTextContextMenu(options?: UseTextContextMenuOptions): UseTextContextMenuReturn;
+/**
+ * Get action label
+ */
+declare function getTextActionLabel(action: TextContextAction): string;
+/**
+ * Get action shortcut
+ */
+declare function getTextActionShortcut(action: TextContextAction): string;
+/**
+ * Get default menu items
+ */
+declare function getDefaultTextContextMenuItems(): TextContextMenuItem[];
+/**
+ * Check if action is available
+ */
+declare function isTextActionAvailable(action: TextContextAction, hasSelection: boolean, isEditable: boolean): boolean;
+
+/**
+ * Error severity levels
+ */
+type ErrorSeverity = 'error' | 'warning' | 'info';
+/**
+ * Error notification
+ */
+interface ErrorNotification {
+    id: string;
+    message: string;
+    severity: ErrorSeverity;
+    details?: string;
+    timestamp: number;
+    dismissed?: boolean;
+}
+/**
+ * Error context value
+ */
+interface ErrorContextValue {
+    /** Current notifications */
+    notifications: ErrorNotification[];
+    /** Show an error notification */
+    showError: (message: string, details?: string) => void;
+    /** Show a warning notification */
+    showWarning: (message: string, details?: string) => void;
+    /** Show an info notification */
+    showInfo: (message: string, details?: string) => void;
+    /** Dismiss a notification */
+    dismissNotification: (id: string) => void;
+    /** Clear all notifications */
+    clearNotifications: () => void;
+}
+/**
+ * Error boundary props
+ */
+interface ErrorBoundaryProps {
+    /** Child components to render */
+    children: ReactNode;
+    /** Custom fallback UI */
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    /** Callback when error occurs */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /** Whether to show error details */
+    showDetails?: boolean;
+}
+/**
+ * Error boundary state
+ */
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+}
+/**
+ * Hook to use error notifications
+ */
+declare function useErrorNotifications(): ErrorContextValue;
+/**
+ * Error notification provider
+ */
+declare function ErrorProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Error Boundary class component
+ *
+ * Catches render errors in child components and displays fallback UI.
+ */
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    resetError: () => void;
+    render(): ReactNode;
+}
+interface ParseErrorDisplayProps {
+    message: string;
+    details?: string;
+    onRetry?: () => void;
+    className?: string;
+}
+/**
+ * Parse error display component
+ *
+ * Shows a helpful message for DOCX parsing errors.
+ */
+declare function ParseErrorDisplay({ message, details, onRetry, className, }: ParseErrorDisplayProps): React__default.ReactElement;
+interface UnsupportedFeatureWarningProps {
+    feature: string;
+    description?: string;
+    className?: string;
+}
+/**
+ * Unsupported feature warning component
+ *
+ * Shows a non-blocking warning for unsupported features.
+ */
+declare function UnsupportedFeatureWarning({ feature, description, className, }: UnsupportedFeatureWarningProps): React__default.ReactElement;
+/**
+ * Check if an error is a parse error
+ */
+declare function isParseError(error: Error): boolean;
+/**
+ * Get user-friendly error message
+ */
+declare function getUserFriendlyMessage(error: Error): string;
+
+/**
+ * Zoom Control Component (Radix UI)
+ *
+ * A dropdown for controlling document zoom level using Radix Select.
+ */
+interface ZoomLevel {
+    value: number;
+    label: string;
+}
+interface ZoomControlProps {
+    value?: number;
+    onChange?: (zoom: number) => void;
+    levels?: ZoomLevel[];
+    disabled?: boolean;
+    className?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    showButtons?: boolean;
+    persistZoom?: boolean;
+    storageKey?: string;
+    compact?: boolean;
+}
+declare function ZoomControl({ value, onChange, levels, disabled, className, compact, }: ZoomControlProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Font Picker Component (Radix UI)
+ *
+ * A dropdown selector for choosing font families using Radix Select.
+ */
+interface FontOption {
+    name: string;
+    fontFamily: string;
+    category?: 'sans-serif' | 'serif' | 'monospace' | 'other';
+}
+interface FontPickerProps {
+    value?: string;
+    onChange?: (fontFamily: string) => void;
+    fonts?: FontOption[];
+    disabled?: boolean;
+    className?: string;
+    placeholder?: string;
+    width?: number | string;
+    showPreview?: boolean;
+}
+declare function FontPicker({ value, onChange, fonts, disabled, className, placeholder, width, showPreview, }: FontPickerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * 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 {
+    value?: number;
+    onChange?: (size: number) => void;
+    sizes?: number[];
+    disabled?: boolean;
+    className?: string;
+    placeholder?: string;
+    width?: number | string;
+    minSize?: number;
+    maxSize?: number;
+}
+declare function FontSizePicker({ value, onChange, sizes, disabled, className, placeholder, minSize, maxSize, }: FontSizePickerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Line Spacing Picker Component (Radix UI)
+ *
+ * A dropdown selector for choosing line spacing values using Radix Select.
+ * Styled like Google Docs with options: Single, 1.15, 1.5, Double
+ */
+interface LineSpacingOption {
+    label: string;
+    value: number;
+    twipsValue: number;
+}
+interface LineSpacingPickerProps {
+    value?: number;
+    onChange?: (twipsValue: number) => void;
+    options?: LineSpacingOption[];
+    disabled?: boolean;
+    className?: string;
+    width?: number | string;
+}
+declare function LineSpacingPicker({ value, onChange, options, disabled, className, width, }: LineSpacingPickerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Color option for the color grid
+ */
+interface ColorOption {
+    /** Display name for the color */
+    name: string;
+    /** Hex value (without #) */
+    hex: string;
+    /** Is this a theme color? */
+    isTheme?: boolean;
+    /** Theme color slot if applicable */
+    themeSlot?: string;
+}
+/**
+ * Props for the ColorPicker component
+ */
+interface ColorPickerProps {
+    /** Current color value */
+    value?: string;
+    /** Callback when color is selected */
+    onChange?: (color: string) => void;
+    /** Type of color picker */
+    type?: 'text' | 'highlight';
+    /** Theme for resolving theme colors */
+    theme?: Theme | null;
+    /** Custom colors to display */
+    colors?: ColorOption[];
+    /** Whether the picker is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Placeholder/tooltip text */
+    title?: string;
+    /** Custom button content */
+    children?: ReactNode;
+    /** Width of the dropdown */
+    dropdownWidth?: number;
+    /** Show "No Color" option */
+    showNoColor?: boolean;
+    /** Show "More Colors" option for custom input */
+    showMoreColors?: boolean;
+}
+/**
+ * Color picker component with dropdown grid
+ */
+declare function ColorPicker({ value, onChange, type, theme: _theme, colors, disabled, className, style, title, children, dropdownWidth, showNoColor, showMoreColors, }: ColorPickerProps): react_jsx_runtime.JSX.Element;
+
+interface StyleOption {
+    styleId: string;
+    name: string;
+    type: StyleType;
+    isDefault?: boolean;
+    qFormat?: boolean;
+    priority?: number;
+    /** Font size in half-points for visual preview */
+    fontSize?: number;
+    /** Bold styling */
+    bold?: boolean;
+    /** Italic styling */
+    italic?: boolean;
+    /** Text color (RGB hex) */
+    color?: string;
+}
+interface StylePickerProps {
+    value?: string;
+    onChange?: (styleId: string) => void;
+    styles?: Style[];
+    theme?: Theme | null;
+    disabled?: boolean;
+    className?: string;
+    placeholder?: string;
+    width?: number | string;
+    showPreview?: boolean;
+    styleTypes?: StyleType[];
+    quickFormatOnly?: boolean;
+}
+declare function StylePicker({ value, onChange, styles, disabled, className, placeholder, width, quickFormatOnly, }: StylePickerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Props for the AlignmentButtons component
+ */
+interface AlignmentButtonsProps {
+    /** Current alignment value */
+    value?: ParagraphAlignment;
+    /** Callback when alignment is changed */
+    onChange?: (alignment: ParagraphAlignment) => void;
+    /** Whether the buttons are disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Show labels next to icons */
+    showLabels?: boolean;
+    /** Compact mode (smaller buttons) */
+    compact?: boolean;
+}
+/**
+ * Alignment buttons component for paragraph alignment controls
+ */
+declare function AlignmentButtons({ value, onChange, disabled, className, style, showLabels, compact, }: AlignmentButtonsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * HorizontalRuler Component
+ *
+ * A horizontal ruler that displays above the document with:
+ * - Page width scale with tick marks
+ * - Left and right margin indicators
+ * - First line indent indicator
+ * - Optional dragging to adjust margins
+ * - Support for zoom levels
+ *
+ * Similar to Microsoft Word's horizontal ruler.
+ */
+
+/**
+ * Props for the HorizontalRuler component
+ */
+interface HorizontalRulerProps {
+    /** Section properties for page layout */
+    sectionProps?: SectionProperties | null;
+    /** Zoom level (1.0 = 100%) */
+    zoom?: number;
+    /** Whether margins can be dragged to adjust */
+    editable?: boolean;
+    /** Callback when left margin changes (in twips) */
+    onLeftMarginChange?: (marginTwips: number) => void;
+    /** Callback when right margin changes (in twips) */
+    onRightMarginChange?: (marginTwips: number) => void;
+    /** Callback when first line indent changes (in twips) */
+    onFirstLineIndentChange?: (indentTwips: number) => void;
+    /** Show first line indent marker */
+    showFirstLineIndent?: boolean;
+    /** First line indent value (in twips) */
+    firstLineIndent?: number;
+    /** Unit to display (inches or cm) */
+    unit?: 'inch' | 'cm';
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * HorizontalRuler - displays a ruler with margin markers
+ */
+declare function HorizontalRuler({ sectionProps, zoom, editable, onLeftMarginChange, onRightMarginChange, onFirstLineIndentChange, showFirstLineIndent, firstLineIndent, unit, className, style, }: HorizontalRulerProps): React__default.ReactElement;
+/**
+ * Convert a ruler position to margin value
+ */
+declare function positionToMargin(positionPx: number, side: 'left' | 'right', pageWidthPx: number, zoom: number): number;
+/**
+ * Get ruler dimensions based on section properties
+ */
+declare function getRulerDimensions(sectionProps?: SectionProperties | null, zoom?: number): {
+    width: number;
+    leftMargin: number;
+    rightMargin: number;
+    contentWidth: number;
+};
+/**
+ * Get margin value in display units
+ */
+declare function getMarginInUnits(marginTwips: number, unit: 'inch' | 'cm'): string;
+/**
+ * Parse a margin value from display units to twips
+ */
+declare function parseMarginFromUnits(value: string, unit: 'inch' | 'cm'): number | null;
+
+/**
+ * TableBorderPicker Component
+ *
+ * UI for changing table/cell border styling:
+ * - Border style (none, single, double, dashed, dotted, etc.)
+ * - Border color
+ * - Border width
+ * - Which borders to apply (all, top, bottom, left, right, inside, outside)
+ */
+
+/**
+ * Border style options (OOXML border styles)
+ */
+type BorderStyleType = 'none' | 'single' | 'double' | 'dotted' | 'dashed' | 'dashSmallGap' | 'dotDash' | 'dotDotDash' | 'triple' | 'thick' | 'thickThinSmallGap' | 'thinThickSmallGap';
+/**
+ * Border position options
+ */
+type BorderPosition = 'all' | 'outside' | 'inside' | 'top' | 'bottom' | 'left' | 'right' | 'insideHorizontal' | 'insideVertical' | 'none';
+/**
+ * Border configuration
+ */
+interface BorderConfig {
+    style: BorderStyleType;
+    color: string;
+    width: number;
+}
+/**
+ * Props for TableBorderPicker
+ */
+interface TableBorderPickerProps {
+    /** Current border configuration */
+    currentBorder?: BorderConfig;
+    /** Callback when border is applied */
+    onApply?: (position: BorderPosition, config: BorderConfig) => void;
+    /** Whether the picker is disabled */
+    disabled?: boolean;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Compact mode */
+    compact?: boolean;
+}
+/**
+ * Available border styles
+ */
+declare const BORDER_STYLES: {
+    value: BorderStyleType;
+    label: string;
+}[];
+/**
+ * Available border widths (in eighths of a point)
+ */
+declare const BORDER_WIDTHS: {
+    value: number;
+    label: string;
+}[];
+/**
+ * Border position options
+ */
+declare const BORDER_POSITIONS: {
+    value: BorderPosition;
+    label: string;
+    icon: ReactNode;
+}[];
+/**
+ * Default border configuration
+ */
+declare const DEFAULT_BORDER_CONFIG: BorderConfig;
+/**
+ * TableBorderPicker - UI for styling table/cell borders
+ */
+declare function TableBorderPicker({ currentBorder, onApply, disabled, className, style: additionalStyle, compact, }: TableBorderPickerProps): React__default.ReactElement;
+/**
+ * Map OOXML border style to CSS border-style
+ */
+declare function mapStyleToCss(style: BorderStyleType): string;
+/**
+ * Create BorderSpec from BorderConfig
+ */
+declare function createBorderSpec(config: BorderConfig): BorderSpec;
+/**
+ * Create BorderConfig from BorderSpec
+ */
+declare function createBorderConfig(spec: BorderSpec | undefined): BorderConfig;
+/**
+ * Get border position label
+ */
+declare function getBorderPositionLabel(position: BorderPosition): string;
+/**
+ * Get available border styles
+ */
+declare function getAvailableBorderStyles(): typeof BORDER_STYLES;
+/**
+ * Get available border widths
+ */
+declare function getAvailableBorderWidths(): typeof BORDER_WIDTHS;
+
+/**
+ * CellBackgroundPicker Component
+ *
+ * UI for changing table cell background/shading color.
+ * Provides a color grid similar to the text highlight picker but
+ * optimized for table cell backgrounds.
+ */
+
+/**
+ * Color option for the picker
+ */
+interface CellColorOption {
+    /** Hex color value */
+    hex: string;
+    /** Display name */
+    name: string;
+}
+/**
+ * Props for CellBackgroundPicker
+ */
+interface CellBackgroundPickerProps {
+    /** Current background color (hex) */
+    value?: string | null;
+    /** Callback when color is selected */
+    onChange?: (color: string | null) => void;
+    /** Custom color options */
+    colors?: CellColorOption[];
+    /** Whether the picker is disabled */
+    disabled?: boolean;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Show "No Fill" option (default: true) */
+    showNoFill?: boolean;
+    /** Show custom color input (default: true) */
+    showCustomColor?: boolean;
+    /** Compact mode for toolbar */
+    compact?: boolean;
+}
+/**
+ * Default cell background colors
+ * Common colors for table cell backgrounds
+ */
+declare const DEFAULT_CELL_COLORS: CellColorOption[];
+/**
+ * CellBackgroundPicker - Color picker for table cell backgrounds
+ */
+declare function CellBackgroundPicker({ value, onChange, colors, disabled, className, style: additionalStyle, showNoFill, showCustomColor, compact, }: CellBackgroundPickerProps): React__default.ReactElement;
+/**
+ * Get default cell colors
+ */
+declare function getDefaultCellColors(): CellColorOption[];
+/**
+ * Create a color option
+ */
+declare function createCellColorOption(hex: string, name?: string): CellColorOption;
+/**
+ * Check if color is in the default palette
+ */
+declare function isDefaultCellColor(hex: string): boolean;
+/**
+ * Get color name from hex
+ */
+declare function getCellColorName(hex: string): string;
+/**
+ * Create ShadingProperties from color
+ */
+declare function createShadingFromColor(color: string | null): ShadingProperties | undefined;
+/**
+ * Get color from ShadingProperties
+ */
+declare function getColorFromShading(shading: ShadingProperties | undefined): string | null;
+/**
+ * Get contrasting text color (black or white) for a background
+ */
+declare function getContrastingTextColor(bgHex: string): string;
+
+/**
+ * Unsaved Changes Indicator Component
+ *
+ * Visual indicator that shows when document has unsaved changes.
+ * Features:
+ * - Configurable appearance (dot, badge, text)
+ * - Pulse animation option for visibility
+ * - Hook for tracking changes
+ * - Browser beforeunload warning
+ */
+
+/**
+ * Indicator variant type
+ */
+type IndicatorVariant = 'dot' | 'badge' | 'text' | 'icon';
+/**
+ * Indicator position type
+ */
+type IndicatorPosition = 'inline' | 'absolute-top-right' | 'absolute-top-left';
+/**
+ * Unsaved indicator props
+ */
+interface UnsavedIndicatorProps {
+    /** Whether there are unsaved changes */
+    hasUnsavedChanges: boolean;
+    /** Variant of the indicator */
+    variant?: IndicatorVariant;
+    /** Position of the indicator */
+    position?: IndicatorPosition;
+    /** Whether to show pulse animation */
+    showPulse?: boolean;
+    /** Custom label for text variant */
+    label?: string;
+    /** Custom saved label for text variant */
+    savedLabel?: string;
+    /** Whether to show indicator when saved (always show) */
+    showWhenSaved?: boolean;
+    /** Custom color for unsaved state */
+    unsavedColor?: string;
+    /** Custom color for saved state */
+    savedColor?: string;
+    /** Size in pixels (for dot/icon) */
+    size?: number;
+    /** Additional className */
+    className?: string;
+    /** Additional inline styles */
+    style?: React__default.CSSProperties;
+    /** Click handler */
+    onClick?: () => void;
+    /** Title/tooltip text */
+    title?: string;
+}
+/**
+ * Hook options for tracking unsaved changes
+ */
+interface UseUnsavedChangesOptions {
+    /** The document to track */
+    document?: Document | null;
+    /** Whether to warn before leaving page */
+    warnBeforeLeave?: boolean;
+    /** Custom warning message */
+    warningMessage?: string;
+    /** Whether tracking is enabled */
+    enabled?: boolean;
+    /** Callback when changes status changes */
+    onChangeStatusChange?: (hasChanges: boolean) => void;
+}
+/**
+ * Hook return value
+ */
+interface UseUnsavedChangesReturn {
+    /** Whether there are unsaved changes */
+    hasUnsavedChanges: boolean;
+    /** Mark the document as saved (resets change tracking) */
+    markAsSaved: () => void;
+    /** Mark the document as changed */
+    markAsChanged: () => void;
+    /** Reset tracking (resets baseline) */
+    resetTracking: (newDocument?: Document | null) => void;
+    /** The last saved document snapshot */
+    lastSavedDocument: Document | null;
+    /** Number of changes since last save */
+    changeCount: number;
+}
+declare const UnsavedIndicator: React__default.FC<UnsavedIndicatorProps>;
+/**
+ * Hook to track unsaved changes in a document
+ */
+declare function useUnsavedChanges(options?: UseUnsavedChangesOptions): UseUnsavedChangesReturn;
+/**
+ * Get indicator variant label
+ */
+declare function getVariantLabel(variant: IndicatorVariant): string;
+/**
+ * Get all indicator variants
+ */
+declare function getAllVariants(): IndicatorVariant[];
+/**
+ * Get all indicator positions
+ */
+declare function getAllPositions(): IndicatorPosition[];
+/**
+ * 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;
+};
+
+/**
+ * Loading Indicator Component
+ *
+ * Displays loading states for operations with configurable appearance.
+ * Features:
+ * - Multiple spinner styles (spinner, dots, bar, pulse)
+ * - Overlay mode for blocking UI during operations
+ * - Inline mode for subtle loading indication
+ * - Progress bar variant
+ * - Hook for managing loading states
+ */
+
+/**
+ * Loading indicator variant
+ */
+type LoadingVariant = 'spinner' | 'dots' | 'bar' | 'pulse' | 'progress';
+/**
+ * Loading indicator size
+ */
+type LoadingSize = 'small' | 'medium' | 'large';
+/**
+ * Loading indicator props
+ */
+interface LoadingIndicatorProps {
+    /** Whether loading is active */
+    isLoading: boolean;
+    /** Variant of the loading indicator */
+    variant?: LoadingVariant;
+    /** Size of the indicator */
+    size?: LoadingSize;
+    /** Loading message to display */
+    message?: string;
+    /** Whether to show as full-screen overlay */
+    overlay?: boolean;
+    /** Overlay background opacity (0-1) */
+    overlayOpacity?: number;
+    /** Progress percentage (0-100) for progress variant */
+    progress?: number;
+    /** Show progress percentage text */
+    showProgressText?: boolean;
+    /** Custom color */
+    color?: string;
+    /** Additional className */
+    className?: string;
+    /** Additional inline styles */
+    style?: React__default.CSSProperties;
+}
+/**
+ * Options for useLoading hook
+ */
+interface UseLoadingOptions {
+    /** Initial loading state */
+    initialLoading?: boolean;
+    /** Minimum loading duration in ms (prevents flash) */
+    minDuration?: number;
+    /** Callback when loading starts */
+    onStart?: () => void;
+    /** Callback when loading ends */
+    onEnd?: () => void;
+}
+/**
+ * Return value of useLoading hook
+ */
+interface UseLoadingReturn {
+    /** Current loading state */
+    isLoading: boolean;
+    /** Current message */
+    message: string | null;
+    /** Current progress (0-100) */
+    progress: number;
+    /** Start loading with optional message */
+    startLoading: (message?: string) => void;
+    /** Stop loading */
+    stopLoading: () => void;
+    /** Update progress (0-100) */
+    setProgress: (progress: number) => void;
+    /** Update message */
+    setMessage: (message: string | null) => void;
+    /** Wrap an async operation with loading state */
+    withLoading: <T>(operation: () => Promise<T>, message?: string) => Promise<T>;
+}
+/**
+ * Loading operation state
+ */
+interface LoadingOperation {
+    id: string;
+    message?: string;
+    progress?: number;
+    startTime: number;
+}
+declare const LoadingIndicator: React__default.FC<LoadingIndicatorProps>;
+/**
+ * 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;
+};
+/**
+ * Get loading variant label
+ */
+declare function getLoadingVariantLabel(variant: LoadingVariant): string;
+/**
+ * Get all loading variants
+ */
+declare function getAllLoadingVariants(): LoadingVariant[];
+/**
+ * Get all loading sizes
+ */
+declare function getAllLoadingSizes(): LoadingSize[];
+/**
+ * Create a delay promise for testing loading states
+ */
+declare function delay(ms: number): Promise<void>;
+
+/**
+ * Responsive Toolbar Component
+ *
+ * A responsive toolbar wrapper that collapses items into an overflow menu
+ * when the screen is narrow.
+ *
+ * Features:
+ * - Automatically measures available space
+ * - Moves items to overflow menu when they don't fit
+ * - Priority-based item ordering
+ * - Configurable breakpoints
+ * - ResizeObserver for dynamic resizing
+ */
+
+/**
+ * Priority level for toolbar items
+ * Lower numbers = higher priority (shown first, hidden last)
+ */
+type ToolbarItemPriority = 1 | 2 | 3 | 4 | 5;
+/**
+ * Toolbar item configuration
+ */
+interface ToolbarItem {
+    /** Unique identifier */
+    id: string;
+    /** The content to render */
+    content: ReactNode;
+    /** Priority level (1 = highest, 5 = lowest) */
+    priority?: ToolbarItemPriority;
+    /** Minimum width in pixels (for measuring) */
+    minWidth?: number;
+    /** Whether this item should never be hidden */
+    alwaysVisible?: boolean;
+    /** Whether to show separator after this item */
+    separatorAfter?: boolean;
+    /** Group name for keeping items together */
+    group?: string;
+}
+/**
+ * Props for ResponsiveToolbar component
+ */
+interface ResponsiveToolbarProps {
+    /** Toolbar items */
+    items: ToolbarItem[];
+    /** Additional items for overflow menu only */
+    overflowItems?: ToolbarItem[];
+    /** Whether to show overflow button even when all items fit */
+    alwaysShowOverflow?: boolean;
+    /** Custom overflow button renderer */
+    renderOverflowButton?: (itemCount: number, isOpen: boolean, onClick: () => void) => ReactNode;
+    /** Custom overflow menu renderer */
+    renderOverflowMenu?: (items: ToolbarItem[], onClose: () => void) => ReactNode;
+    /** Gap between items in pixels */
+    itemGap?: number;
+    /** Padding for the toolbar */
+    padding?: number | string;
+    /** Minimum width for overflow button */
+    overflowButtonWidth?: number;
+    /** Additional className */
+    className?: string;
+    /** Additional styles */
+    style?: CSSProperties;
+    /** Height of the toolbar */
+    height?: number | string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Border styles */
+    borderBottom?: string;
+}
+/**
+ * Options for useResponsiveToolbar hook
+ */
+interface UseResponsiveToolbarOptions {
+    /** Container ref */
+    containerRef: React__default.RefObject<HTMLElement>;
+    /** Total items */
+    items: ToolbarItem[];
+    /** Gap between items */
+    itemGap?: number;
+    /** Width reserved for overflow button */
+    overflowButtonWidth?: number;
+}
+/**
+ * Return value of useResponsiveToolbar hook
+ */
+interface UseResponsiveToolbarReturn {
+    /** Items that fit in visible area */
+    visibleItems: ToolbarItem[];
+    /** Items in overflow menu */
+    overflowItems: ToolbarItem[];
+    /** Whether overflow menu is needed */
+    hasOverflow: boolean;
+    /** Force a recalculation */
+    recalculate: () => void;
+}
+/**
+ * Hook to calculate which items fit in the toolbar
+ */
+declare function useResponsiveToolbar(options: UseResponsiveToolbarOptions): UseResponsiveToolbarReturn;
+declare const ResponsiveToolbar: React__default.FC<ResponsiveToolbarProps>;
+interface ToolbarGroupProps {
+    /** Group items */
+    children: ReactNode;
+    /** Gap between items */
+    gap?: number;
+    /** Whether to show separator after group */
+    separatorAfter?: boolean;
+    /** Additional className */
+    className?: string;
+    /** Additional styles */
+    style?: CSSProperties;
+}
+declare const ToolbarGroup: React__default.FC<ToolbarGroupProps>;
+/**
+ * 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[];
+/**
+ * Get recommended priority for common toolbar items
+ */
+declare function getRecommendedPriority(itemType: string): ToolbarItemPriority;
+
+/**
+ * Find and Replace Dialog Component
+ *
+ * Modal dialog for searching and replacing text in the document.
+ * Supports find, find next/previous, replace, and replace all operations.
+ *
+ * Features:
+ * - Find input with next/previous navigation
+ * - Replace input with replace/replace all
+ * - Match case option
+ * - Match whole word option
+ * - Keyboard shortcuts (Ctrl+F, Ctrl+H, Enter, Escape)
+ * - Match count display
+ */
+
+/**
+ * A single match result in the document
+ */
+interface FindMatch {
+    /** Index of the paragraph containing the match */
+    paragraphIndex: number;
+    /** Index of the run/content within the paragraph */
+    contentIndex: number;
+    /** Character offset within the content */
+    startOffset: number;
+    /** Character offset for end of match */
+    endOffset: number;
+    /** The matched text */
+    text: string;
+}
+/**
+ * Find options for controlling search behavior
+ */
+interface FindOptions {
+    /** Whether to match case */
+    matchCase: boolean;
+    /** Whether to match whole words only */
+    matchWholeWord: boolean;
+    /** Whether to use regular expressions (future) */
+    useRegex?: boolean;
+}
+/**
+ * Find result with all matches
+ */
+interface FindResult {
+    /** All matches found */
+    matches: FindMatch[];
+    /** Total match count */
+    totalCount: number;
+    /** Current match index (0-based) */
+    currentIndex: number;
+}
+/**
+ * Props for the FindReplaceDialog component
+ */
+interface FindReplaceDialogProps {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Callback when dialog is closed */
+    onClose: () => void;
+    /** Callback when searching for text */
+    onFind: (searchText: string, options: FindOptions) => FindResult | null;
+    /** Callback when navigating to next match */
+    onFindNext: () => FindMatch | null;
+    /** Callback when navigating to previous match */
+    onFindPrevious: () => FindMatch | null;
+    /** Callback when replacing current match */
+    onReplace: (replaceText: string) => boolean;
+    /** Callback when replacing all matches */
+    onReplaceAll: (searchText: string, replaceText: string, options: FindOptions) => number;
+    /** Callback to highlight matches in document */
+    onHighlightMatches?: (matches: FindMatch[]) => void;
+    /** Callback to clear highlights */
+    onClearHighlights?: () => void;
+    /** Initial search text (e.g., from selected text) */
+    initialSearchText?: string;
+    /** Whether to start in replace mode */
+    replaceMode?: boolean;
+    /** Current match result (from external state) */
+    currentResult?: FindResult | null;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * FindReplaceDialog component - Modal for finding and replacing text
+ */
+declare function FindReplaceDialog({ isOpen, onClose, onFind, onFindNext, onFindPrevious, onReplace, onReplaceAll, onHighlightMatches, onClearHighlights, initialSearchText, replaceMode, currentResult, className, style, }: FindReplaceDialogProps): React__default.ReactElement | null;
+/**
+ * Create default find options
+ */
+declare function createDefaultFindOptions(): FindOptions;
+/**
+ * Find all matches of search text in content
+ * @param content - The text to search in
+ * @param searchText - The text to find
+ * @param options - Find options
+ * @returns Array of match indices [startIndex, endIndex]
+ */
+declare function findAllMatches(content: string, searchText: string, options: FindOptions): Array<{
+    start: number;
+    end: number;
+}>;
+/**
+ * Escape string for use in regex pattern
+ */
+declare function escapeRegexString(str: string): string;
+/**
+ * Create a regex pattern from search text and options
+ */
+declare function createSearchPattern(searchText: string, options: FindOptions): RegExp | null;
+/**
+ * Replace text in content
+ * @param content - Original content
+ * @param searchText - Text to find
+ * @param replaceText - Text to replace with
+ * @param options - Find options
+ * @returns New content with replacements
+ */
+declare function replaceAllInContent(content: string, searchText: string, replaceText: string, options: FindOptions): string;
+/**
+ * Replace first match in content
+ * @param content - Original content
+ * @param searchText - Text to find
+ * @param replaceText - Text to replace with
+ * @param options - Find options
+ * @param startIndex - Index to start searching from
+ * @returns New content with replacement, or original if no match
+ */
+declare function replaceFirstInContent(content: string, searchText: string, replaceText: string, options: FindOptions, startIndex?: number): {
+    content: string;
+    replaced: boolean;
+    matchStart: number;
+    matchEnd: number;
+};
+/**
+ * Get match count for status display
+ */
+declare function getMatchCountText(result: FindResult | null): string;
+/**
+ * Check if search text is empty or whitespace-only
+ */
+declare function isEmptySearch(searchText: string): boolean;
+/**
+ * Highlight options for document rendering
+ */
+interface HighlightOptions {
+    /** Background color for current match */
+    currentMatchColor: string;
+    /** Background color for other matches */
+    otherMatchColor: string;
+}
+/**
+ * Get default highlight options
+ */
+declare function getDefaultHighlightOptions(): HighlightOptions;
+/**
+ * Options for the useFindReplace hook
+ */
+interface FindReplaceOptions {
+    /** Whether to show replace functionality initially */
+    initialReplaceMode?: boolean;
+    /** Callback when matches change */
+    onMatchesChange?: (matches: FindMatch[]) => void;
+    /** Callback when current match changes */
+    onCurrentMatchChange?: (match: FindMatch | null, index: number) => void;
+}
+/**
+ * State for the find/replace hook
+ */
+interface FindReplaceState {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Current search text */
+    searchText: string;
+    /** Current replace text */
+    replaceText: string;
+    /** Find options */
+    options: FindOptions;
+    /** All matches found */
+    matches: FindMatch[];
+    /** Current match index */
+    currentIndex: number;
+    /** Whether in replace mode */
+    replaceMode: boolean;
+}
+/**
+ * Return type for the useFindReplace hook
+ */
+interface UseFindReplaceReturn {
+    /** Current state */
+    state: FindReplaceState;
+    /** Open the find dialog */
+    openFind: (selectedText?: string) => void;
+    /** Open the replace dialog */
+    openReplace: (selectedText?: string) => void;
+    /** Close the dialog */
+    close: () => void;
+    /** Toggle dialog visibility */
+    toggle: () => void;
+    /** Update search text */
+    setSearchText: (text: string) => void;
+    /** Update replace text */
+    setReplaceText: (text: string) => void;
+    /** Update find options */
+    setOptions: (options: Partial<FindOptions>) => void;
+    /** Set search results */
+    setMatches: (matches: FindMatch[], currentIndex?: number) => void;
+    /** Go to next match */
+    goToNextMatch: () => number;
+    /** Go to previous match */
+    goToPreviousMatch: () => number;
+    /** Go to a specific match by index */
+    goToMatch: (index: number) => void;
+    /** Get current match */
+    getCurrentMatch: () => FindMatch | null;
+    /** Check if has matches */
+    hasMatches: () => boolean;
+}
+/**
+ * Hook for managing find/replace dialog state
+ */
+declare function useFindReplace(hookOptions?: FindReplaceOptions): UseFindReplaceReturn;
+/**
+ * Find all matches in a document
+ */
+declare function findInDocument(document: any, searchText: string, options: FindOptions): FindMatch[];
+/**
+ * Find matches in a single paragraph
+ */
+declare function findInParagraph(paragraph: any, searchText: string, options: FindOptions, paragraphIndex: number): FindMatch[];
+/**
+ * Scroll to a match in the document (to be used with the editor)
+ */
+declare function scrollToMatch(containerElement: HTMLElement | null, match: FindMatch): void;
+
+/**
+ * Hyperlink Dialog Component
+ *
+ * Modal dialog for inserting and editing hyperlinks in the document.
+ * Supports both external URLs and internal bookmark links.
+ *
+ * Features:
+ * - Input for URL (http, https, mailto, tel, etc.)
+ * - Input for display text
+ * - Edit existing hyperlinks
+ * - Remove hyperlink option
+ * - Internal bookmark selection
+ * - Validation and error handling
+ */
+
+/**
+ * Hyperlink data structure for dialog
+ */
+interface HyperlinkData {
+    /** URL for external link */
+    url?: string;
+    /** Display text for the link */
+    displayText?: string;
+    /** Internal bookmark name */
+    bookmark?: string;
+    /** Tooltip text */
+    tooltip?: string;
+}
+/**
+ * Bookmark option for internal link selection
+ */
+interface BookmarkOption {
+    /** Bookmark name/ID */
+    name: string;
+    /** Optional display label */
+    label?: string;
+}
+/**
+ * Props for the HyperlinkDialog component
+ */
+interface HyperlinkDialogProps {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Callback when dialog is closed */
+    onClose: () => void;
+    /** Callback when hyperlink is inserted/updated */
+    onSubmit: (data: HyperlinkData) => void;
+    /** Callback when hyperlink is removed */
+    onRemove?: () => void;
+    /** Initial data for editing existing hyperlink */
+    initialData?: HyperlinkData;
+    /** Currently selected text (used as default display text) */
+    selectedText?: string;
+    /** Whether we're editing an existing hyperlink */
+    isEditing?: boolean;
+    /** Available bookmarks for internal links */
+    bookmarks?: BookmarkOption[];
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * HyperlinkDialog component - Modal for inserting/editing hyperlinks
+ */
+declare function HyperlinkDialog({ isOpen, onClose, onSubmit, onRemove, initialData, selectedText, isEditing, bookmarks, className, style, }: HyperlinkDialogProps): React__default.ReactElement | null;
+/**
+ * Hook state for the Hyperlink dialog
+ */
+interface UseHyperlinkDialogState {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Initial data for the dialog (for editing) */
+    initialData?: HyperlinkData;
+    /** Currently selected text */
+    selectedText?: string;
+    /** Whether we're editing an existing hyperlink */
+    isEditing: boolean;
+}
+/**
+ * Hook return type for the Hyperlink dialog
+ */
+interface UseHyperlinkDialogReturn {
+    /** Current state */
+    state: UseHyperlinkDialogState;
+    /** Open dialog for inserting new hyperlink */
+    openInsert: (selectedText?: string) => void;
+    /** Open dialog for editing existing hyperlink */
+    openEdit: (data: HyperlinkData) => void;
+    /** Close the dialog */
+    close: () => void;
+    /** Toggle dialog open/closed */
+    toggle: () => void;
+}
+/**
+ * Hook for managing Hyperlink dialog state
+ */
+declare function useHyperlinkDialog(): UseHyperlinkDialogReturn;
+
+/**
+ * Insert Table Dialog Component
+ *
+ * Modal dialog for inserting a new table into the document.
+ * Provides a visual grid selector for choosing rows and columns.
+ *
+ * Features:
+ * - Visual grid selector (hover to select dimensions)
+ * - Manual row/column input
+ * - Preview of table dimensions
+ * - Quick insert with default sizes
+ */
+
+/**
+ * Table configuration for insertion
+ */
+interface TableConfig {
+    /** Number of rows */
+    rows: number;
+    /** Number of columns */
+    columns: number;
+}
+/**
+ * Props for InsertTableDialog
+ */
+interface InsertTableDialogProps {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Callback when dialog is closed */
+    onClose: () => void;
+    /** Callback when table is inserted */
+    onInsert: (config: TableConfig) => void;
+    /** Maximum rows in grid selector (default: 8) */
+    maxGridRows?: number;
+    /** Maximum columns in grid selector (default: 10) */
+    maxGridColumns?: number;
+    /** Maximum allowed rows (default: 100) */
+    maxRows?: number;
+    /** Maximum allowed columns (default: 20) */
+    maxColumns?: number;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * InsertTableDialog - Modal for inserting tables with visual grid selector
+ */
+declare function InsertTableDialog({ isOpen, onClose, onInsert, maxGridRows, maxGridColumns, maxRows, maxColumns, className, style, }: InsertTableDialogProps): React__default.ReactElement | null;
+/**
+ * Hook for managing Insert Table dialog state
+ */
+declare function useInsertTableDialog(): {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+/**
+ * Create a default TableConfig
+ */
+declare function createDefaultTableConfig(rows?: number, columns?: number): TableConfig;
+/**
+ * Validate TableConfig
+ */
+declare function isValidTableConfig(config: TableConfig, maxRows?: number, maxColumns?: number): boolean;
+/**
+ * Clamp TableConfig to valid range
+ */
+declare function clampTableConfig(config: TableConfig, maxRows?: number, maxColumns?: number): TableConfig;
+/**
+ * Format table dimensions for display
+ */
+declare function formatTableDimensions(config: TableConfig): string;
+/**
+ * Get common table presets
+ */
+declare function getTablePresets(): {
+    label: string;
+    config: TableConfig;
+}[];
+
+/**
+ * Insert Image Dialog Component
+ *
+ * Modal dialog for inserting images into the document.
+ * Supports file upload with preview and basic sizing options.
+ *
+ * Features:
+ * - File input for image selection
+ * - Drag and drop support
+ * - Image preview
+ * - Width/height controls with aspect ratio lock
+ * - Alt text input
+ */
+
+/**
+ * Image data for insertion
+ */
+interface ImageData {
+    /** Base64 data URL or external URL */
+    src: string;
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+    /** Alt text for accessibility */
+    alt?: string;
+    /** Original file name */
+    fileName?: string;
+    /** MIME type */
+    mimeType?: string;
+}
+/**
+ * Props for InsertImageDialog
+ */
+interface InsertImageDialogProps {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Callback when dialog is closed */
+    onClose: () => void;
+    /** Callback when image is inserted */
+    onInsert: (data: ImageData) => void;
+    /** Maximum width in pixels (default: 800) */
+    maxWidth?: number;
+    /** Maximum height in pixels (default: 600) */
+    maxHeight?: number;
+    /** Accepted file types (default: image/*) */
+    accept?: string;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * InsertImageDialog - Modal for inserting images with preview and sizing
+ */
+declare function InsertImageDialog({ isOpen, onClose, onInsert, maxWidth, maxHeight, accept, className, style, }: InsertImageDialogProps): React__default.ReactElement | null;
+/**
+ * Hook for managing Insert Image dialog state
+ */
+declare function useInsertImageDialog(): {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+/**
+ * Check if a file is a valid image
+ */
+declare function isValidImageFile(file: File): boolean;
+/**
+ * Get supported image extensions
+ */
+declare function getSupportedImageExtensions(): string[];
+/**
+ * Get accept string for file input
+ */
+declare function getImageAcceptString(): string;
+/**
+ * Calculate scaled dimensions to fit within bounds
+ */
+declare function calculateFitDimensions(originalWidth: number, originalHeight: number, maxWidth: number, maxHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Convert data URL to Blob
+ */
+declare function dataUrlToBlob(dataUrl: string): Blob;
+/**
+ * Get image dimensions from a data URL
+ */
+declare function getImageDimensions(src: string): Promise<{
+    width: number;
+    height: number;
+}>;
+/**
+ * Format file size for display
+ */
+declare function formatFileSize(bytes: number): string;
+
+/**
+ * Insert Symbol Dialog Component
+ *
+ * Modal dialog for inserting special characters and symbols into the document.
+ * Provides categorized symbol picker with search functionality.
+ *
+ * Features:
+ * - Categorized symbol groups
+ * - Recent symbols
+ * - Search functionality
+ * - Unicode character display
+ */
+
+/**
+ * Symbol category
+ */
+interface SymbolCategory {
+    /** Category name */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Symbols in this category */
+    symbols: string[];
+}
+/**
+ * Props for InsertSymbolDialog
+ */
+interface InsertSymbolDialogProps {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Callback when dialog is closed */
+    onClose: () => void;
+    /** Callback when symbol is inserted */
+    onInsert: (symbol: string) => void;
+    /** Recently used symbols */
+    recentSymbols?: string[];
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+}
+/**
+ * Default symbol categories
+ */
+declare const SYMBOL_CATEGORIES: SymbolCategory[];
+/**
+ * InsertSymbolDialog - Modal for inserting special characters
+ */
+declare function InsertSymbolDialog({ isOpen, onClose, onInsert, recentSymbols, className, style, }: InsertSymbolDialogProps): React__default.ReactElement | null;
+/**
+ * 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;
+};
+/**
+ * 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;
+};
+/**
+ * Search symbols by query
+ */
+declare function searchSymbols(query: string): string[];
+/**
+ * Get symbol from Unicode code point string
+ */
+declare function symbolFromCodePoint(codePointStr: string): string | null;
+
+/**
+ * Clipboard utilities for copy/paste with formatting
+ *
+ * Handles:
+ * - Copy: puts formatted HTML and plain text on clipboard
+ * - Paste: reads HTML clipboard, converts to runs with formatting
+ * - Handles paste from Word (cleans up Word HTML)
+ * - Ctrl+C, Ctrl+V, Ctrl+X keyboard shortcuts
+ */
+
+/**
+ * Clipboard content format
+ */
+interface ClipboardContent {
+    /** Plain text representation */
+    plainText: string;
+    /** HTML representation */
+    html: string;
+    /** Internal format (JSON) for preserving full formatting */
+    internal?: string;
+}
+/**
+ * Parsed clipboard content
+ */
+interface ParsedClipboardContent {
+    /** Runs parsed from clipboard */
+    runs: Run[];
+    /** Whether content came from Word */
+    fromWord: boolean;
+    /** Whether content came from our editor */
+    fromEditor: boolean;
+    /** Original plain text */
+    plainText: string;
+}
+/**
+ * Options for clipboard operations
+ */
+interface ClipboardOptions {
+    /** Whether to include formatting in copy */
+    includeFormatting?: boolean;
+    /** Whether to clean Word-specific formatting */
+    cleanWordFormatting?: boolean;
+    /** Callback for handling errors */
+    onError?: (error: Error) => void;
+}
+/**
+ * Custom MIME type for internal clipboard format
+ */
+declare const INTERNAL_CLIPBOARD_TYPE = "application/x-docx-editor";
+/**
+ * Standard clipboard MIME types
+ */
+declare const CLIPBOARD_TYPES: {
+    readonly HTML: "text/html";
+    readonly PLAIN: "text/plain";
+};
+/**
+ * Copy runs to clipboard with formatting
+ */
+declare function copyRuns(runs: Run[], options?: ClipboardOptions): Promise<boolean>;
+/**
+ * Copy paragraphs to clipboard with formatting
+ */
+declare function copyParagraphs(paragraphs: Paragraph[], options?: ClipboardOptions): Promise<boolean>;
+/**
+ * Convert runs to clipboard content (HTML and plain text)
+ */
+declare function runsToClipboardContent(runs: Run[], includeFormatting?: boolean): ClipboardContent;
+/**
+ * Convert paragraphs to clipboard content
+ */
+declare function paragraphsToClipboardContent(paragraphs: Paragraph[], includeFormatting?: boolean): ClipboardContent;
+/**
+ * Write content to clipboard
+ */
+declare function writeToClipboard(content: ClipboardContent): Promise<boolean>;
+/**
+ * Read content from clipboard
+ */
+declare function readFromClipboard(options?: ClipboardOptions): Promise<ParsedClipboardContent | null>;
+/**
+ * Handle paste event
+ */
+declare function handlePasteEvent(event: ClipboardEvent, options?: ClipboardOptions): ParsedClipboardContent | null;
+/**
+ * Parse HTML from clipboard
+ */
+declare function parseClipboardHtml(html: string, plainText: string, cleanWordFormatting?: boolean): ParsedClipboardContent;
+/**
+ * Check if HTML is from Microsoft Word
+ */
+declare function isWordHtml(html: string): boolean;
+/**
+ * Check if HTML is from our editor
+ */
+declare function isEditorHtml(html: string): boolean;
+/**
+ * Clean Microsoft Word HTML
+ */
+declare function cleanWordHtml(html: string): string;
+/**
+ * Convert HTML to runs
+ */
+declare function htmlToRuns(html: string, plainTextFallback: string): Run[];
+/**
+ * Create clipboard keyboard handlers for an editor
+ */
+declare function createClipboardHandlers(options: {
+    onCopy?: () => {
+        runs: Run[];
+    } | null;
+    onCut?: () => {
+        runs: Run[];
+    } | null;
+    onPaste?: (content: ParsedClipboardContent) => void;
+    clipboardOptions?: ClipboardOptions;
+}): {
+    handleCopy: (event: ClipboardEvent) => Promise<void>;
+    handleCut: (event: ClipboardEvent) => Promise<void>;
+    handlePaste: (event: ClipboardEvent) => void;
+    handleKeyDown: (event: KeyboardEvent) => Promise<void>;
+};
+
+/**
+ * Paste Special Dialog Component
+ *
+ * Provides paste options for pasting content with or without formatting.
+ * Features:
+ * - Paste with formatting (default)
+ * - Paste as plain text (unformatted)
+ * - Keyboard shortcut: Ctrl+Shift+V opens dialog
+ */
+
+/**
+ * Paste option type
+ */
+type PasteOption = 'formatted' | 'plainText';
+/**
+ * Paste special dialog props
+ */
+interface PasteSpecialDialogProps {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Callback when dialog is closed */
+    onClose: () => void;
+    /** Callback when paste is confirmed */
+    onPaste: (content: ParsedClipboardContent, asPlainText: boolean) => void;
+    /** Optional custom position */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Paste option item
+ */
+interface PasteOptionItem {
+    id: PasteOption;
+    label: string;
+    description: string;
+    shortcut: string;
+}
+/**
+ * Hook return value for paste special
+ */
+interface UsePasteSpecialReturn {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Open the paste special dialog */
+    openDialog: () => void;
+    /** Close the dialog */
+    closeDialog: () => void;
+    /** Handle keyboard shortcut (Ctrl+Shift+V) */
+    handleKeyDown: (event: KeyboardEvent) => boolean;
+    /** Paste as plain text directly */
+    pasteAsPlainText: () => Promise<void>;
+}
+/**
+ * Options for usePasteSpecial hook
+ */
+interface UsePasteSpecialOptions {
+    /** Callback when paste is confirmed */
+    onPaste?: (content: ParsedClipboardContent, asPlainText: boolean) => void;
+    /** Whether paste operations are enabled */
+    enabled?: boolean;
+}
+declare const PasteSpecialDialog: React__default.FC<PasteSpecialDialogProps>;
+/**
+ * Hook to manage paste special dialog
+ */
+declare function usePasteSpecial(options?: UsePasteSpecialOptions): UsePasteSpecialReturn;
+/**
+ * Get paste option by id
+ */
+declare function getPasteOption(id: PasteOption): PasteOptionItem | undefined;
+/**
+ * Get all paste options
+ */
+declare function getAllPasteOptions(): PasteOptionItem[];
+/**
+ * Get default paste option
+ */
+declare function getDefaultPasteOption(): PasteOption;
+/**
+ * Check if paste special shortcut
+ */
+declare function isPasteSpecialShortcut(event: KeyboardEvent): boolean;
+
+/**
+ * Keyboard Shortcuts Dialog Component
+ *
+ * Displays all available keyboard shortcuts organized by category.
+ * Features:
+ * - Categorized shortcut list
+ * - Search/filter functionality
+ * - Platform-aware modifier keys (Ctrl/Cmd)
+ * - Keyboard shortcut to open (Ctrl+/)
+ */
+
+/**
+ * Keyboard shortcut definition
+ */
+interface KeyboardShortcut$1 {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description of what the shortcut does */
+    description: string;
+    /** Primary key combination (e.g., 'Ctrl+C') */
+    keys: string;
+    /** Alternative key combination */
+    altKeys?: string;
+    /** Category for grouping */
+    category: ShortcutCategory;
+    /** Whether this is a common/frequently used shortcut */
+    common?: boolean;
+}
+/**
+ * Shortcut category
+ */
+type ShortcutCategory = 'editing' | 'formatting' | 'navigation' | 'clipboard' | 'selection' | 'view' | 'file' | 'other';
+/**
+ * Dialog props
+ */
+interface KeyboardShortcutsDialogProps {
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Close callback */
+    onClose: () => void;
+    /** Custom shortcuts (merged with defaults) */
+    customShortcuts?: KeyboardShortcut$1[];
+    /** Whether to show search */
+    showSearch?: boolean;
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Hook options
+ */
+interface UseKeyboardShortcutsDialogOptions {
+    /** Whether the dialog can be opened with Ctrl+? or F1 */
+    enabled?: boolean;
+    /** Custom open shortcut (default: Ctrl+/) */
+    openShortcut?: string;
+}
+/**
+ * Hook return value
+ */
+interface UseKeyboardShortcutsDialogReturn {
+    /** Whether dialog is open */
+    isOpen: boolean;
+    /** Open the dialog */
+    open: () => void;
+    /** Close the dialog */
+    close: () => void;
+    /** Toggle the dialog */
+    toggle: () => void;
+    /** Keyboard event handler */
+    handleKeyDown: (event: KeyboardEvent) => void;
+}
+declare const KeyboardShortcutsDialog: React__default.FC<KeyboardShortcutsDialogProps>;
+/**
+ * Hook to manage keyboard shortcuts dialog
+ */
+declare function useKeyboardShortcutsDialog(options?: UseKeyboardShortcutsDialogOptions): UseKeyboardShortcutsDialogReturn;
+/**
+ * Get all default shortcuts
+ */
+declare function getDefaultShortcuts(): KeyboardShortcut$1[];
+/**
+ * Get shortcuts by category
+ */
+declare function getShortcutsByCategory(category: ShortcutCategory): KeyboardShortcut$1[];
+/**
+ * Get common/frequently used shortcuts
+ */
+declare function getCommonShortcuts(): KeyboardShortcut$1[];
+/**
+ * Get category label
+ */
+declare function getCategoryLabel(category: ShortcutCategory): string;
+/**
+ * Get all categories
+ */
+declare function getAllCategories(): ShortcutCategory[];
+/**
+ * Format shortcut keys for display
+ */
+declare function formatShortcutKeys(keys: string): string;
+
+/**
+ * useTableSelection Hook
+ *
+ * Tracks table selection state based on user clicks.
+ * Provides:
+ * - Current table context when clicking in a table cell
+ * - Methods to handle table actions (add row, delete column, etc.)
+ * - Clears selection when clicking outside tables
+ */
+
+/**
+ * Table selection state
+ */
+interface TableSelectionState {
+    /** Current table context (null if not in a table) */
+    context: TableContext | null;
+    /** The selected table */
+    table: Table | null;
+    /** Index of the table in the document */
+    tableIndex: number | null;
+    /** Row index */
+    rowIndex: number | null;
+    /** Column index */
+    columnIndex: number | null;
+}
+/**
+ * Return type for useTableSelection hook
+ */
+interface UseTableSelectionReturn {
+    /** Current table selection state */
+    state: TableSelectionState;
+    /** Handle click on a table cell */
+    handleCellClick: (tableIndex: number, rowIndex: number, columnIndex: number) => void;
+    /** Handle table action */
+    handleAction: (action: TableAction) => void;
+    /** Clear the selection */
+    clearSelection: () => void;
+    /** Check if a cell is selected */
+    isCellSelected: (tableIndex: number, rowIndex: number, columnIndex: number) => boolean;
+    /** The table context for the TableToolbar */
+    tableContext: TableContext | null;
+}
+/**
+ * Options for useTableSelection
+ */
+interface UseTableSelectionOptions {
+    /** The document being edited */
+    document: Document | null;
+    /** Callback when document changes */
+    onChange?: (document: Document) => void;
+    /** Callback when table selection changes */
+    onSelectionChange?: (context: TableContext | null) => void;
+}
+/**
+ * Data attributes for table elements
+ */
+declare const TABLE_DATA_ATTRIBUTES: {
+    /** Attribute for table index */
+    TABLE_INDEX: string;
+    /** Attribute for row index */
+    ROW_INDEX: string;
+    /** Attribute for column index */
+    COLUMN_INDEX: string;
+    /** Attribute marking a table cell */
+    TABLE_CELL: string;
+};
+/**
+ * Hook for tracking and managing table selection
+ */
+declare function useTableSelection({ document: doc, onChange, onSelectionChange, }: UseTableSelectionOptions): UseTableSelectionReturn;
+
+/**
+ * useAutoSave Hook
+ *
+ * Automatically saves document state to localStorage at configurable intervals.
+ *
+ * Features:
+ * - Configurable save interval (default: 30 seconds)
+ * - Saves document JSON to localStorage
+ * - Recovery of saved state on load
+ * - Manual save trigger
+ * - Last save timestamp tracking
+ * - Save status callbacks
+ */
+
+/**
+ * Auto-save status
+ */
+type AutoSaveStatus = 'idle' | 'saving' | 'saved' | 'error';
+/**
+ * Options for useAutoSave hook
+ */
+interface UseAutoSaveOptions {
+    /** Storage key for localStorage (default: 'docx-editor-autosave') */
+    storageKey?: string;
+    /** Save interval in milliseconds (default: 30000 - 30 seconds) */
+    interval?: number;
+    /** Whether auto-save is enabled (default: true) */
+    enabled?: boolean;
+    /** Maximum age of auto-save in milliseconds before it's considered stale (default: 24 hours) */
+    maxAge?: number;
+    /** Callback when save succeeds */
+    onSave?: (timestamp: Date) => void;
+    /** Callback when save fails */
+    onError?: (error: Error) => void;
+    /** Callback when recovery data is found */
+    onRecoveryAvailable?: (savedDocument: SavedDocumentData) => void;
+    /** Whether to save immediately when document changes (debounced) */
+    saveOnChange?: boolean;
+    /** Debounce delay for saveOnChange in milliseconds (default: 2000) */
+    debounceDelay?: number;
+}
+/**
+ * Return value of useAutoSave hook
+ */
+interface UseAutoSaveReturn {
+    /** Current auto-save status */
+    status: AutoSaveStatus;
+    /** Last save timestamp */
+    lastSaveTime: Date | null;
+    /** Manually trigger a save */
+    save: () => Promise<boolean>;
+    /** Clear auto-saved data from storage */
+    clearAutoSave: () => void;
+    /** Check if there's recoverable data */
+    hasRecoveryData: boolean;
+    /** Get the saved document data for recovery */
+    getRecoveryData: () => SavedDocumentData | null;
+    /** Accept and apply recovered data */
+    acceptRecovery: () => Document | null;
+    /** Dismiss recovery (clears saved data) */
+    dismissRecovery: () => void;
+    /** Whether auto-save is currently enabled */
+    isEnabled: boolean;
+    /** Enable auto-save */
+    enable: () => void;
+    /** Disable auto-save */
+    disable: () => void;
+}
+/**
+ * Saved document data structure
+ */
+interface SavedDocumentData {
+    /** The document JSON */
+    document: Document;
+    /** When the document was saved */
+    savedAt: string;
+    /** Version for format compatibility */
+    version: number;
+    /** Optional document identifier */
+    documentId?: string;
+}
+/**
+ * React hook for auto-saving document to localStorage
+ */
+declare function useAutoSave(document: Document | null | undefined, options?: UseAutoSaveOptions): UseAutoSaveReturn;
+/**
+ * Format last save time for display
+ */
+declare function formatLastSaveTime(date: Date | null): string;
+/**
+ * Get auto-save status label
+ */
+declare function getAutoSaveStatusLabel(status: AutoSaveStatus): string;
+/**
+ * Get storage size used by auto-save
+ */
+declare function getAutoSaveStorageSize(storageKey?: string): number;
+/**
+ * Format storage size for display
+ */
+declare function formatStorageSize(bytes: number): string;
+/**
+ * Check if auto-save is supported in this environment
+ */
+declare function isAutoSaveSupported(): boolean;
+
+/**
+ * useWheelZoom Hook
+ *
+ * Enables Ctrl+scroll (or Cmd+scroll on Mac) to zoom in/out.
+ * Features:
+ * - Configurable zoom range and step
+ * - Smooth zoom transitions
+ * - Pinch-to-zoom support on trackpads
+ * - Zoom reset (Ctrl+0)
+ * - Zoom in/out shortcuts (Ctrl++, Ctrl+-)
+ */
+/**
+ * Options for useWheelZoom hook
+ */
+interface UseWheelZoomOptions {
+    /** Initial zoom level (default: 1.0) */
+    initialZoom?: number;
+    /** Minimum zoom level (default: 0.25) */
+    minZoom?: number;
+    /** Maximum zoom level (default: 4.0) */
+    maxZoom?: number;
+    /** Zoom step for each scroll event (default: 0.1) */
+    zoomStep?: number;
+    /** Whether zoom is enabled (default: true) */
+    enabled?: boolean;
+    /** Container element ref to attach wheel listener */
+    containerRef?: React.RefObject<HTMLElement>;
+    /** Callback when zoom changes */
+    onZoomChange?: (zoom: number) => void;
+    /** Whether to enable keyboard shortcuts (Ctrl++, Ctrl+-, Ctrl+0) */
+    enableKeyboardShortcuts?: boolean;
+    /** Whether to prevent default browser zoom behavior */
+    preventDefault?: boolean;
+}
+/**
+ * Return value of useWheelZoom hook
+ */
+interface UseWheelZoomReturn {
+    /** Current zoom level */
+    zoom: number;
+    /** Set zoom level directly */
+    setZoom: (zoom: number) => void;
+    /** Zoom in by step */
+    zoomIn: () => void;
+    /** Zoom out by step */
+    zoomOut: () => void;
+    /** Reset zoom to initial level */
+    resetZoom: () => void;
+    /** Reset zoom to 100% */
+    zoomTo100: () => void;
+    /** Zoom to fit width */
+    zoomToFit: (containerWidth: number, contentWidth: number) => void;
+    /** Whether currently at minimum zoom */
+    isMinZoom: boolean;
+    /** Whether currently at maximum zoom */
+    isMaxZoom: boolean;
+    /** Zoom percentage (e.g., 100 for zoom level 1.0) */
+    zoomPercent: number;
+    /** Wheel event handler (for manual attachment) */
+    handleWheel: (event: WheelEvent) => void;
+    /** Keyboard event handler (for manual attachment) */
+    handleKeyDown: (event: KeyboardEvent) => void;
+}
+/**
+ * Preset zoom levels for snapping
+ */
+declare const ZOOM_PRESETS: number[];
+/**
+ * React hook for Ctrl+scroll zoom functionality
+ */
+declare function useWheelZoom(options?: UseWheelZoomOptions): UseWheelZoomReturn;
+/**
+ * Get zoom presets
+ */
+declare function getZoomPresets(): number[];
+/**
+ * Find nearest zoom preset
+ */
+declare function findNearestZoomPreset(zoom: number): number;
+/**
+ * Get next zoom preset (for zoom in)
+ */
+declare function getNextZoomPreset(zoom: number): number;
+/**
+ * Get previous zoom preset (for zoom out)
+ */
+declare function getPreviousZoomPreset(zoom: number): number;
+/**
+ * Format zoom level for display
+ */
+declare function formatZoom(zoom: number): string;
+/**
+ * Parse zoom from percentage string
+ */
+declare function parseZoom(zoomString: string): number | null;
+/**
+ * Check if zoom level is at a preset
+ */
+declare function isZoomPreset(zoom: number): boolean;
+/**
+ * Clamp zoom to valid range
+ */
+declare function clampZoom(zoom: number, minZoom?: number, maxZoom?: number): number;
+
+/**
+ * Insert Operations Utility
+ *
+ * Utility functions for inserting content into the document.
+ * Provides functions for inserting page breaks, horizontal rules, and other elements.
+ */
+
+/**
+ * Insert position in the document
+ */
+interface InsertPosition {
+    /** Paragraph index in the document body */
+    paragraphIndex: number;
+    /** Run index within the paragraph (optional) */
+    runIndex?: number;
+    /** Character offset within the run (optional) */
+    offset?: number;
+}
+/**
+ * Create a page break content element
+ */
+declare function createPageBreak(): BreakContent;
+/**
+ * Create a column break content element
+ */
+declare function createColumnBreak(): BreakContent;
+/**
+ * Create a text wrapping break (line break)
+ */
+declare function createLineBreak(clear?: 'none' | 'left' | 'right' | 'all'): BreakContent;
+/**
+ * Create a run containing a page break
+ */
+declare function createPageBreakRun(): Run;
+/**
+ * Create an empty paragraph with a page break before it
+ */
+declare function createPageBreakParagraph(): Paragraph;
+/**
+ * Insert a page break at a position in the document
+ * This inserts a new paragraph with pageBreakBefore: true
+ */
+declare function insertPageBreak(doc: Document, position: InsertPosition): Document;
+/**
+ * Create a horizontal rule paragraph
+ * Uses a paragraph with bottom border to simulate horizontal rule
+ */
+declare function createHorizontalRule(): Paragraph;
+/**
+ * Insert a horizontal rule at a position in the document
+ */
+declare function insertHorizontalRule(doc: Document, position: InsertPosition): Document;
+/**
+ * Check if content is a page break
+ */
+declare function isPageBreak(content: RunContent): boolean;
+/**
+ * Check if content is a column break
+ */
+declare function isColumnBreak(content: RunContent): boolean;
+/**
+ * Check if content is a line break
+ */
+declare function isLineBreak(content: RunContent): boolean;
+/**
+ * Check if content is any type of break
+ */
+declare function isBreakContent(content: RunContent): content is BreakContent;
+/**
+ * Check if a paragraph has pageBreakBefore
+ */
+declare function hasPageBreakBefore(paragraph: Paragraph): boolean;
+/**
+ * Count page breaks in a document
+ */
+declare function countPageBreaks(doc: Document): number;
+/**
+ * Find all page break positions in a document
+ */
+declare function findPageBreaks(doc: Document): InsertPosition[];
+/**
+ * Remove a page break at a specific position
+ */
+declare function removePageBreak(doc: Document, position: InsertPosition): Document;
+
+/**
+ * Selection Highlight Utilities
+ *
+ * Provides visual highlighting for text selection across multiple runs.
+ * Browsers handle ::selection pseudo-element differently, especially when
+ * selection spans multiple elements with different backgrounds or styling.
+ *
+ * This module provides:
+ * - Custom selection highlight rendering
+ * - Programmatic selection range marking
+ * - Visual feedback for selection across runs
+ */
+
+/**
+ * Highlight rectangle representing a selected region
+ */
+interface HighlightRect {
+    /** Left position in pixels */
+    left: number;
+    /** Top position in pixels */
+    top: number;
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+}
+/**
+ * Selection highlight configuration
+ */
+interface SelectionHighlightConfig {
+    /** Background color for selection */
+    backgroundColor: string;
+    /** Optional border color for selection */
+    borderColor?: string;
+    /** Optional border radius */
+    borderRadius?: number;
+    /** Z-index for overlay */
+    zIndex?: number;
+    /** Opacity for highlight */
+    opacity?: number;
+    /** Mix blend mode */
+    mixBlendMode?: CSSProperties['mixBlendMode'];
+}
+/**
+ * Selection range in document coordinates
+ */
+interface SelectionRange {
+    /** Start position */
+    start: {
+        paragraphIndex: number;
+        contentIndex: number;
+        offset: number;
+    };
+    /** End position */
+    end: {
+        paragraphIndex: number;
+        contentIndex: number;
+        offset: number;
+    };
+}
+/**
+ * Default selection highlight style (matches Word/Google Docs)
+ */
+declare const DEFAULT_SELECTION_STYLE: SelectionHighlightConfig;
+/**
+ * High contrast selection style
+ */
+declare const HIGH_CONTRAST_SELECTION_STYLE: SelectionHighlightConfig;
+/**
+ * Selection highlight CSS custom properties
+ */
+declare const SELECTION_CSS_VARS: {
+    readonly backgroundColor: "--docx-selection-bg";
+    readonly borderColor: "--docx-selection-border";
+    readonly textColor: "--docx-selection-text";
+};
+/**
+ * Get all selection rectangles from the current DOM selection
+ *
+ * Uses getClientRects() to get accurate rectangles even when
+ * selection spans multiple inline elements.
+ */
+declare function getSelectionRects(containerElement?: HTMLElement | null): HighlightRect[];
+/**
+ * Merge adjacent or overlapping rectangles
+ *
+ * This reduces the number of highlight elements needed and creates
+ * a cleaner visual appearance.
+ */
+declare function mergeAdjacentRects(rects: HighlightRect[], tolerance?: number): HighlightRect[];
+/**
+ * Get selection rectangles with merging applied
+ */
+declare function getMergedSelectionRects(containerElement?: HTMLElement | null): HighlightRect[];
+/**
+ * Generate CSS styles for a highlight rectangle
+ */
+declare function getHighlightRectStyle(rect: HighlightRect, config?: SelectionHighlightConfig): CSSProperties;
+/**
+ * Generate inline CSS for selection pseudo-elements
+ *
+ * This is used to inject consistent selection styling
+ * across all editable elements.
+ */
+declare function generateSelectionCSS(selector: string, config?: SelectionHighlightConfig): string;
+/**
+ * Check if there is an active text selection (not collapsed)
+ */
+declare function hasActiveSelection(): boolean;
+/**
+ * Get the selected text
+ */
+declare function getSelectedText(): string;
+/**
+ * Check if selection is within a specific element
+ */
+declare function isSelectionWithin(element: HTMLElement): boolean;
+/**
+ * Get the bounding rect of the current selection
+ */
+declare function getSelectionBoundingRect(): DOMRect | null;
+/**
+ * Create a selection highlight for a specific text range
+ *
+ * This is useful for find/replace highlighting, AI action previews, etc.
+ */
+declare function highlightTextRange(_containerElement: HTMLElement, startNode: Node, startOffset: number, endNode: Node, endOffset: number): Range | null;
+/**
+ * Select a text range programmatically
+ */
+declare function selectRange(range: Range): void;
+/**
+ * Clear the current selection
+ */
+declare function clearSelection(): void;
+/**
+ * Check if selection is backwards (focus before anchor)
+ */
+declare function isSelectionBackwards(): boolean;
+/**
+ * Normalize selection to always be forward (start before end)
+ */
+declare function normalizeSelectionDirection(): void;
+/**
+ * Inject selection highlight CSS into document
+ */
+declare function injectSelectionStyles(config?: SelectionHighlightConfig): void;
+/**
+ * Remove injected selection styles
+ */
+declare function removeSelectionStyles(): void;
+/**
+ * Check if selection styles are injected
+ */
+declare function areSelectionStylesInjected(): boolean;
+/**
+ * Create a selection change handler that updates highlight rects
+ */
+declare function createSelectionChangeHandler(containerElement: HTMLElement | null, onRectsChange: (rects: HighlightRect[]) => void, merge?: boolean): () => void;
+
+/**
+ * Selection Highlight Hook
+ *
+ * A React hook that manages visual selection highlighting across multiple runs.
+ * Uses a combination of CSS ::selection pseudo-element styling and optional
+ * overlay rectangles for complex scenarios.
+ *
+ * Features:
+ * - Consistent selection highlighting across all text runs
+ * - Support for text with different backgrounds (highlighted, dark bg)
+ * - Optional overlay rectangles for custom highlight effects
+ * - Debounced updates for performance
+ */
+
+/**
+ * Options for the useSelectionHighlight hook
+ */
+interface UseSelectionHighlightOptions {
+    /** Reference to the container element */
+    containerRef: React__default.RefObject<HTMLElement>;
+    /** Whether to enable selection highlighting */
+    enabled?: boolean;
+    /** Custom highlight configuration */
+    config?: SelectionHighlightConfig;
+    /** Whether to use overlay rectangles (default: false, uses CSS) */
+    useOverlay?: boolean;
+    /** Debounce delay for rect updates in ms (default: 16) */
+    debounceMs?: number;
+    /** Callback when selection changes */
+    onSelectionChange?: (hasSelection: boolean, text: string) => void;
+}
+/**
+ * Return value from the useSelectionHighlight hook
+ */
+interface UseSelectionHighlightReturn {
+    /** Whether there is an active selection */
+    hasSelection: boolean;
+    /** The selected text */
+    selectedText: string;
+    /** Highlight rectangles (only populated if useOverlay is true) */
+    highlightRects: HighlightRect[];
+    /** Whether selection is within the container */
+    isSelectionInContainer: boolean;
+    /** Refresh the highlight state */
+    refresh: () => void;
+    /** Get styles for a highlight rect overlay */
+    getOverlayStyle: (rect: HighlightRect) => CSSProperties;
+}
+/**
+ * Hook to manage selection highlighting in the editor
+ */
+declare function useSelectionHighlight(options: UseSelectionHighlightOptions): UseSelectionHighlightReturn;
+/**
+ * Props for selection overlay component
+ */
+interface SelectionOverlayProps {
+    /** Highlight rectangles to render */
+    rects: HighlightRect[];
+    /** Style configuration */
+    config?: SelectionHighlightConfig;
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * Generate selection overlay elements (for use in JSX)
+ *
+ * Usage:
+ * ```tsx
+ * const { highlightRects } = useSelectionHighlight({ ... });
+ * return (
+ *   <div style={{ position: 'relative' }}>
+ *     {generateOverlayElements(highlightRects)}
+ *     <div>... content ...</div>
+ *   </div>
+ * );
+ * ```
+ */
+declare function generateOverlayElements(rects: HighlightRect[], config?: SelectionHighlightConfig): React__default.ReactNode[];
+
+/**
+ * Text Selection Utilities
+ *
+ * Utilities for word-level and paragraph-level text selection.
+ * Used for double-click (word) and triple-click (paragraph) selection.
+ */
+/**
+ * Check if a character is a word character
+ */
+declare function isWordCharacter$1(char: string): boolean;
+/**
+ * Check if a character is whitespace
+ */
+declare function isWhitespace$1(char: string): boolean;
+/**
+ * Find word boundaries around a position in text
+ * Returns [startIndex, endIndex] inclusive start, exclusive end
+ */
+declare function findWordBoundaries(text: string, position: number): [number, number];
+/**
+ * Get the word at a position in text
+ */
+declare function getWordAt(text: string, position: number): string;
+/**
+ * Word selection result
+ */
+interface WordSelectionResult {
+    /** The selected word */
+    word: string;
+    /** Start index in the text (inclusive) */
+    startIndex: number;
+    /** End index in the text (exclusive) */
+    endIndex: number;
+}
+/**
+ * Find the word at a position and return detailed info
+ */
+declare function findWordAt(text: string, position: number): WordSelectionResult;
+/**
+ * Select a word at the current cursor position using the browser's native APIs.
+ * This works reliably across different browsers and handles contentEditable well.
+ */
+declare function selectWordAtCursor(): boolean;
+/**
+ * Select a word in a specific text node at the given offset
+ */
+declare function selectWordInTextNode(textNode: Text, offset: number): boolean;
+/**
+ * Expand the current selection to word boundaries.
+ * If there's a collapsed selection (cursor), selects the word at cursor.
+ * If there's an existing selection, expands to include complete words.
+ */
+declare function expandSelectionToWordBoundaries(): boolean;
+/**
+ * Select the entire paragraph containing the current selection.
+ * Looks for the nearest element with [data-paragraph-index] attribute.
+ */
+declare function selectParagraphAtCursor(): boolean;
+/**
+ * Handle click event for multi-click detection.
+ * Call this in your click handler.
+ * Returns the click count (1 = single, 2 = double, 3 = triple).
+ */
+declare function handleClickForMultiClick(event: MouseEvent): number;
+/**
+ * Create a double-click handler that selects words.
+ * Returns a function that should be called on dblclick events.
+ */
+declare function createDoubleClickWordSelector(): (event: MouseEvent) => void;
+/**
+ * Create a triple-click handler that selects paragraphs.
+ * This uses our custom click counting since browsers have inconsistent triple-click.
+ */
+declare function createTripleClickParagraphSelector(): (event: MouseEvent) => void;
+
+/**
+ * Keyboard Navigation Utilities
+ *
+ * Provides enhanced keyboard navigation for the editor:
+ * - Ctrl+Left/Right: Move by word
+ * - Home/End: Move to start/end of line
+ * - Ctrl+Home/End: Move to start/end of document
+ * - Ctrl+Shift+Left/Right: Select by word
+ * - Shift+Home/End: Select to start/end of line
+ */
+/**
+ * Navigation direction
+ */
+type NavigationDirection = 'left' | 'right' | 'up' | 'down';
+/**
+ * Navigation unit
+ */
+type NavigationUnit = 'character' | 'word' | 'line' | 'paragraph' | 'document';
+/**
+ * Keyboard navigation action
+ */
+interface NavigationAction {
+    /** Direction to navigate */
+    direction: NavigationDirection;
+    /** Unit of movement */
+    unit: NavigationUnit;
+    /** Whether to extend selection */
+    extend: boolean;
+}
+/**
+ * Keyboard shortcut definition
+ */
+interface KeyboardShortcut {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+}
+/**
+ * Check if a character is a word character (letter, digit, or underscore)
+ */
+declare function isWordCharacter(char: string): boolean;
+/**
+ * Check if a character is whitespace
+ */
+declare function isWhitespace(char: string): boolean;
+/**
+ * Check if a character is a punctuation character
+ */
+declare function isPunctuation(char: string): boolean;
+/**
+ * Find the start of the current or previous word
+ */
+declare function findWordStart(text: string, position: number): number;
+/**
+ * Find the end of the current or next word
+ */
+declare function findWordEnd(text: string, position: number): number;
+/**
+ * Find the next word start (for Ctrl+Right navigation)
+ */
+declare function findNextWordStart(text: string, position: number): number;
+/**
+ * Find the previous word start (for Ctrl+Left navigation)
+ */
+declare function findPreviousWordStart(text: string, position: number): number;
+/**
+ * Find the start of the current line in a text node
+ * Uses visual line detection based on bounding rectangles
+ */
+declare function findVisualLineStart(container: Node, offset: number): {
+    node: Node;
+    offset: number;
+} | null;
+/**
+ * Find the end of the current line in a text node
+ * Uses visual line detection based on bounding rectangles
+ */
+declare function findVisualLineEnd(container: Node, offset: number): {
+    node: Node;
+    offset: number;
+} | null;
+/**
+ * Get the current selection info
+ */
+declare function getSelectionInfo(): {
+    node: Node;
+    offset: number;
+    anchorNode: Node | null;
+    anchorOffset: number;
+    focusNode: Node | null;
+    focusOffset: number;
+    isCollapsed: boolean;
+    text: string;
+} | null;
+/**
+ * Set the selection to a specific position
+ */
+declare function setSelectionPosition(node: Node, offset: number): void;
+/**
+ * Extend selection to a specific position
+ */
+declare function extendSelectionTo(node: Node, offset: number): void;
+/**
+ * Move selection by word in a text node
+ */
+declare function moveByWord(direction: 'left' | 'right', extend?: boolean): boolean;
+/**
+ * Move to start/end of line
+ */
+declare function moveToLineEdge(edge: 'start' | 'end', extend?: boolean): boolean;
+/**
+ * Parse a keyboard event into a navigation action
+ */
+declare function parseNavigationAction(event: KeyboardEvent): NavigationAction | null;
+/**
+ * Handle a keyboard navigation event
+ * Returns true if the event was handled
+ */
+declare function handleNavigationKey(event: KeyboardEvent, options?: {
+    onDocumentStart?: () => void;
+    onDocumentEnd?: () => void;
+}): boolean;
+/**
+ * Check if an event is a navigation key event
+ */
+declare function isNavigationKey(event: KeyboardEvent): boolean;
+/**
+ * Expand selection to word boundaries
+ * Used for double-click word selection
+ */
+declare function expandSelectionToWord(): boolean;
+/**
+ * Get the word at the current cursor position
+ */
+declare function getWordAtCursor(): string | null;
+/**
+ * Check if a keyboard event matches a shortcut definition
+ */
+declare function matchesShortcut(event: KeyboardEvent, shortcut: KeyboardShortcut): boolean;
+/**
+ * Common navigation shortcuts
+ */
+declare const NAVIGATION_SHORTCUTS: {
+    readonly wordLeft: KeyboardShortcut;
+    readonly wordRight: KeyboardShortcut;
+    readonly selectWordLeft: KeyboardShortcut;
+    readonly selectWordRight: KeyboardShortcut;
+    readonly lineStart: KeyboardShortcut;
+    readonly lineEnd: KeyboardShortcut;
+    readonly selectToLineStart: KeyboardShortcut;
+    readonly selectToLineEnd: KeyboardShortcut;
+    readonly documentStart: KeyboardShortcut;
+    readonly documentEnd: KeyboardShortcut;
+    readonly selectToDocumentStart: KeyboardShortcut;
+    readonly selectToDocumentEnd: KeyboardShortcut;
+};
+/**
+ * Get a human-readable description of a shortcut
+ */
+declare function describeShortcut(shortcut: KeyboardShortcut): string;
+/**
+ * Get all navigation shortcuts with descriptions
+ */
+declare function getNavigationShortcutDescriptions(): Array<{
+    action: string;
+    shortcut: string;
+}>;
+
+/**
+ * useClipboard Hook
+ *
+ * React hook for managing clipboard operations in the editor with formatting preservation.
+ *
+ * Features:
+ * - Copy: Copies selected runs/paragraphs to clipboard with formatting as HTML
+ * - Cut: Copies and removes selected content
+ * - Paste: Parses clipboard HTML/text and applies formatting
+ * - Handles Word-pasted content (cleans Word-specific markup)
+ * - Keyboard shortcuts (Ctrl+C, Ctrl+X, Ctrl+V)
+ */
+
+/**
+ * Selection data for clipboard operations
+ */
+interface ClipboardSelection {
+    /** Selected text (plain text) */
+    text: string;
+    /** Selected runs */
+    runs: Run[];
+    /** Start position */
+    startParagraphIndex: number;
+    startRunIndex: number;
+    startOffset: number;
+    /** End position */
+    endParagraphIndex: number;
+    endRunIndex: number;
+    endOffset: number;
+    /** Whether selection spans multiple paragraphs */
+    isMultiParagraph: boolean;
+}
+/**
+ * Options for useClipboard hook
+ */
+interface UseClipboardOptions {
+    /** Callback when content is copied */
+    onCopy?: (selection: ClipboardSelection) => void;
+    /** Callback when content is cut */
+    onCut?: (selection: ClipboardSelection) => void;
+    /** Callback when content is pasted */
+    onPaste?: (content: ParsedClipboardContent, asPlainText: boolean) => void;
+    /** Whether to clean Word-specific formatting */
+    cleanWordFormatting?: boolean;
+    /** Whether the editor is editable */
+    editable?: boolean;
+    /** Callback for errors */
+    onError?: (error: Error) => void;
+}
+/**
+ * Return value of useClipboard hook
+ */
+interface UseClipboardReturn {
+    /** Copy the current selection to clipboard */
+    copy: (selection: ClipboardSelection) => Promise<boolean>;
+    /** Cut the current selection to clipboard */
+    cut: (selection: ClipboardSelection) => Promise<boolean>;
+    /** Paste from clipboard */
+    paste: (asPlainText?: boolean) => Promise<ParsedClipboardContent | null>;
+    /** Handle copy event from DOM */
+    handleCopy: (event: ClipboardEvent) => void;
+    /** Handle cut event from DOM */
+    handleCut: (event: ClipboardEvent) => void;
+    /** Handle paste event from DOM */
+    handlePaste: (event: ClipboardEvent) => void;
+    /** Handle keyboard shortcuts */
+    handleKeyDown: (event: KeyboardEvent) => void;
+    /** Whether a clipboard operation is in progress */
+    isProcessing: boolean;
+    /** Last pasted content */
+    lastPastedContent: ParsedClipboardContent | null;
+}
+/**
+ * Get selected runs from the current DOM selection
+ */
+declare function getSelectionRuns(): Run[];
+/**
+ * Create a selection object from the current DOM selection
+ */
+declare function createSelectionFromDOM(): ClipboardSelection | null;
+/**
+ * React hook for clipboard operations
+ */
+declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturn;
+
+declare const PLUGIN_HOST_STYLES = "\n.plugin-host {\n  display: flex;\n  width: 100%;\n  height: 100%;\n  overflow: visible;\n  position: relative;\n}\n\n.plugin-host-editor {\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n  min-width: 0;\n  overflow: visible;\n}\n\n\n.plugin-panels-left,\n.plugin-panels-right {\n  display: flex;\n  flex-direction: column;\n  flex-shrink: 0;\n  background: #f8f9fa;\n  border-color: #e9ecef;\n}\n\n.plugin-panels-left {\n  border-right: 1px solid #e9ecef;\n}\n\n.plugin-panels-right {\n  border-left: 1px solid #e9ecef;\n}\n\n.plugin-panels-bottom {\n  border-top: 1px solid #e9ecef;\n  background: #f8f9fa;\n}\n\n.plugin-panel {\n  position: relative;\n  display: flex;\n  flex-direction: column;\n  overflow: hidden;\n  transition: width 0.2s ease, height 0.2s ease;\n}\n\n.plugin-panel.collapsed {\n  overflow: visible;\n}\n\n.plugin-panel-toggle {\n  display: flex;\n  align-items: center;\n  gap: 4px;\n  padding: 6px 8px;\n  background: transparent;\n  border: none;\n  cursor: pointer;\n  font-size: 12px;\n  color: #6c757d;\n  white-space: nowrap;\n}\n\n.plugin-panel.collapsed .plugin-panel-toggle {\n  writing-mode: vertical-rl;\n  text-orientation: mixed;\n  flex-direction: column;\n  height: 100%;\n  padding: 8px 6px;\n}\n\n.plugin-panel-toggle:hover {\n  background: #e9ecef;\n  color: #495057;\n}\n\n.plugin-panel-toggle-icon {\n  font-weight: bold;\n  font-size: 14px;\n}\n\n.plugin-panel.collapsed .plugin-panel-toggle-icon {\n  transform: rotate(90deg);\n}\n\n.plugin-panel-toggle-label {\n  font-weight: 500;\n}\n\n.plugin-panel-content {\n  flex: 1;\n  overflow: auto;\n}\n\n/* Overlay panels - positioned absolutely over the editor, outside the page */\n.plugin-panels-overlay-right {\n  position: absolute;\n  top: 0;\n  right: 50%;\n  margin-right: -600px; /* Position outside the ~816px page width / 2 + gap */\n  bottom: 0;\n  width: 220px;\n  pointer-events: none;\n  z-index: 10;\n  overflow: visible;\n  clip: unset;\n}\n\n.plugin-panel-overlay {\n  position: absolute;\n  top: 0;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  display: flex;\n  flex-shrink: 0;\n  pointer-events: none;\n  background: transparent;\n  overflow: visible;\n  clip: unset;\n}\n\n.plugin-panel-overlay.collapsed {\n  display: none;\n}\n\n.plugin-panel-overlay-content {\n  flex: 1;\n  overflow: visible;\n  position: relative;\n  clip: unset;\n}\n\n/* Plugin overlay container for rendering highlights/decorations */\n.plugin-overlays-container {\n  position: absolute;\n  top: 0;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  pointer-events: none;\n  overflow: visible;\n  z-index: 5;\n}\n\n.plugin-overlay {\n  position: absolute;\n  top: 0;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  pointer-events: none;\n}\n\n.plugin-overlay > * {\n  pointer-events: auto;\n}\n";
+/**
+ * PluginHost Component
+ *
+ * Wraps the editor and provides:
+ * - Plugin state management
+ * - Panel rendering for each plugin
+ * - CSS injection for plugin styles
+ * - Callbacks for editor interaction
+ */
+declare const PluginHost: React$1.ForwardRefExoticComponent<PluginHostProps & React$1.RefAttributes<PluginHostRef>>;
+
+/**
+ * Template tag types
+ */
+type TagType = 'variable' | 'sectionStart' | 'sectionEnd' | 'invertedStart' | 'raw';
+/**
+ * A found template tag
+ */
+interface TemplateTag {
+    id: string;
+    type: TagType;
+    name: string;
+    rawTag: string;
+    from: number;
+    to: number;
+    /** For sections: nested variable names */
+    nestedVars?: string[];
+    /** True if this variable is inside a section (shown in section's nested vars) */
+    insideSection?: boolean;
+}
+/**
+ * Plugin state
+ */
+interface TemplatePluginState$1 {
+    tags: TemplateTag[];
+    decorations: DecorationSet;
+    hoveredId?: string;
+    selectedId?: string;
+}
+/**
+ * Plugin key
+ */
+declare const templatePluginKey: PluginKey<TemplatePluginState$1>;
+/**
+ * Create the template plugin
+ */
+declare function createTemplatePlugin(): Plugin<TemplatePluginState$1>;
+/**
+ * Get tags from editor state
+ */
+declare function getTemplateTags(state: prosemirror_state.EditorState): TemplateTag[];
+/**
+ * Set hovered tag
+ */
+declare function setHoveredElement(view: EditorView, id: string | undefined): void;
+/**
+ * Set selected tag
+ */
+declare function setSelectedElement(view: EditorView, id: string | undefined): void;
+/**
+ * CSS styles for template decorations
+ */
+declare const TEMPLATE_DECORATION_STYLES = "\n.docx-template-tag {\n  cursor: pointer;\n  transition: background-color 0.1s;\n}\n\n.docx-template-tag:hover,\n.docx-template-tag.hovered {\n  filter: brightness(0.95);\n}\n\n.docx-template-tag.selected {\n  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.5);\n}\n";
+
+interface PluginState {
+    tags: TemplateTag[];
+    hoveredId?: string;
+    selectedId?: string;
+}
+interface AnnotationPanelProps extends PluginPanelProps<PluginState> {
+}
+declare function AnnotationPanel({ editorView, pluginState, renderedDomContext, }: AnnotationPanelProps): react_jsx_runtime.JSX.Element | null;
+declare const ANNOTATION_PANEL_STYLES = "\n.template-panel {\n  display: flex;\n  min-height: 100%;\n  background: transparent;\n  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;\n  position: relative;\n}\n\n.template-panel-annotations {\n  flex: 1;\n  position: relative;\n  overflow: visible;\n  min-height: 100%;\n  pointer-events: none;\n  will-change: transform;\n}\n\n.template-panel-annotations > * {\n  pointer-events: auto;\n}\n\n.template-annotation-anchor {\n  position: absolute;\n  left: 0;\n  right: 0;\n  display: flex;\n  align-items: flex-start;\n}\n\n.template-annotation-connector {\n  width: 20px;\n  height: 1px;\n  background: #d0d0d0;\n  margin-top: 12px;\n  margin-right: 4px;\n  flex-shrink: 0;\n}\n\n.template-annotation-anchor:hover .template-annotation-connector {\n  background: #3b82f6;\n}\n\n.template-annotation-chip {\n  display: inline-flex;\n  flex-wrap: wrap;\n  align-items: center;\n  gap: 4px;\n  padding: 5px 10px;\n  background: white;\n  border: 1px solid #e2e8f0;\n  border-left: 3px solid #6c757d;\n  border-radius: 4px;\n  font-size: 11px;\n  cursor: pointer;\n  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.06);\n  max-width: 200px;\n}\n\n.template-annotation-chip:hover,\n.template-annotation-chip.hovered {\n  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);\n  border-color: #cbd5e1;\n}\n\n.template-annotation-chip.selected {\n  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.5);\n}\n\n.template-chip-badge {\n  font-size: 9px;\n  font-weight: 600;\n  padding: 1px 5px;\n  border-radius: 3px;\n  color: white;\n  text-transform: uppercase;\n  letter-spacing: 0.3px;\n}\n\n.template-chip-dot {\n  font-size: 8px;\n}\n\n.template-chip-name {\n  color: #334155;\n  font-weight: 500;\n}\n\n.template-chip-nested {\n  display: flex;\n  flex-wrap: wrap;\n  gap: 4px;\n  width: 100%;\n  margin-top: 4px;\n  padding-top: 4px;\n  border-top: 1px solid rgba(0, 0, 0, 0.06);\n}\n\n.template-nested-var {\n  font-size: 10px;\n  color: #64748b;\n  background: rgba(0, 0, 0, 0.04);\n  padding: 2px 6px;\n  border-radius: 3px;\n}\n\n.template-nested-var:hover {\n  background: rgba(59, 130, 246, 0.15);\n  color: #1e40af;\n}\n";
+
+/**
+ * Template Plugin
+ *
+ * Docxtemplater template support as a plugin for the DOCX Editor.
+ *
+ * Features:
+ * - Full docxtemplater syntax detection (variables, loops, conditionals)
+ * - Schema annotation panel showing template structure
+ * - Differentiated visual highlighting by element type
+ *
+ * @example
+ * ```tsx
+ * import { PluginHost } from '@docx-editor/plugin-api';
+ * import { templatePlugin } from '@docx-editor/plugins/template';
+ *
+ * function MyEditor() {
+ *   return (
+ *     <PluginHost plugins={[templatePlugin]}>
+ *       <DocxEditor document={doc} onChange={handleChange} />
+ *     </PluginHost>
+ *   );
+ * }
+ * ```
+ */
+
+/**
+ * Plugin state interface
+ */
+interface TemplatePluginState {
+    tags: TemplateTag[];
+    hoveredId?: string;
+    selectedId?: string;
+}
+/**
+ * Create the template plugin instance.
+ *
+ * @param options - Plugin configuration options
+ */
+declare function createPlugin(options?: {
+    /** Initial panel collapsed state */
+    defaultCollapsed?: boolean;
+    /** Panel position */
+    panelPosition?: 'left' | 'right';
+    /** Panel default width */
+    panelWidth?: number;
+}): EditorPlugin<TemplatePluginState>;
+/**
+ * Default template plugin instance.
+ * Use this for quick setup without custom configuration.
+ */
+declare const templatePlugin: EditorPlugin<TemplatePluginState>;
+
+/**
+ * @eigenpal/docx-js-editor
+ *
+ * A complete WYSIWYG DOCX editor with full Microsoft Word fidelity.
+ *
+ * Features:
+ * - Full text and paragraph formatting
+ * - Tables, images, shapes, text boxes
+ * - Hyperlinks, bookmarks, fields
+ * - Footnotes, lists, headers/footers
+ * - Page layout with margins and columns
+ * - DocumentAgent API for programmatic editing
+ * - Template variable substitution
+ * - AI-powered context menu
+ *
+ * CSS Styles:
+ * For optimal cursor visibility and selection highlighting, import the editor styles:
+ * ```
+ * import '@eigenpal/docx-js-editor/styles/editor.css';
+ * ```
+ */
+declare const VERSION = "0.0.1";
+
+export { AIAction, ANNOTATION_PANEL_STYLES, AgentResponse, AlignmentButtons, type AlignmentButtonsProps, AnnotationPanel, type AutoSaveStatus, BORDER_POSITIONS, BORDER_STYLES, BORDER_WIDTHS, type BorderConfig, type BorderPosition, type BorderStyleType, CLIPBOARD_TYPES, CellBackgroundPicker, type CellBackgroundPickerProps, type CellColorOption, type ClipboardContent, type ClipboardOptions, type ClipboardSelection, type ColorOption, ColorPicker, type ColorPickerProps, ContextMenu, type ContextMenuProps, DEFAULT_BORDER_CONFIG, DEFAULT_CELL_COLORS, DEFAULT_SELECTION_STYLE, type KeyboardShortcut$1 as DialogKeyboardShortcut, Document, DocumentAgent, DocumentViewer, type DocumentViewerProps, DocxEditor, type DocxEditorProps, type DocxEditorRef, type EditorPlugin, ErrorBoundary, type ErrorBoundaryProps, type ErrorContextValue, type ErrorNotification, ErrorProvider, type ErrorSeverity, type FindMatch, type FindOptions, FindReplaceDialog, type FindReplaceDialogProps, type FindReplaceOptions, type FindReplaceState, type FindResult, type FontOption, FontPicker, type FontPickerProps, FontSizePicker, type FontSizePickerProps, HIGH_CONTRAST_SELECTION_STYLE, HeaderFooter, type HighlightOptions, type HighlightRect, HorizontalRuler, type HorizontalRulerProps, type HyperlinkData, HyperlinkDialog, type HyperlinkDialogProps, INTERNAL_CLIPBOARD_TYPE, type ImageData, type IndicatorPosition, type IndicatorVariant, InsertImageDialog, type InsertImageDialogProps, type InsertPosition, InsertSymbolDialog, type InsertSymbolDialogProps, InsertTableDialog, type InsertTableDialogProps, type KeyboardShortcut, KeyboardShortcutsDialog, type KeyboardShortcutsDialogProps, type LineSpacingOption, LineSpacingPicker, type LineSpacingPickerProps, ListButtons, type ListButtonsProps, type ListState, LoadingIndicator, type LoadingIndicatorProps, type LoadingOperation, type LoadingSize, type LoadingVariant, NAVIGATION_SHORTCUTS, type NavigationAction, type NavigationDirection, type NavigationUnit, PLUGIN_HOST_STYLES, type PageIndicatorPosition, type PageIndicatorVariant, PageNavigator, type PageNavigatorPosition, type PageNavigatorProps, type PageNavigatorVariant, PageNumberIndicator, type PageNumberIndicatorProps, type PanelConfig, Paragraph, ParagraphFormatting, ParseErrorDisplay, type ParseErrorDisplayProps, type ParsedClipboardContent, type PasteOption, PasteSpecialDialog, type PasteSpecialDialogProps, type PluginContext, PluginHost, type PluginHostProps, type PluginHostRef, type PluginPanelProps, PrintButton, type PrintButtonProps, type PrintOptions, PrintPreview, type PrintPreviewProps, PrintStyles, ResponsePreview, type ResponsePreviewProps, type ResponsePreviewState, ResponsiveToolbar, ToolbarGroup as ResponsiveToolbarGroup, type ToolbarGroupProps as ResponsiveToolbarGroupProps, type ResponsiveToolbarProps, Run, RunContent, SELECTION_CSS_VARS, SYMBOL_CATEGORIES, type SavedDocumentData, SectionProperties, SelectionContext, type SelectionHighlightConfig, type SelectionOverlayProps, type SelectionRange, type ShortcutCategory, Style, type StyleOption, StylePicker, type StylePickerProps, type SymbolCategory, TABLE_DATA_ATTRIBUTES, TEMPLATE_DECORATION_STYLES, Table, type TableAction, TableBorderPicker, type TableBorderPickerProps, TableCell, type TableConfig, type TableContext, type TableSelection, type TableSelectionState, TableToolbar, type TableToolbarProps, type TagType, type TemplateTag, type TextContextAction, TextContextMenu, type TextContextMenuItem, type TextContextMenuProps, TextFormatting, Theme, Toolbar, ToolbarButton, ToolbarGroup$1 as ToolbarGroup, type ToolbarItem, type ToolbarItemPriority, type ToolbarProps, ToolbarSeparator, UnsavedIndicator, type UnsavedIndicatorProps, UnsupportedFeatureWarning, type UnsupportedFeatureWarningProps, type UseAutoSaveOptions, type UseAutoSaveReturn, type UseClipboardOptions, type UseClipboardReturn, type UseFindReplaceReturn, type UseKeyboardShortcutsDialogOptions, type UseKeyboardShortcutsDialogReturn, type UseLoadingOptions, type UseLoadingReturn, type UsePasteSpecialOptions, type UsePasteSpecialReturn, type UseResponsiveToolbarOptions, type UseResponsiveToolbarReturn, type UseSelectionHighlightOptions, type UseSelectionHighlightReturn, type UseTableSelectionOptions, type UseTableSelectionReturn, type UseTextContextMenuOptions, type UseTextContextMenuReturn, type UseUnsavedChangesOptions, type UseUnsavedChangesReturn, type UseWheelZoomOptions, type UseWheelZoomReturn, VERSION, VariablePanel, type VariablePanelProps, type WordSelectionResult, ZOOM_PRESETS, ZoomControl, type ZoomControlProps, addColumn, addRow, areSelectionStylesInjected, calculateFitDimensions, calculateFitPageZoom, calculateFitWidthZoom, calculateProgress, calculateScrollToPage, calculateVisiblePage, canRenderFont, clampPageNumber, clampTableConfig, clampZoom, cleanWordHtml, clearSelection, copyParagraphs, copyRuns, countPageBreaks, createBorderConfig, createBorderSpec, createCellColorOption, createChangeTracker, createClipboardHandlers, createColumnBreak, createDefaultFindOptions, createDefaultListState, createDefaultTableConfig, createDoubleClickWordSelector, createErrorResponse, createHorizontalRule, createLineBreak, createMockResponse, createPageBreak, createPageBreakParagraph, createPageBreakRun, createPageFormat, createSearchPattern, createSelectionChangeHandler, createSelectionFromDOM, createShadingFromColor, createTableContext, createPlugin as createTemplatePlugin, createTemplatePlugin as createTemplateProseMirrorPlugin, createToolbarItem, createToolbarItems, createTripleClickParagraphSelector, dataUrlToBlob, DocxEditor as default, delay, deleteColumn, deleteRow, describeShortcut, escapeRegexString, expandSelectionToWord, expandSelectionToWordBoundaries, extendSelectionTo, findAllMatches, findInDocument, findInParagraph, findNearestZoomPreset, findNextWordStart, findPageBreaks, findPreviousWordStart, findVisualLineEnd, findVisualLineStart, findWordAt, findWordBoundaries, findWordEnd, findWordStart, formatFileSize, formatLastSaveTime, formatPageOrdinal, formatPageRange$1 as formatPageRange, formatPageRange as formatPrintPageRange, formatShortcutKeys, formatStorageSize, formatTableDimensions, formatZoom, generateOverlayElements, generateSelectionCSS, getActionShortcut, getAllActions, getAllCategories, getAllPositions as getAllIndicatorPositions, getAllVariants as getAllIndicatorVariants, getAllLoadingSizes, getAllLoadingVariants, getAllPasteOptions, getAutoSaveStatusLabel, getAutoSaveStorageSize, getAvailableBorderStyles, getAvailableBorderWidths, getBorderPositionLabel, getCategoryLabel, getCellAt, getCellColorName, getColorFromShading, getColumnCount, getCommonShortcuts, getContrastingTextColor, getDefaultActions, getDefaultCellColors, getDefaultHighlightOptions, getDefaultPasteOption, getDefaultPrintOptions, getDefaultShortcuts, getDefaultTextContextMenuItems, getHighlightRectStyle, getImageAcceptString, getImageDimensions, getLoadedFonts, getLoadingVariantLabel, getMarginInUnits, getMatchCountText, getMergedSelectionRects, getNavigationShortcutDescriptions, getNavigationShortcuts, getNextZoomPreset, getPageProgress, getPasteOption, getPreviousZoomPreset, getRecommendedPriority, getRulerDimensions, getSelectedText, getSelectionBoundingRect, getSelectionInfo, getSelectionRects, getSelectionRuns, getShortcutsByCategory, getSupportedImageExtensions, getSymbolCategories, getSymbolInfo as getSymbolUnicodeInfo, getSymbolsByCategory, getTablePresets, getTemplateTags as getTemplatePluginTags, getTextActionLabel, getTextActionShortcut, getUserFriendlyMessage, getVariantLabel, getVisiblePages, getWordAt, getWordAtCursor, getZoomPresets, handleClickForMultiClick, handleNavigationKey, handlePasteEvent, hasActiveSelection, hasPageBreakBefore, highlightTextRange, htmlToRuns, injectSelectionStyles, insertHorizontalRule, insertPageBreak, isActionAvailable, isAutoSaveSupported, isBreakContent, isColumnBreak, isDefaultCellColor, isEditorHtml, isEmptySearch, isFirstPage, isFontLoaded, isLoading as isFontsLoading, isLastPage, isLineBreak, isNavigationKey, isPageBreak, isParseError, isPasteSpecialShortcut, isPrintSupported, isPunctuation, isSelectionBackwards, isSelectionWithin, isTextActionAvailable, isValidImageFile, isValidPageNumber, isValidTableConfig, isWhitespace$1 as isWhitespace, isWhitespace as isWhitespaceChar, isWordCharacter as isWordChar, isWordCharacter$1 as isWordCharacter, isWordHtml, isZoomPreset, loadFont, loadFontFromBuffer, loadFonts, mapStyleToCss, matchesShortcut, mergeAdjacentRects, mergeCells, moveByWord, moveToLineEdge, normalizeSelectionDirection, onFontsLoaded, openPrintWindow, paragraphsToClipboardContent, parseClipboardHtml, parseMarginFromUnits, parseNavigationAction, parsePageInput, parsePageRange, parseZoom, positionToMargin, preloadCommonFonts, readFromClipboard, removePageBreak, removeSelectionStyles, replaceAllInContent, replaceFirstInContent, runsToClipboardContent, scrollToMatch, scrollToPage, searchSymbols, selectParagraphAtCursor, selectRange, selectWordAtCursor, selectWordInTextNode, setHoveredElement, setSelectedElement, setSelectionPosition, splitCell, symbolFromCodePoint, templatePlugin, templatePluginKey, triggerPrint, useAutoSave, useClipboard, useContextMenu, useErrorNotifications, useFindReplace, useHyperlinkDialog, useInsertImageDialog, useInsertSymbolDialog, useInsertTableDialog, useKeyboardShortcutsDialog, useLoading, useLoadingOperations, usePasteSpecial, useResponsePreview, useResponsiveToolbar, useSelectionHighlight, useTableSelection, useTextContextMenu, useUnsavedChanges, useWheelZoom, writeToClipboard };