@eigenpal/docx-js-editor 0.0.16 → 0.0.17

package/dist/react.d.ts

@@ -1,9 +1,860 @@
-export { A as AutoSaveStatus, C as ClipboardSelection, a as DocxEditor, b as DocxEditorHandle, c as DocxEditorProps, d as DocxEditorRef, E as EditorPlugin, e as ErrorBoundary, f as ErrorBoundaryProps, g as ErrorContextValue, h as ErrorNotification, i as ErrorProvider, j as ErrorSeverity, l as PLUGIN_HOST_STYLES, m as PanelConfig, n as ParseErrorDisplay, o as ParseErrorDisplayProps, p as PluginContext, q as PluginHost, r as PluginHostProps, s as PluginHostRef, P as PluginPanelProps, R as RenderAsyncOptions, v as SavedDocumentData, x as SelectionOverlayProps, T as TABLE_DATA_ATTRIBUTES, z as TableSelectionState, U as UnsupportedFeatureWarning, B as UnsupportedFeatureWarningProps, F as UseAutoSaveOptions, G as UseAutoSaveReturn, I as UseClipboardOptions, J as UseClipboardReturn, K as UseSelectionHighlightOptions, L as UseSelectionHighlightReturn, M as UseTableSelectionOptions, N as UseTableSelectionReturn, O as UseWheelZoomOptions, Q as UseWheelZoomReturn, Z as ZOOM_PRESETS, W as clampZoom, _ as createSelectionFromDOM, $ as findNearestZoomPreset, a0 as formatLastSaveTime, a1 as formatStorageSize, a2 as formatZoom, a3 as generateOverlayElements, a5 as getAutoSaveStatusLabel, a6 as getAutoSaveStorageSize, a9 as getNextZoomPreset, aa as getPreviousZoomPreset, ae as getSelectionRuns, af as getUserFriendlyMessage, ag as getZoomPresets, ak as isAutoSaveSupported, al as isParseError, ao as isZoomPreset, ar as parseZoom, at as renderAsync, av as useAutoSave, aw as useClipboard, ax as useErrorNotifications, ay as useSelectionHighlight, az as useTableSelection, aA as useWheelZoom } from './react-BZxD04XV.js';
-export { a as DocxInput, t as toArrayBuffer } from './DocumentAgent-Ci6_T-XM.js';
-import 'react';
-import 'prosemirror-view';
-import 'prosemirror-state';
-import './agentApi-CbVUCZRu.js';
-import './clipboard-BOocwmAM.js';
-import 'prosemirror-model';
-import 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode, CSSProperties, Component, ErrorInfo } from 'react';
+import * as prosemirror_view from 'prosemirror-view';
+import { EditorView } from 'prosemirror-view';
+import * as prosemirror_state from 'prosemirror-state';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { Document, Theme, Table, Run } from '@eigenpal/docx-core/types/document';
+import { P as PageIndicatorPosition, c as PageNavigatorPosition, a as PageIndicatorVariant, e as PageNavigatorVariant, j as PrintOptions, l as TableContext, T as TableAction } from './TableToolbar-RHX9L4h9.js';
+import { DocumentAgent } from '@eigenpal/docx-core/agent/DocumentAgent';
+import { DocxInput } from '@eigenpal/docx-core/utils/docxInput';
+export { DocxInput, toArrayBuffer } from '@eigenpal/docx-core/utils/docxInput';
+import { SelectionState } from '@eigenpal/docx-core/prosemirror';
+import { Layout } from '@eigenpal/docx-core/layout-engine/types';
+import { EditorPluginCore, PluginPanelProps, RenderedDomContext } from '@eigenpal/docx-core/plugin-api/types';
+export { PanelConfig, PluginPanelProps } from '@eigenpal/docx-core/plugin-api/types';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ParsedClipboardContent } from '@eigenpal/docx-core/utils/clipboard';
+import { HighlightRect, SelectionHighlightConfig } from '@eigenpal/docx-core/utils/selectionHighlight';
+
+/**
+ * React Plugin Interface for the DOCX Editor
+ *
+ * Extends the framework-agnostic EditorPluginCore with React-specific
+ * UI rendering capabilities (Panel component, renderOverlay).
+ */
+
+/**
+ * React-specific editor plugin interface.
+ *
+ * Extends EditorPluginCore with:
+ * - Panel: React component for rendering in the annotation panel
+ * - renderOverlay: Function returning ReactNode for overlay rendering
+ */
+interface ReactEditorPlugin<TState = any> extends EditorPluginCore<TState> {
+    /**
+     * React component to render in the annotation panel area.
+     * Receives editor state and callbacks for interaction.
+     */
+    Panel?: React.ComponentType<PluginPanelProps<TState>>;
+    /**
+     * 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.
+     *
+     * @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;
+}
+/**
+ * Backwards-compatible alias — EditorPlugin is now ReactEditorPlugin.
+ */
+type EditorPlugin<TState = any> = ReactEditorPlugin<TState>;
+/**
+ * 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;
+}
+
+interface PagedEditorRef {
+    /** Get the current document. */
+    getDocument(): Document | null;
+    /** Get the ProseMirror EditorState. */
+    getState(): EditorState | null;
+    /** Get the ProseMirror EditorView. */
+    getView(): EditorView | null;
+    /** Focus the editor. */
+    focus(): void;
+    /** Blur the editor. */
+    blur(): void;
+    /** Check if focused. */
+    isFocused(): boolean;
+    /** Dispatch a transaction. */
+    dispatch(tr: Transaction): void;
+    /** Undo. */
+    undo(): boolean;
+    /** Redo. */
+    redo(): boolean;
+    /** Set selection by PM position. */
+    setSelection(anchor: number, head?: number): void;
+    /** Get current layout. */
+    getLayout(): Layout | null;
+    /** Force re-layout. */
+    relayout(): void;
+    /** Scroll the visible pages to bring a PM position into view. */
+    scrollToPosition(pmPos: number): void;
+}
+
+/**
+ * DocxEditor props
+ */
+interface DocxEditorProps {
+    /** Document data — ArrayBuffer, Uint8Array, Blob, or File */
+    documentBuffer?: DocxInput | 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 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. When true, hides toolbar and rulers */
+    readOnly?: boolean;
+    /** Custom toolbar actions */
+    toolbarExtra?: ReactNode;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: CSSProperties;
+    /** Placeholder when no document */
+    placeholder?: ReactNode;
+    /** Loading indicator */
+    loadingIndicator?: ReactNode;
+    /** Whether to show the document outline sidebar (default: false) */
+    showOutline?: boolean;
+    /** 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;
+    /**
+     * 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 editor ref */
+    getEditorRef: () => PagedEditorRef | 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$1.ForwardRefExoticComponent<DocxEditorProps & React$1.RefAttributes<DocxEditorRef>>;
+
+/**
+ * Simple imperative API for rendering a DOCX editor into a DOM element.
+ *
+ * Usage:
+ * ```ts
+ * import { renderAsync } from '@eigenpal/docx-js-editor';
+ *
+ * const editor = await renderAsync(docxBlob, document.getElementById('container'), {
+ *   readOnly: false,
+ *   showToolbar: true,
+ * });
+ *
+ * // Save the edited document
+ * const buffer = await editor.save();
+ *
+ * // Clean up
+ * editor.destroy();
+ * ```
+ */
+
+/**
+ * Options for {@link renderAsync}. A subset of DocxEditorProps minus
+ * `documentBuffer` / `document` (passed as the first argument instead).
+ */
+type RenderAsyncOptions = Omit<DocxEditorProps, 'documentBuffer' | 'document'>;
+/**
+ * Handle returned by {@link renderAsync} for interacting with the editor.
+ */
+interface DocxEditorHandle {
+    /** Save the document and return the DOCX as an ArrayBuffer. */
+    save: () => Promise<ArrayBuffer | null>;
+    /** Get the current parsed document model. */
+    getDocument: () => Document | null;
+    /** Focus the editor. */
+    focus: () => void;
+    /** Set zoom level (1.0 = 100%). */
+    setZoom: (zoom: number) => void;
+    /** Unmount the editor and clean up. */
+    destroy: () => void;
+}
+/**
+ * Render a DOCX editor into a container element.
+ *
+ * @param input - DOCX data as ArrayBuffer, Uint8Array, Blob, or File
+ * @param container - DOM element to render into
+ * @param options - Editor configuration (toolbar, readOnly, callbacks, etc.)
+ * @returns A handle with save / destroy / getDocument methods
+ */
+declare function renderAsync(input: DocxInput, container: HTMLElement, options?: RenderAsyncOptions): Promise<DocxEditorHandle>;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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[];
+
+/**
+ * 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/* Right panel rendered inside viewport - scrolls with content */\n.plugin-panel-in-viewport {\n  position: absolute;\n  top: 0;\n  /* Position is set dynamically via inline styles based on page edge */\n  width: 220px;\n  pointer-events: auto;\n  z-index: 10;\n  overflow: visible;\n}\n\n.plugin-panel-in-viewport.collapsed {\n  width: 32px;\n}\n\n.plugin-panel-in-viewport .plugin-panel-toggle {\n  position: sticky;\n  top: 0;\n  background: rgba(255, 255, 255, 0.95);\n  border-radius: 4px;\n  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);\n}\n\n.plugin-panel-in-viewport-content {\n  overflow: visible;\n  position: relative;\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>>;
+
+export { type AutoSaveStatus, type ClipboardSelection, DocxEditor, type DocxEditorHandle, type DocxEditorProps, type DocxEditorRef, type EditorPlugin, ErrorBoundary, type ErrorBoundaryProps, type ErrorContextValue, type ErrorNotification, ErrorProvider, type ErrorSeverity, PLUGIN_HOST_STYLES, ParseErrorDisplay, type ParseErrorDisplayProps, type PluginContext, PluginHost, type PluginHostProps, type PluginHostRef, type RenderAsyncOptions, type SavedDocumentData, type SelectionOverlayProps, TABLE_DATA_ATTRIBUTES, type TableSelectionState, UnsupportedFeatureWarning, type UnsupportedFeatureWarningProps, type UseAutoSaveOptions, type UseAutoSaveReturn, type UseClipboardOptions, type UseClipboardReturn, type UseSelectionHighlightOptions, type UseSelectionHighlightReturn, type UseTableSelectionOptions, type UseTableSelectionReturn, type UseWheelZoomOptions, type UseWheelZoomReturn, ZOOM_PRESETS, clampZoom, createSelectionFromDOM, findNearestZoomPreset, formatLastSaveTime, formatStorageSize, formatZoom, generateOverlayElements, getAutoSaveStatusLabel, getAutoSaveStorageSize, getNextZoomPreset, getPreviousZoomPreset, getSelectionRuns, getUserFriendlyMessage, getZoomPresets, isAutoSaveSupported, isParseError, isZoomPreset, parseZoom, renderAsync, useAutoSave, useClipboard, useErrorNotifications, useSelectionHighlight, useTableSelection, useWheelZoom };