superdoc 0.31.3 → 0.32.0-beta.1

package/dist/super-editor/super-editor/src/core/Editor.d.ts

@@ -1,469 +1,273 @@
-/**
- * @typedef {Object} FieldValue
- * @property {string} input_id The id of the input field
- * @property {string} input_value The value to insert into the field
- */
-/**
- * A map of plugin names to their helper API objects.
- * Each plugin defines its own helper methods.
- *
- * Example:
- * editor.helpers.linkedStyles.getStyles()
- *
- * @typedef {Object<string, Object<string, Function>>} EditorHelpers
- */
-/**
- * Editor main class.
- *
- * Expects a config object.
- * @class
- */
-/**
- * @typedef {Object} User The current user of this superdoc
- * @property {string} name The user's name
- * @property {string} email The user's email
- * @property {string | null} image The user's photo
- */
-/**
- * @typedef {Object} DocxNode A JSON representation of a docx node
- */
-/**
- * @typedef {Object} EditorOptions
- * @property {HTMLElement} [element] - The container element for the editor
- * @property {string} [selector] - CSS selector for the editor container
- * @property {boolean} [isHeadless=false] - Whether the editor is running in headless mode
- * @property {Document} [mockDocument] - Mock document for testing
- * @property {Window} [mockWindow] - Mock window for testing
- * @property {string} [content=''] - XML content
- * @property {User} [user] - Current user information
- * @property {Array.<User>} [users=[]] - List of users for collaboration
- * @property {Object} [media={}] - Media configuration
- * @property {Object} [mediaFiles={}] - Media files
- * @property {Object} [fonts={}] - Font configuration
- * @property {string} [documentMode='editing'] - Document mode ('editing', 'viewing', 'suggesting')
- * @property {string} [mode='docx'] - Editor mode ('docx', 'text', 'html')
- * @property {string} [role='editor'] - User role ('editor', 'viewer', 'suggester')
- * @property {Array} [colors=[]] - Available colors
- * @property {Object} [converter] - Document converter
- * @property {File|Blob|Buffer} [fileSource] - Source of the file (File/Blob in browser, Buffer in Node.js)
- * @property {Object} [initialState] - Initial editor state
- * @property {string} [documentId] - Unique document identifier
- * @property {Array} [extensions=[]] - Editor extensions
- * @property {boolean} [editable=true] - Whether the editor is editable
- * @property {Object} [editorProps={}] - Editor properties
- * @property {Object} [parseOptions={}] - Parsing options
- * @property {Object} [coreExtensionOptions={}] - Core extension options
- * @property {boolean} [enableInputRules=true] - Whether to enable input rules
- * @property {boolean} [isCommentsEnabled=false] - Whether comments are enabled
- * @property {boolean} [isNewFile=false] - Whether this is a new file
- * @property {number} [scale=1] - Editor scale/zoom
- * @property {boolean} [annotations=false] - Whether annotations are enabled
- * @property {boolean} [isInternal=false] - Whether this is an internal editor
- * @property {Array} [externalExtensions=[]] - External extensions
- * @property {Object} [numbering={}] - Numbering configuration
- * @property {boolean} [isHeaderOrFooter=false] - Whether this is a header or footer editor
- * @property {Function} [onBeforeCreate] - Called before editor creation
- * @property {Function} [onCreate] - Called after editor creation
- * @property {Function} [onUpdate] - Called when editor content updates
- * @property {Function} [onSelectionUpdate] - Called when selection updates
- * @property {Function} [onTransaction] - Called when a transaction is processed
- * @property {Function} [onFocus] - Called when editor gets focus
- * @property {Function} [onBlur] - Called when editor loses focus
- * @property {Function} [onDestroy] - Called when editor is destroyed
- * @property {Function} [onContentError] - Called when there's a content error
- * @property {Function} [onTrackedChangesUpdate] - Called when tracked changes update
- * @property {Function} [onCommentsUpdate] - Called when comments update
- * @property {Function} [onCommentsLoaded] - Called when comments are loaded
- * @property {Function} [onCommentClicked] - Called when a comment is clicked
- * @property {Function} [onCommentLocationsUpdate] - Called when comment locations update
- * @property {Function} [onDocumentLocked] - Called when document is locked
- * @property {Function} [onFirstRender] - Called on first render
- * @property {Function} [onCollaborationReady] - Called when collaboration is ready
- * @property {Function} [onPaginationUpdate] - Called when pagination updates
- * @property {Function} [onException] - Called when an exception occurs
- * @property {Function} [onListDefinitionsChange] - Called when list definitions change
- * @property {Function} [onFontsResolved] - Called when all fonts used in the document are determined
- * @property {Function} [handleImageUpload] - Handler for image uploads
- * @property {Object} [telemetry] - Telemetry configuration
- * @property {boolean} [suppressDefaultDocxStyles] - Prevent default styles from being applied in docx mode
- * @property {Object} [jsonOverride] - Provided JSON to override content with
- * @property {string} [html] - HTML content to initialize the editor with
- * @property {string} [markdown] - Markdown content to initialize the editor with
- * @property {boolean} [isDebug=false] - Whether to enable debug mode
- * @property {(params: {
- *   permission: string,
- *   role?: string,
- *   isInternal?: boolean,
- *   comment?: Object | null,
- *   trackedChange?: Object | null,
- }) => boolean | undefined} [permissionResolver] - Host-provided permission hook
- */
+import type { EditorState, Plugin } from 'prosemirror-state';
+import type { Node as PmNode, Schema } from 'prosemirror-model';
+import type { EditorOptions, User, FieldValue, DocxFileEntry } from './types/EditorConfig.js';
+import type { EditorHelpers, ExtensionStorage, ProseMirrorJSON, PageStyles, Toolbar } from './types/EditorTypes.js';
+import type { ChainableCommandObject, CanObject, EditorCommands } from './types/ChainedCommands.js';
+import type { EditorEventMap, Comment } from './types/EditorEvents.js';
+import type { SchemaSummaryJSON } from './types/EditorSchema.js';
+import { EditorView } from 'prosemirror-view';
+import { EventEmitter } from './EventEmitter.js';
+import { ExtensionService } from './ExtensionService.js';
+import { SuperConverter } from '@core/super-converter/SuperConverter.js';
 /**
  * Main editor class that manages document state, extensions, and user interactions
- * @class
- * @extends EventEmitter
  */
