declare function addColumnLeft(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function addColumnRight(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function addRowAbove(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function addRowBelow(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function addTabStop(position: number, alignment?: TabStopAlignment, leader?: TabLeader): Command;

declare function applyStyle(styleId: string, resolvedAttrs?: ResolvedStyleAttrs): Command;

declare function applyTableStyle(styleData: {
    styleId: string;
    tableBorders?: Record<string, unknown>;
    conditionals?: Record<string, unknown>;
    look?: Record<string, boolean>;
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function autoFitContents(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

Create an empty ProseMirror document

declare function createEmptyDoc(): Node;

Create selection tracker plugin

declare function createSelectionTrackerPlugin(onSelectionChange?: SelectionChangeCallback): Plugin;

Create a style resolver from document's style definitions

declare function createStyleResolver(styleDefinitions: StyleDefinitions | undefined): StyleResolver;

declare function decreaseIndent(amount?: number): Command;

declare function deleteColumn(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function deleteRow(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function deleteTable(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function distributeColumns(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

Extract selection context from editor state

declare function extractSelectionContext(state: EditorState): SelectionContext;

Extract selection state from editor state. Used by PagedEditor integration in DocxEditor for toolbar state.

declare function extractSelectionState(state: EditorState): SelectionState | null;

Resolve the hyperlink mark + contiguous range that surrounds the current cursor. Used by edit/remove popup actions in both adapters.

Resolution order for the mark itself: 1. `$from.marks()` — the normal active-marks lookup 2. `$from.nodeAfter`/`nodeBefore` marks — boundary positions don't report active marks via `marks()` 3. (optional) text-node search by `fallbackHref` — last resort when the popup knows the href but the cursor sits at a gap

The returned range walks the parent block grouping consecutive text nodes that share the same href, and returns whichever range contains the cursor.

declare function findHyperlinkRangeAt(state: EditorState, fallbackHref?: string): {
    mark: Mark;
    start: number;
    end: number;
} | null;

ProseMirror position range for the paragraph (or any textblock) whose `paraId` attribute equals `paraId`. Returns the inclusive `from` and exclusive `to` positions, plus the node, so callers can both target the paragraph (e.g. addMark over its text range) and inspect it.

`from` is the position immediately before the textblock; `to` is `from + node.nodeSize`. The text content lives at `[from + 1, to - 1]`.

Returns null if no textblock with that paraId exists.

declare function findParagraphByParaId(doc: Node, paraId: string): {
    node: Node;
    from: number;
    to: number;
} | null;

ProseMirror position immediately before the first textblock whose `paraId` attribute equals `paraId` (Word `w14:paraId` / OOXML paragraph id).

Match is strict string equality on `node.attrs.paraId`.

declare function findStartPosForParaId(doc: Node, paraId: string): number | null;

Convert footnote/endnote content (array of Paragraph/Table blocks) to a ProseMirror document. Mirrors `headerFooterToProseDoc` so footnotes flow through the same body pipeline (toFlowBlocks → measureBlocks → renderFragment) and inherit its block support — paragraph + table + image + textBox + fields. Pre-PR, footnoteLayout's `convertFootnoteToContent` re-implemented run/paragraph conversion by hand and silently dropped tables, images, and fields nested inside a footnote.

declare function footnoteToProseDoc(content: Array<Paragraph | Table>, options?: ToProseDocOptions & {
    theme?: Theme | null;
}): Node;

Convert a ProseMirror document to our Document type

declare function fromProseDoc(pmDoc: Node, baseDocument?: Document): Document;

declare function getHyperlinkAttrs(state: EditorState): {
    href: string;
    tooltip?: string;
} | null;

declare function getListInfo(state: EditorState): {
    numId: number;
    ilvl: number;
} | null;

Get the current value of a mark attribute

declare function getMarkAttr(state: EditorState, markType: MarkType, attr: string): unknown | null;

declare function getParagraphAlignment(state: EditorState): ParagraphAlignment | null;

declare function getParagraphBidi(state: EditorState): boolean;

declare function getSelectedText(state: EditorState): string;

Get current selection context from editor state

declare function getSelectionContext(state: EditorState): SelectionContext | null;

declare function getStyleId(state: EditorState): string | null;

declare function getTableContext(state: EditorState): TableContextInfo;

Convert HeaderFooter content (array of Paragraph/Table blocks) to a ProseMirror document. Used for editing headers/footers in their own ProseMirror editor and for the unified header/footer render pipeline. `theme` must be threaded for themeColor resolution in cell shading (`<w:shd w:themeFill=...>`) — without it, themed fills in HF tables fall back to the unresolved theme key.

declare function headerFooterToProseDoc(content: Array<Paragraph | Table>, options?: ToProseDocOptions & {
    theme?: Theme | null;
}): Node;

declare function increaseIndent(amount?: number): Command;

declare function insertHyperlink(text: string, href: string, tooltip?: string): Command;

declare function insertTable(rows: number, cols: number): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function isHyperlinkActive(state: EditorState): boolean;

declare function isInList(state: EditorState): boolean;

declare function isInTableCell(state: EditorState): boolean;

Check if a mark is active in the current selection

declare function isMarkActive(state: EditorState, markType: MarkType, attrs?: Record<string, unknown>): boolean;

declare function mergeCells(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function removeTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function removeTabStop(position: number): Command;

declare function selectColumn(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function selectRow(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function selectTable(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

Paragraph Formatting Commands — thin re-exports from extension system

Alignment, line spacing, indentation, lists, paragraph styles. All implementations live in extensions/; this file re-exports for backward compatibility.

declare function setAlignment(alignment: ParagraphAlignment): Command;

declare function setAllTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): boolean;

declare function setCellBorder(side: 'top' | 'bottom' | 'left' | 'right' | 'all', spec: {
    style: string;
    size?: number;
    color?: {
        rgb: string;
    };
} | null, clearOthers?: boolean): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setCellFillColor(color: string | null): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setCellMargins(margins: {
    top?: number;
    bottom?: number;
    left?: number;
    right?: number;
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setCellTextDirection(direction: string | null): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setCellVerticalAlign(align: 'top' | 'center' | 'bottom'): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setFontFamily(fontName: string): Command;

declare function setFontSize(size: number): Command;

declare function setHighlight(color: string): Command;

declare function setHyperlink(href: string, tooltip?: string): Command;

declare function setIndentFirstLine(twips: number, hanging?: boolean): Command;

declare function setIndentLeft(twips: number): Command;

declare function setIndentRight(twips: number): Command;

declare function setInsideTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): boolean;

declare function setLineSpacing(value: number, rule?: LineSpacingRule): Command;

declare function setOutsideTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): boolean;

declare function setRowHeight(height: number | null, rule?: 'auto' | 'atLeast' | 'exact'): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setTableBorderColor(color: string): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setTableBorders(preset: BorderPreset, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setTableBorderWidth(size: number): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setTableProperties(props: {
    width?: number | null;
    widthType?: string | null;
    justification?: 'left' | 'center' | 'right' | null;
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function setTextColor(attrs: TextColorAttrs): Command;

declare function splitCell(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

declare function toggleHeaderRow(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

declare function toggleNoWrap(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

Convert a Document to a ProseMirror document

declare function toProseDoc(document: Document, options?: ToProseDocOptions): Node;

Update a Document with content from a ProseMirror document Preserves all non-content parts of the original document

declare function updateDocumentContent(originalDocument: Document, pmDoc: Node): Document;

LayoutSelectionGate coordinates the timing between document edits and layout reflow so that selection overlays are only painted against current DOM geometry.

Workflow: 1. Document changes → setStateSeq(++seq) 2. Layout starts → onLayoutStart() 3. Layout completes → onLayoutComplete(seq) 4. Selection update requested → requestRender() 5. If safe → callback is called

declare class LayoutSelectionGate

StyleResolver provides efficient access to resolved style properties

declare class StyleResolver

Font family mark attributes

interface FontFamilyAttrs

Font size mark attributes

interface FontSizeAttrs

Hyperlink mark attributes

interface HyperlinkAttrs

Image node attributes

interface ImageAttrs

Paragraph node attributes - maps to ParagraphFormatting

interface ParagraphAttrs

Resolved style properties ready for rendering

interface ResolvedParagraphStyle

Selection context for toolbar state

interface SelectionContext

Selection state for toolbar integration

interface SelectionState

Table selection context + navigation helpers.

`getTableContext` walks the selection up from `$from` and reports which table / row / cell the cursor is in, plus the table's row/column counts, whether a multi-cell selection is active, and the current cell's border + fill colors (so the toolbar's color pickers can show the live values).

`goToNextCell` / `goToPrevCell` are tab-stop-style cell navigation commands registered by the plugin extension.

interface TableContextInfo

Text color mark attributes

interface TextColorAttrs

Options for document conversion

interface ToProseDocOptions

Underline mark attributes

interface UnderlineAttrs

Cell-border commands. Each command applies a preset / individual side / color / width to the cells targeted by the current selection (single cursor cell or active `CellSelection`).

All four commands use the shared `buildTableGrid` lookup to find each cell's neighbours in the grid, then sync the matching edge on the adjacent cell — Google-Docs style edge-symmetric border editing.

Schema-free: only attribute updates via `tr.setNodeMarkup`.

type BorderPreset = 'all' | 'outside' | 'inside' | 'none';

Callback type for selection changes

type SelectionChangeCallback = (context: SelectionContext) => void;

alignCenter: Command

alignJustify: Command

alignLeft: Command

alignRight: Command

clearFontFamily: Command

clearFontSize: Command

Clear all text formatting (remove all marks)

clearFormatting: Command

clearHighlight: Command

clearStyle: Command

clearTextColor: Command

decreaseListLevel: Command

generateTOC: Command

increaseListLevel: Command

Insert a page break at the current cursor position. Always ensures a paragraph follows the page break and places the cursor there.

insertPageBreak: Command

removeHyperlink: Command

removeList: Command

schema: prosemirror_model.Schema<any, any>

Plugin key for accessing selection tracker state

selectionTrackerKey: PluginKey<SelectionContext>

setLtr: Command

setRtl: Command

toggleBold: Command

toggleBulletList: Command

toggleItalic: Command

toggleNumberedList: Command

toggleStrike: Command

toggleSubscript: Command

toggleSuperscript: Command

toggleUnderline: Command