-export class Editor extends EventEmitter {
-    /**
-     * Load the data from DOCX to be used in the schema.
-     * Expects a DOCX file.
-     * @static
-     * @async
-     * @param {File|Blob|Buffer} fileSource - The DOCX file to load (File/Blob in browser, Buffer in Node.js)
-     * @param {boolean} [isNode=false] - Whether the method is being called in a Node.js environment
-     * @returns {Promise<Array>} - A promise that resolves to an array containing:
-     *   - [0] xmlFiles - Array of XML files extracted from the DOCX
-     *   - [1] mediaFiles - Object containing media files with URLs (browser only)
-     *   - [2] mediaFiles - Object containing media files with base64 data
-     *   - [3] fonts - Object containing font files from the DOCX
-     */
-    static loadXmlData(fileSource: File | Blob | Buffer, isNode?: boolean): Promise<any[]>;
-    /**
-     * Get the document version
-     * @static
-     * @param {Object} doc - Document object
-     * @returns {string} Document version
-     */
-    static getDocumentVersion(doc: any): string;
+export declare class Editor extends EventEmitter<EditorEventMap> {
+    #private;
     /**
-     * Set the document version
-     * @static
-     * @param {Object} doc - Document object
-     * @param {string} version - New version
-     * @returns {string} The set version
+     * Service for managing extensions
      */
-    static setDocumentVersion(doc: any, version: string): string;
+    extensionService: ExtensionService;
     /**
-     * Get the document GUID
-     * @static
-     * @param {Object} doc - Document object
-     * @returns {string|null} Document GUID
+     * Storage for extension data
      */
-    static getDocumentGuid(doc: any): string | null;
+    extensionStorage: ExtensionStorage;
     /**
-     * @deprecated use setDocumentVersion instead
+     * ProseMirror schema for the editor
      */
-    static updateDocumentVersion(doc: any, version: any): string;
+    schema: Schema;
     /**
-     * Check if migrations are needed for the data
-     * @static
-     * @param {Object} data - Document data
-     * @returns {boolean} Whether migrations are needed
+     * ProseMirror view instance
      */
-    static checkIfMigrationsNeeded(): boolean;
+    view: EditorView;
     /**
-     * Create a new Editor instance
-     * @param {EditorOptions} options - Editor configuration options
+     * Whether the editor currently has focus
      */
-    constructor(options: EditorOptions);
+    isFocused: boolean;
     /**
-     * Service for managing extensions
-     * @type {Object}
+     * All the embedded fonts that were imported by the Editor
      */
-    extensionService: any;
+    fontsImported: string[];
     /**
-     * Storage for extension data
-     * @type {Object}
+     * The document converter instance
      */
-    extensionStorage: any;
+    converter: SuperConverter;
     /**
-     * ProseMirror schema for the editor
-     * @type {Object}
+     * Toolbar instance (if attached)
      */
-    schema: any;
+    toolbar?: Toolbar;
     /**
-     * ProseMirror view instance
-     * @type {Object}
+     * Original state for preview mode
      */
-    view: any;
+    originalState?: EditorState;
     /**
-     * Whether the editor currently has focus
-     * @type {boolean}
+     * High contrast mode setter
      */
-    isFocused: boolean;
+    setHighContrastMode?: (enabled: boolean) => void;
+    options: EditorOptions;
     /**
-     * All the embedded fonts that were imported by the Editor
-     * @type {string[]}
+     * Create a new Editor instance
+     * @param options - Editor configuration options
      */
-    fontsImported: string[];
-    options: {
-        element: any;
-        selector: any;
-        isHeadless: boolean;
-        mockDocument: any;
-        mockWindow: any;
-        content: string;
-        user: any;
-        users: any[];
-        media: {};
-        mediaFiles: {};
-        fonts: {};
-        documentMode: string;
-        mode: string;
-        role: string;
-        colors: any[];
-        converter: any;
-        fileSource: any;
-        initialState: any;
-        documentId: any;
-        extensions: any[];
-        editable: boolean;
-        editorProps: {};
-        parseOptions: {};
-        coreExtensionOptions: {};
-        enableInputRules: boolean;
-        isCommentsEnabled: boolean;
-        isNewFile: boolean;
-        scale: number;
-        annotations: boolean;
-        isInternal: boolean;
-        externalExtensions: any[];
-        numbering: {};
-        isHeaderOrFooter: boolean;
-        lastSelection: any;
-        suppressDefaultDocxStyles: boolean;
-        jsonOverride: any;
-        onBeforeCreate: () => any;
-        onCreate: () => any;
-        onUpdate: () => any;
-        onSelectionUpdate: () => any;
-        onTransaction: () => any;
-        onFocus: () => any;
-        onBlur: () => any;
-        onDestroy: () => any;
-        onContentError: ({ error }: {
-            error: any;
-        }) => never;
-        onTrackedChangesUpdate: () => any;
-        onCommentsUpdate: () => any;
-        onCommentsLoaded: () => any;
-        onCommentClicked: () => any;
-        onCommentLocationsUpdate: () => any;
-        onDocumentLocked: () => any;
-        onFirstRender: () => any;
-        onCollaborationReady: () => any;
-        onPaginationUpdate: () => any;
-        onException: () => any;
-        onListDefinitionsChange: () => any;
-        onFontsResolved: any;
-        handleImageUpload: any;
-        telemetry: any;
-        customUpdatedFiles: {};
-        isHeaderFooterChanged: boolean;
-        isCustomXmlChanged: boolean;
-        focusTarget: any;
-        permissionResolver: any;
-        parentEditor: any;
-    };
-    setHighContrastMode: (value: any) => void;
+    constructor(options: Partial<EditorOptions>);
     /**
      * Getter which indicates if any changes happen in Editor
-     * @returns {boolean}
      */
     get docChanged(): boolean;
-    mount(el: any): void;
+    mount(el: HTMLElement | null): void;
     unmount(): void;
     /**
      * Set the toolbar for this editor
-     * @param {Object} toolbar - The toolbar instance
-     * @returns {void}
      */
-    setToolbar(toolbar: any): void;
-    toolbar: any;
+    setToolbar(toolbar: Toolbar): void;
     /**
      * Focus the editor.
-     * @returns {void}
      */
     focus(): void;
     /**
      * Get the editor state
-     * @returns {Object} ProseMirror state
      */
-    get state(): any;
+    get state(): EditorState;
     /**
      * Get the editor storage.
-     * @returns {Object} Editor storage object
      */
-    get storage(): any;
+    get storage(): ExtensionStorage;
     /**
      * Get object of registered commands.
-     * @returns {import('./commands/types/index.js').EditorCommands} Commands object
      */
-    get commands(): import("./commands/types/index.js").EditorCommands;
+    get commands(): EditorCommands;
     /**
      * Get extension helpers.
-     * @returns {EditorHelpers} Object with helper methods for extensions
      */
     get helpers(): EditorHelpers;
     /**
      * Check if the editor is editable.
-     * @returns {boolean}
      */
     get isEditable(): boolean;
     /**
      * Check if editor is destroyed.
-     * @returns {boolean}
      */
     get isDestroyed(): boolean;
     /**
      * Get the editor element
-     * @returns {HTMLElement} The editor element
      */
-    get element(): HTMLElement;
+    get element(): HTMLElement | null;
     /**
      * Get possible users of the editor.
-     * @returns {Array.<User>} List of users
      */
-    get users(): Array<User>;
+    get users(): User[];
     /**
      * Create a chain of commands to call multiple commands at once.
-     * @returns {Object} Command chain
      */
-    chain(): any;
+    chain(): ChainableCommandObject;
     /**
      * Check if a command or a chain of commands can be executed. Without executing it.
-     * @returns {Object} Object with methods to check command availability
      */
-    can(): any;
+    can(): CanObject;
     /**
      * Set the document mode
-     * @param {string} documentMode - The document mode ('editing', 'viewing', 'suggesting')
-     * @param {string} caller - Calling context
+     * @param documentMode - The document mode ('editing', 'viewing', 'suggesting')
+     * @param caller - Calling context
      */
-    setDocumentMode(documentMode: string, caller: string): void;
+    setDocumentMode(documentMode: string, caller?: string): void;
     /**
      * Export the yjs binary from the current state.
-     * @returns {Promise<Uint8Array>} The exported yjs binary
      */
     generateCollaborationUpdate(): Promise<Uint8Array>;
     /**
      * Initialize data for collaborative editing
      * If we are replacing data and have a valid provider, listen for synced event
      * so that we can initialize the data
-     * @returns {void}
      */
     initializeCollaborationData(): void;
     /**
      * Replace content of editor that was created with loadFromSchema option
      * Used to replace content of other header/footer when one of it was edited
      *
-     * @param {object} content - new editor content json (retrieved from editor.getUpdatedJson)
-     * @returns {void}
+     * @param content - new editor content json (retrieved from editor.getUpdatedJson)
      */
-    replaceContent(content: object): void;
+    replaceContent(content: ProseMirrorJSON): void;
     /**
      * Set editor options and update state.
-     * @param {EditorOptions} options - Editor options
-     * @returns {void}
      */
-    setOptions(options?: EditorOptions): void;
+    setOptions(options?: Partial<EditorOptions>): void;
     /**
      * Set whether the editor is editable
-     * @param {boolean} [editable=true] - Whether the editor is editable
-     * @param {boolean} [emitUpdate=true] - Whether to emit an update event
-     * @returns {void}
      */
     setEditable(editable?: boolean, emitUpdate?: boolean): void;
     /**
      * Register PM plugin.
      * @param plugin PM plugin.
      * @param handlePlugins Optional function for handling plugin merge.
-     * @returns {void}
      */
-    registerPlugin(plugin: any, handlePlugins: any): void;
+    registerPlugin(plugin: Plugin, handlePlugins?: (plugin: Plugin, plugins: Plugin[]) => Plugin[]): void;
     /**
      * Unregister a PM plugin
-     * @param {string|Object} nameOrPluginKey - Plugin name or plugin instance
-     * @returns {void}
      */
-    unregisterPlugin(nameOrPluginKey: string | any): void;
-    converter: any;
+    unregisterPlugin(nameOrPluginKey: string | {
+        key?: string;
+    }): void;
+    /**
+     * Load the data from DOCX to be used in the schema.
+     * Expects a DOCX file.
+     * @param fileSource - The DOCX file to load (File/Blob in browser, Buffer in Node.js)
+     * @param isNode - Whether the method is being called in a Node.js environment
+     * @returns A promise that resolves to an array containing:
+     *   - [0] xmlFiles - Array of XML files extracted from the DOCX
+     *   - [1] mediaFiles - Object containing media files with URLs (browser only)
+     *   - [2] mediaFiles - Object containing media files with base64 data
+     *   - [3] fonts - Object containing font files from the DOCX
+     */
+    static loadXmlData(fileSource: File | Blob | Buffer, isNode?: boolean): Promise<[DocxFileEntry[], Record<string, unknown>, Record<string, unknown>, Record<string, unknown>] | undefined>;
+    /**
+     * Get the document version
+     */
+    static getDocumentVersion(doc: DocxFileEntry[]): string;
+    /**
+     * Set the document version
+     */
+    static setDocumentVersion(doc: DocxFileEntry[], version: string): string;
+    /**
+     * Get the document GUID
+     */
+    static getDocumentGuid(doc: DocxFileEntry[]): string | null;
+    /**
+     * @deprecated use setDocumentVersion instead
+     */
+    static updateDocumentVersion(doc: DocxFileEntry[], version: string): string;
+    /**
+     * Generates a schema summary for the current runtime schema.
+     */
+    getSchemaSummaryJSON(): Promise<SchemaSummaryJSON>;
+    /**
+     * Validates a ProseMirror JSON document against the current schema.
+     */
+    validateJSON(doc: ProseMirrorJSON | ProseMirrorJSON[]): PmNode;
     /**
      * Creates all node views.
-     * @returns {void}
      */
     createNodeViews(): void;
     /**
      * Get the maximum content size
-     * @returns {Object} Size object with width and height
      */
-    getMaxContentSize(): any;
+    getMaxContentSize(): {
+        width?: number;
+        height?: number;
+    };
     /**
      * Attach styles and attributes to the editor element
      */
-    updateEditorStyles(element: any, proseMirror: any, hasPaginationEnabled?: boolean): void;
+    updateEditorStyles(element: HTMLElement, proseMirror: HTMLElement, hasPaginationEnabled?: boolean): void;
     /**
      * Initialize default styles for the editor container and ProseMirror.
      * Get page size and margins from the converter.
      * Set document default font and font size.
      *
-     * @param {HTMLElement} [element=this.element] - The DOM element to apply styles to
-     * @returns {void}
+     * @param element - The DOM element to apply styles to
      */
-    initDefaultStyles(element?: HTMLElement, isPaginationEnabled?: boolean): void;
+    initDefaultStyles(element?: HTMLElement | null, isPaginationEnabled?: boolean): void;
     /**
      * Initializes responsive styles for mobile devices.
      * Sets up scaling based on viewport width and handles orientation changes.
-     *
-     * @param {HTMLElement|void} element - The DOM element to apply mobile styles to
-     * @returns {void}
      */
-    initMobileStyles(element: HTMLElement | void): void;
+    initMobileStyles(element: HTMLElement | null): void;
     /**
      * Get document identifier for telemetry (async - may generate hash)
-     * @returns {Promise<string>} GUID for modified docs, hash for unmodified
      */
-    getDocumentIdentifier(): Promise<string>;
+    getDocumentIdentifier(): Promise<string | null>;
     /**
      * Get permanent document GUID (sync - only for modified documents)
-     * @returns {string|null} GUID or null if document hasn't been modified
      */
     getDocumentGuid(): string | null;
     /**
      * Check if document has been modified
-     * @returns {boolean}
      */
     isDocumentModified(): boolean;
     /**
      * Get telemetry data (async because of lazy hash generation)
      */
     getTelemetryData(): Promise<{
-        documentId: string;
+        documentId: string | null;
         isModified: boolean;
         isPermanentId: boolean;
-        version: any;
+        version: string | null;
     }>;
-    getDocumentId(): string;
+    /**
+     * @deprecated use getDocumentGuid instead
+     */
+    getDocumentId(): string | null;
     /**
      * Get attrs of the currently selected node or mark.
-     * @param {String} nameOrType
      * @example
      * editor.getAttributes('textStyle').color
      */
-    getAttributes(nameOrType: string): any;
+    getAttributes(nameOrType: string): Record<string, unknown>;
     /**
      * Returns if the currently selected node or mark is active.
-     * @param {String|Object} nameOrAttributes - The name of the node/mark or an attributes object
-     * @param {Object} [attributesOrUndefined] - Optional attributes to check when first parameter is a name
-     * @returns {Boolean} Whether the node or mark is active with the specified attributes
+     * @param nameOrAttributes - The name of the node/mark or an attributes object
+     * @param attributesOrUndefined - Optional attributes to check when first parameter is a name
      * @example
      * editor.isActive('bold')
      * editor.isActive('textStyle', { color: 'purple' })
      * editor.isActive({ textAlign: 'center' })
      */
-    isActive(nameOrAttributes: string | any, attributesOrUndefined?: any): boolean;
+    isActive(nameOrAttributes: string | Record<string, unknown>, attributesOrUndefined?: Record<string, unknown>): boolean;
     /**
      * Get the editor content as JSON
-     * @returns {Object} Editor content as JSON
      */
-    getJSON(): any;
+    getJSON(): ProseMirrorJSON;
     /**
      * Get document metadata including GUID, modification status, and version
-     * @returns {{
-     *   documentGuid: string | null,
-     *   isModified: boolean,
-     *   version: string | null
-     * }} Document metadata
      */
     getMetadata(): {
         documentGuid: string | null;
@@ -472,448 +276,116 @@ export class Editor extends EventEmitter {
     };
     /**
      * Get the editor content as HTML
-     * @param {Object} options - Options for the HTML serializer
-     * @param {boolean} [options.unflattenLists] - Whether to unflatten lists in the HTML
-     * @returns {string} Editor content as HTML
      */
     getHTML({ unflattenLists }?: {
         unflattenLists?: boolean;
     }): string;
     /**
      * Get the editor content as Markdown
-     * @returns {Promise<string>} Editor content as Markdown
      */
     getMarkdown(): Promise<string>;
     /**
      * Get the document version from the converter
-     * @returns {string|null} The SuperDoc version stored in the document
      */
     getDocumentVersion(): string | null;
     /**
      * Create a child editor linked to this editor.
      * This is useful for creating header/footer editors that are linked to the main editor.
      * Or paragraph fields that rely on the same underlying document and list defintions
-     * @param {EditorOptions} options - Options for the child editor
-     * @returns {Editor} A new child editor instance linked to this editor
      */
-    createChildEditor(options: EditorOptions): Editor;
+    createChildEditor(options: Partial<EditorOptions>): Editor;
     /**
      * Get page styles
-     * @returns {Object} Page styles
      */
-    getPageStyles(): any;
+    getPageStyles(): PageStyles;
     /**
      * Update page styles
-     *
-     * @param {Object} param0
-     * @param {Object} param0.pageMargins The new page margins
-     * @returns {void}
      */
     updatePageStyle({ pageMargins }: {
-        pageMargins: any;
+        pageMargins?: Record<string, unknown>;
     }): void;
-    migrateListsToV2(): any;
-    getUpdatedJson(): any;
+    migrateListsToV2(): any[];
+    getUpdatedJson(): ProseMirrorJSON;
     /**
      * Export the editor document to DOCX.
-     * @async
-     * @param {Object} options - The export options
-     * @param {boolean} [options.isFinalDoc=false] - Whether this is the final document version
-     * @param {string} [options.commentsType] - The type of comments to include
-     * @param {Array} [options.comments=[]] - Array of comments to include in the document
-     * @param {boolean} [options.getUpdatedDocs=false] - When set to true return only updated docx files
-     * @returns {Promise<Blob|ArrayBuffer|Object>} The exported DOCX file or updated docx files
      */
     exportDocx({ isFinalDoc, commentsType, exportJsonOnly, exportXmlOnly, comments, getUpdatedDocs, fieldsHighlightColor, }?: {
         isFinalDoc?: boolean;
         commentsType?: string;
-        comments?: any[];
+        exportJsonOnly?: boolean;
+        exportXmlOnly?: boolean;
+        comments?: Comment[];
         getUpdatedDocs?: boolean;
-    }): Promise<Blob | ArrayBuffer | any>;
+        fieldsHighlightColor?: string | null;
+    }): Promise<Blob | ArrayBuffer | Buffer | Record<string, string> | ProseMirrorJSON | string | undefined>;
     /**
      * Destroy the editor and clean up resources
-     * @returns {void}
      */
     destroy(): void;
     destroyHeaderFooterEditors(): void;
+    /**
+     * Check if migrations are needed for the data
+     */
+    static checkIfMigrationsNeeded(): boolean;
     /**
      * Process collaboration migrations
-     * @returns {Object | void} Migration results
      */
-    processCollaborationMigrations(): any | void;
+    processCollaborationMigrations(): unknown | void;
     /**
      * Replace the current file
-     * @async
-     * @param {Object} newFile - New file data
-     * @returns {Promise<void>}
      */
-    replaceFile(newFile: any): Promise<void>;
+    replaceFile(newFile: File | Blob | Buffer): Promise<void>;
     /**
      * Get internal docx file content
-     * @param {string} name - File name
-     * @param {string} type - type of result (json, string)
-     * @returns {Object|String} - file content
+     * @param name - File name
+     * @param type - type of result (json, string)
      */
-    getInternalXmlFile(name: string, type?: string): any | string;
+    getInternalXmlFile(name: string, type?: 'json' | 'string'): unknown | string | null;
     /**
      * Update internal docx file content
-     * @param {string} name - File name
-     * @param {string} updatedContent - new file content
+     * @param name - File name
+     * @param updatedContent - new file content
      */
-    updateInternalXmlFile(name: string, updatedContent: string): void;
+    updateInternalXmlFile(name: string, updatedContent: string | unknown): void;
     /**
      * Get all nodes of a specific type
-     * @param {string} type - Node type
-     * @returns {Array} Array of nodes
      */
-    getNodesOfType(type: string): any[];
+    getNodesOfType(type: string): Array<{
+        node: PmNode;
+        pos: number;
+    }>;
     /**
      * Replace a node with HTML content
-     * @param {Object} targetNode - The node to replace
-     * @param {string} html - HTML content to replace with
-     * @returns {void}
      */
-    replaceNodeWithHTML(targetNode: any, html: string): void;
+    replaceNodeWithHTML(targetNode: {
+        node: PmNode;
+        pos: number;
+    }, html: string): void;
     /**
      * A command to prepare the editor to receive annotations. This will
      * pre-process the document as needed prior to running in the annotator.
      *
      * Currently this is only used for table generation but additional pre-processing can be done here.
-     *
-     * @param {FieldValue[]} annotationValues
-     * @returns {void}
      */
     prepareForAnnotations(annotationValues?: FieldValue[]): void;
     /**
      * Migrate paragraph fields to lists V2 structure if necessary.
-     * @param {FieldValue[]} annotationValues - List of field values to migrate.
-     * @returns {Promise<FieldValue[]>} - Returns a promise that resolves to the migrated
+     * @param annotationValues - List of field values to migrate.
+     * @returns Returns a promise that resolves to the migrated values
      */
     migrateParagraphFields(annotationValues?: FieldValue[]): Promise<FieldValue[]>;
     /**
      * Annotate the document with the given annotation values.
-     *
-     * @param {FieldValue[]} annotationValues List of field values to apply.
-     * @param {String[]} hiddenIds List of field ids to remove from the document.
-     * @returns {void}
      */
     annotate(annotationValues?: FieldValue[], hiddenIds?: string[], removeEmptyFields?: boolean): void;
     /**
      * Preview annotations in the editor. It stores a copy of the original state.
      * This can be reverted via closePreview()
-     *
-     * @param {Object[]} annotationValues
-     * @param {string[]} hiddenIds
-     * @returns {void}
      */
-    previewAnnotations(annotationValues?: any[], hiddenIds?: string[]): void;
-    originalState: any;
+    previewAnnotations(annotationValues?: FieldValue[], hiddenIds?: string[]): void;
     /**
      * If there is a preview active, this will revert the editor to the original state.
-     *
-     * @returns {void}
      */
     closePreview(): void;
-    #private;
 }
-export type FieldValue = {
-    /**
-     * The id of the input field
-     */
-    input_id: string;
-    /**
-     * The value to insert into the field
-     */
-    input_value: string;
-};
-/**
- * A map of plugin names to their helper API objects.
- * Each plugin defines its own helper methods.
- *
- * Example:
- * editor.helpers.linkedStyles.getStyles()
- */
-export type EditorHelpers = {
-    [x: string]: {
-        [x: string]: Function;
-    };
-};
-/**
- * The current user of this superdoc
- */
-export type User = {
-    /**
-     * The user's name
-     */
-    name: string;
-    /**
-     * The user's email
-     */
-    email: string;
-    /**
-     * The user's photo
-     */
-    image: string | null;
-};
-/**
- * A JSON representation of a docx node
- */
-export type DocxNode = any;
-export type EditorOptions = {
-    /**
-     * - The container element for the editor
-     */
-    element?: HTMLElement;
-    /**
-     * - CSS selector for the editor container
-     */
-    selector?: string;
-    /**
-     * - Whether the editor is running in headless mode
-     */
-    isHeadless?: boolean;
-    /**
-     * - Mock document for testing
-     */
-    mockDocument?: Document;
-    /**
-     * - Mock window for testing
-     */
-    mockWindow?: Window;
-    /**
-     * - XML content
-     */
-    content?: string;
-    /**
-     * - Current user information
-     */
-    user?: User;
-    /**
-     * - List of users for collaboration
-     */
-    users?: Array<User>;
-    /**
-     * - Media configuration
-     */
-    media?: any;
-    /**
-     * - Media files
-     */
-    mediaFiles?: any;
-    /**
-     * - Font configuration
-     */
-    fonts?: any;
-    /**
-     * - Document mode ('editing', 'viewing', 'suggesting')
-     */
-    documentMode?: string;
-    /**
-     * - Editor mode ('docx', 'text', 'html')
-     */
-    mode?: string;
-    /**
-     * - User role ('editor', 'viewer', 'suggester')
-     */
-    role?: string;
-    /**
-     * - Available colors
-     */
-    colors?: any[];
-    /**
-     * - Document converter
-     */
-    converter?: any;
-    /**
-     * - Source of the file (File/Blob in browser, Buffer in Node.js)
-     */
-    fileSource?: File | Blob | Buffer;
-    /**
-     * - Initial editor state
-     */
-    initialState?: any;
-    /**
-     * - Unique document identifier
-     */
-    documentId?: string;
-    /**
-     * - Editor extensions
-     */
-    extensions?: any[];
-    /**
-     * - Whether the editor is editable
-     */
-    editable?: boolean;
-    /**
-     * - Editor properties
-     */
-    editorProps?: any;
-    /**
-     * - Parsing options
-     */
-    parseOptions?: any;
-    /**
-     * - Core extension options
-     */
-    coreExtensionOptions?: any;
-    /**
-     * - Whether to enable input rules
-     */
-    enableInputRules?: boolean;
-    /**
-     * - Whether comments are enabled
-     */
-    isCommentsEnabled?: boolean;
-    /**
-     * - Whether this is a new file
-     */
-    isNewFile?: boolean;
-    /**
-     * - Editor scale/zoom
-     */
-    scale?: number;
-    /**
-     * - Whether annotations are enabled
-     */
-    annotations?: boolean;
-    /**
-     * - Whether this is an internal editor
-     */
-    isInternal?: boolean;
-    /**
-     * - External extensions
-     */
-    externalExtensions?: any[];
-    /**
-     * - Numbering configuration
-     */
-    numbering?: any;
-    /**
-     * - Whether this is a header or footer editor
-     */
-    isHeaderOrFooter?: boolean;
-    /**
-     * - Called before editor creation
-     */
-    onBeforeCreate?: Function;
-    /**
-     * - Called after editor creation
-     */
-    onCreate?: Function;
-    /**
-     * - Called when editor content updates
-     */
-    onUpdate?: Function;
-    /**
-     * - Called when selection updates
-     */
-    onSelectionUpdate?: Function;
-    /**
-     * - Called when a transaction is processed
-     */
-    onTransaction?: Function;
-    /**
-     * - Called when editor gets focus
-     */
-    onFocus?: Function;
-    /**
-     * - Called when editor loses focus
-     */
-    onBlur?: Function;
-    /**
-     * - Called when editor is destroyed
-     */
-    onDestroy?: Function;
-    /**
-     * - Called when there's a content error
-     */
-    onContentError?: Function;
-    /**
-     * - Called when tracked changes update
-     */
-    onTrackedChangesUpdate?: Function;
-    /**
-     * - Called when comments update
-     */
-    onCommentsUpdate?: Function;
-    /**
-     * - Called when comments are loaded
-     */
-    onCommentsLoaded?: Function;
-    /**
-     * - Called when a comment is clicked
-     */
-    onCommentClicked?: Function;
-    /**
-     * - Called when comment locations update
-     */
-    onCommentLocationsUpdate?: Function;
-    /**
-     * - Called when document is locked
-     */
-    onDocumentLocked?: Function;
-    /**
-     * - Called on first render
-     */
-    onFirstRender?: Function;
-    /**
-     * - Called when collaboration is ready
-     */
-    onCollaborationReady?: Function;
-    /**
-     * - Called when pagination updates
-     */
-    onPaginationUpdate?: Function;
-    /**
-     * - Called when an exception occurs
-     */
-    onException?: Function;
-    /**
-     * - Called when list definitions change
-     */
-    onListDefinitionsChange?: Function;
-    /**
-     * - Called when all fonts used in the document are determined
-     */
-    onFontsResolved?: Function;
-    /**
-     * - Handler for image uploads
-     */
-    handleImageUpload?: Function;
-    /**
-     * - Telemetry configuration
-     */
-    telemetry?: any;
-    /**
-     * - Prevent default styles from being applied in docx mode
-     */
-    suppressDefaultDocxStyles?: boolean;
-    /**
-     * - Provided JSON to override content with
-     */
-    jsonOverride?: any;
-    /**
-     * - HTML content to initialize the editor with
-     */
-    html?: string;
-    /**
-     * - Markdown content to initialize the editor with
-     */
-    markdown?: string;
-    /**
-     * - Whether to enable debug mode
-     */
-    isDebug?: boolean;
-    /**
-     * - Host-provided permission hook
-     */
-    permissionResolver?: (params: {
-        permission: string;
-        role?: string;
-        isInternal?: boolean;
-        comment?: any | null;
-        trackedChange?: any | null;
-    }) => boolean | undefined;
-};
-import { EventEmitter } from './EventEmitter.js';
 //# sourceMappingURL=Editor.d.ts.map