@docx-editor.dev/vue

v2.39.0 · 1 published subpath with full TypeScript signatures and JSDoc.

Package root

Functions (72)

definePopupfunctionSource ↗

Adapt a Vue component to a popup renderer while preserving its props and lifecycle. Required and narrowed props remain checked; inherited framework attributes do not constrain the popup host.

declare function definePopup<C extends Component | FunctionalComponent<never>>(component: C): (props: C extends new (...args: never[]) => {
    $props: infer P;
} ? Omit<P, {
    [K in keyof P]-?: K extends keyof (VNodeProps & AllowedComponentProps & ComponentCustomProps) ? {} extends Pick<P, K> ? (VNodeProps & AllowedComponentProps & ComponentCustomProps)[K] extends P[K] ? K : never : never : never;
}[keyof P]> : C extends (props: infer P, ...args: never[]) => unknown ? P : never) => DocxEditorChildren;
declare function isFieldLink(link: SurfaceHyperlink): boolean;

Whether an open pane overlays the page rather than moving it: true when the viewport leaves less than [NAVIGATION_PANE_MIN_PAGE_ROOM](NAVIGATION_PANE_MIN_PAGE_ROOM) beside the reservation. Uses the viewport's client width only, never a padding the pane itself causes, so the answer cannot feed back into its own input. false for a viewport that has not been measured.

declare function navigationPaneOverlays(viewportWidth: number, reservation: number): boolean;

Total left space an open pane needs before the page may start.

declare function navigationPaneReservation(paneWidth?: number): number;

The viewport's left padding, in px, that puts the page's left edge exactly at reservation — and 0 whenever the gutter is already wide enough.

Returns 0 for a degenerate measurement (a viewport that has not been laid out yet, a document with no page setup) rather than guessing: shifting on a zero measurement would make the pane jump on the first frame and settle on the second.

declare function navigationShift(input: NavigationShiftInput): number;

normalizeImageBytesfunctionSource ↗

Preflight raster bytes for insert/replace. Never allocates from file-supplied dimensions alone.

declare function normalizeImageBytes(bytes: Uint8Array): NormalizedImagePayload;

provideDocxEditorfunctionSource ↗

Setup composable for hosts that own the editor above the packaged root. Creates the instance, publishes docxEditorKey, and returns props for [DocxEditorRoot](DocxEditorRoot).

declare function provideDocxEditor(options: DocxEditorRootProps): ProvideDocxEditorResult;

reviewGutterfunctionSource ↗

Returns the inline-edge reservations for the current rail geometry.

declare function reviewGutter(input: ReviewGutterInput): ReviewGutter;

useBookmarkDialogfunctionSource ↗

Read the enclosing Bookmark dialog draft.

declare function useBookmarkDialog(): UseBookmarkDialogReturn;

useBookmarksfunctionSource ↗

The document's bookmarks plus the commands that change them.

declare function useBookmarks(): UseBookmarksReturn;

useChromeDirfunctionSource ↗

The dir attribute a chrome part sets on its root, as a read-only ref: the direction a provider decided (its dir prop, the catalog's _dir, or a right-to-left _lang), otherwise nothing, so the part keeps the host page direction.

Read it in your own controls to follow the editor chrome: undefined means the chrome inherits the host page direction, so set no dir then.

declare function useChromeDir(): Readonly<ShallowRef<'ltr' | 'rtl' | undefined>>;

useChromeTranslatefunctionSource ↗

declare function useChromeTranslate(overrides?: ReadonlyMap<string, string>): ComputedRef<ChromeTranslate>;

useCommentDraftRequestfunctionSource ↗

Open the host's own comment draft when the review.addComment control is pressed.

While the component is mounted and handler is set, the control is enabled (subject to the engine's other rules: the review module, the editing mode, and a selection). Without any registration the control is disabled, because nothing could open the draft. The most recent registration receives each request. The registration lasts while the calling component is mounted. Passing null registers nothing; to stop serving requests, unmount the component, for example with v-if while your comment UI cannot open a draft.

The handler takes no arguments. Read the selection with editor.getSelectionPlacement(), and pin it with editor.retainSelection() while the draft is open.

declare function useCommentDraftRequest(handler: (() => void) | null | undefined): void;
```ts
const drafting = ref(false);
useCommentDraftRequest(() => {
  drafting.value = true;
});
const addComment = useEditorCommand('review.addComment');
// Bind `addComment.isEnabled` to the button, and call `addComment.execute()` on click.
```

useCompareDocumentsDialogfunctionSource ↗

Access the Compare documents draft and actions.

declare function useCompareDocumentsDialog(): UseCompareDocumentsDialogReturn;

useContentControlfunctionSource ↗

declare function useContentControl(): UseContentControlResult;

useContentControlInstancefunctionSource ↗

declare function useContentControlInstance(): UseContentControlResult;

useContentControlWidgetfunctionSource ↗

Draft state of the enclosing content-control value pop-up.

declare function useContentControlWidget(): UseContentControlWidgetResult;

useContextMenuAnchorfunctionSource ↗

Where the open menu is anchored and how it was opened, or null while the menu is closed.

Rows in ContextMenu.Start read trigger to tell a right-click from a keyboard open, which acts on the caret rather than on a pointer target. The ref follows the menu, so a row that stays mounted while the menu opens again reads the new anchor.

declare function useContextMenuAnchor(): ComputedRef<ContextMenuAnchor | null>;

useContextMenuHighlightsfunctionSource ↗

The text highlights the open context menu is about, topmost first. Pass a set name to read one set. R is your range type, so fields you added to your ranges come back typed on range.

For a right-click (trigger: 'pointer'), these are the marks under the pointer. For a keyboard open (trigger: 'keyboard', Shift+F10 or the Menu key), these are the marks whose current range holds the caret: same paragraph, and the caret offset from start to start + length, both ends included. For a range selection, the caret is its head. A keyboard hit's rect is the mark's rectangle on the caret's line.

A document change while the menu is open, such as a collaborator's edit, reads the marks again, so start and length never describe text that moved. Text that moved away from the pointer or the caret is no longer reported. Empty while the menu is closed, and when the caret is on a page that is not painted.

declare function useContextMenuHighlights<R extends HighlightRange = HighlightRange>(name?: string): Readonly<ShallowRef<readonly HighlightHit<R>[]>>;
```ts
const hits = useContextMenuHighlights<MisspellingRange>('spelling');
// hits.value[0]?.range.suggestions
```

useContextMenuTargetfunctionSource ↗

The element the opening right-click landed on, or null while the menu is closed.

A menu opened from the keyboard has no target; read the caret with editor.getSelectionRange().

declare function useContextMenuTarget(): HTMLElement | null;

useDocumentOutlinefunctionSource ↗

declare function useDocumentOutline(): UseDocumentOutlineResult;

useDocumentSearchfunctionSource ↗

The editor's shared search, with no UI attached. The packaged Find pane uses the same session, so state set here shows there.

declare function useDocumentSearch(options?: MaybeRefOrGetter<UseDocumentSearchOptions>): UseDocumentSearchResult;

useDocxEditorfunctionSource ↗

declare function useDocxEditor(): ShallowRef<DocxEditorInstance | null>;

useDocxSourcefunctionSource ↗

declare function useDocxSource(source: MaybeRefOrGetter<DocxSource | null | undefined>, options?: MaybeRefOrGetter<UseDocxSourceOptions>): UseDocxSourceResult;

useEditorCaretfunctionSource ↗

declare function useEditorCaret(): ShallowRef<EditorCaret | null>;

useEditorColorModefunctionSource ↗

The theme the enclosing DocxEditorRoot resolved from its colorMode, so parts you build yourself can match the editor chrome. 'system' resolves to the operating system's current setting and updates when it changes. Outside a DocxEditorRoot, or without colorMode, the answer is 'light'. Call it in setup.

declare function useEditorColorMode(): UseEditorColorModeReturn;
```ts
const { colorMode } = useEditorColorMode();
const panelClass = computed(() => (colorMode.value === 'dark' ? 'panel panel--dark' : 'panel'));
```

useEditorCommandfunctionSource ↗

declare function useEditorCommand(target: MaybeRefOrGetter<ChromeSlotId | EditorCommand>): EditorCommandState;

useEditorEventfunctionSource ↗

declare function useEditorEvent<E extends keyof EditorEvents>(event: E, handler: EditorEvents[E]): void;

useEditorHostDocumentfunctionSource ↗

The document the editor's pages are mounted in: a pop-out window's or an iframe's when the host attached the editor there, otherwise the page's own. null during server rendering.

Custom chrome that adds document listeners, reads focus, or injects a <style> uses this instead of the global document, which belongs to the window the script runs in. The value changes when the editor moves to another window, so watchers keyed on it re-bind. Its defaultView is the editor's window, for timers, viewport size and the clipboard.

declare function useEditorHostDocument(): UseEditorHostDocumentReturn;
```ts
const hostDocument = useEditorHostDocument();
watch(hostDocument, (doc, _previous, onCleanup) => {
  if (!doc) return;
  doc.addEventListener('keydown', onShortcut);
  onCleanup(() => doc.removeEventListener('keydown', onShortcut));
}, { immediate: true });
```

useEditorSnapshotfunctionSource ↗

declare function useEditorSnapshot(editor: MaybeRefOrGetter<Editor | null>): Ref<number>;

useEditorStatefunctionSource ↗

declare function useEditorState<T>(selector: (snapshot: EditorSnapshot) => T, isEqual?: (a: T, b: T) => boolean, options?: UseEditorStateOptions): Readonly<ShallowRef<T>>;

useEditorValueCommandfunctionSource ↗

Bind a value slot. Font size values use half-points; colors use six digits without #. The shape.* and chart.* slots bind through useObjectControl.

declare function useEditorValueCommand<K extends Exclude<keyof ToolbarValueMap, keyof ObjectSlotValueMap>>(slotId: K): EditorValueCommandState<ToolbarValueMap[K]>;

useFontFamilyfunctionSource ↗

declare function useFontFamily(): UseFontFamilyResult;

useFontsfunctionSource ↗

declare function useFonts(source: MaybeRefOrGetter<FontsInput>, ...fragments: readonly MaybeRefOrGetter<FontConfigurationFragment | undefined>[]): MarkedFontResolver;

useFontsfunctionSource ↗

declare function useFonts(...origins: readonly MaybeRefOrGetter<FontOrigin>[]): MarkedFontResolver;

useGoToBookmarkfunctionSource ↗

Go To for bookmarks: filter by name, move through the offered rows, and jump.

declare function useGoToBookmark(options?: MaybeRefOrGetter$1<UseGoToBookmarkOptions>): UseGoToBookmarkReturn;

useHeaderFooterStatefunctionSource ↗

declare function useHeaderFooterState(): ShallowRef<HeaderFooterState | null>;

useHighlightAtfunctionSource ↗

The topmost text highlight under the pointer, or null. Pass a set name to watch one set. R is your range type, so fields you added to your ranges come back typed on range.

declare function useHighlightAt<R extends HighlightRange = HighlightRange>(name?: MaybeRefOrGetter<string>): Readonly<ShallowRef<HighlightHit<R> | null>>;
```ts
const hit = useHighlightAt<GlossaryRange>('glossary');
// hit.value?.range.definition, positioned at hit.value.rect
```

useHighlightsfunctionSource ↗

Mark text ranges as the named set while the calling scope is active.

A function source runs inside reactive tracking, so a getter that reads refs reapplies when they change. For state that is not reactive, call refresh() on the returned value. Use a unique name per call: two calls with the same name replace each other's ranges.

declare function useHighlights(name: MaybeRefOrGetter<string>, source: MaybeRefOrGetter<HighlightSource>, options?: MaybeRefOrGetter<HighlightOptions>): ComputedRef<UseHighlightsReturn>;
```ts
const glossary = useHighlights(
  'glossary',
  (editor) => editor.findMatches(terms.value, { wholeWord: true }).flat(),
  { className: 'glossary-term' }
);
// glossary.value.applied; glossary.value.refresh() runs the source again.
```

useHistoryGroupfunctionSource ↗

Bind a control's native gesture lifecycle. Apply values through the existing command hooks.

declare function useHistoryGroup(input: HistoryGroupBindingOptions): UseHistoryGroupReturn;

useHyperlinkPopupfunctionSource ↗

The hyperlink popover's behavior. Inside DocxEditor.Root it is the shared state that DocxEditor.HyperLink renders, and calling it marks the component as a view of that state. Outside a root it is a standalone instance that registers with the engine itself.

declare function useHyperlinkPopup(): UseHyperlinkPopupResult;

useHyperlinkPopupInstancefunctionSource ↗

declare function useHyperlinkPopupInstance(active?: boolean): UseHyperlinkPopupResult;

useNavigationPanefunctionSource ↗

declare function useNavigationPane(options?: MaybeRefOrGetter$1<UseNavigationPaneOptions>): UseNavigationPaneResult;

useNavigationShiftfunctionSource ↗

declare function useNavigationShift(): ShallowRef<number>;

useNotePropertiesStatefunctionSource ↗

declare function useNotePropertiesState(): ShallowRef<NotePropertiesState | null>;

useNoteScopeStatefunctionSource ↗

declare function useNoteScopeState(): ShallowRef<Extract<ViewScope, {
    kind: 'note';
}> | null>;

useObjectControlfunctionSource ↗

Bind one shape.* or chart.* slot: its typed value, the values a list offers, the enabled state, the translated reason, and execute. Use it to build a control the packaged parts do not cover.

declare function useObjectControl<K extends ObjectSlotId>(slotId: K): UseObjectControlReturn<K>;

useOpenFailurefunctionSource ↗

Reads the document the editor refused to open, for a host that shows it in its own UI, such as a toast. Pair it with :open-failure="false" on <DocxEditor>, so the packaged dialog does not show as well. Call it inside a DocxEditor.Root.

ts const { failure, message, dismiss } = useOpenFailure(); watch(failure, (next) => { if (next) toast(message.value, { detail: next.code, onClose: () => dismiss(next) }); });

declare function useOpenFailure(options?: UseOpenFailureOptions): UseOpenFailureReturn;

usePageSetupfunctionSource ↗

declare function usePageSetup(): UsePageSetupReturn;

usePageSetupDialogfunctionSource ↗

Access the current Page Setup draft and actions.

Call it in a child of the dialog. It does not open the dialog. To open the dialog from your own toolbar, keep its open state and render DocxEditorPageSetupDialog with open and @close. Take the button's enabled state from usePageSetup().isEnabled.

declare function usePageSetupDialog(): UsePageSetupDialogReturn;

usePaneRequestfunctionSource ↗

Call listener for each request for a pane in options.panes: Insert Chart and Edit chart ask for 'chart', and Format shape asks for 'shape'. The default is ['chart']. A request says what the user asked to see, not where: answer it with any UI, such as a popover, a drawer, a dialog, or DocxEditor.SidePanel, and render DocxEditor.PaneSections or single parts in it. Listening for a pane makes its chrome available, so list only the panes the host shows.

declare function usePaneRequest(listener: (request: PaneRequest) => void, options?: PaneRequestListenerOptions): void;
```vue
<script setup lang="ts">
import { ref } from 'vue';
import { DocxEditor, usePaneRequest } from '@docx-editor.dev/vue';

const open = ref(false);
usePaneRequest(() => (open.value = true), { panes: ['chart'] });
</script>

<template>
  <div v-if="open" role="dialog" aria-label="Chart">
    <DocxEditor.PaneSections pane="chart" :sections="['type', 'elements']" />
  </div>
</template>
```

useParagraphDialogfunctionSource ↗

Access the current Paragraph draft and actions.

Call it in a child of the dialog. It does not open the dialog. To open the dialog from your own toolbar, keep its open state and render DocxEditorParagraphDialog with open and @close. Take the button's enabled state from useParagraphFormat().isEnabled.

declare function useParagraphDialog(): UseParagraphDialogReturn;

useParagraphFormatfunctionSource ↗

The selection's paragraph formatting, plus the command to change it.

declare function useParagraphFormat(): UseParagraphFormatReturn;

useParagraphIndentfunctionSource ↗

declare function useParagraphIndent(): UseParagraphIndentReturn;

useParagraphStylefunctionSource ↗

declare function useParagraphStyle(): UseParagraphStyleResult;

useReviewAuthorsfunctionSource ↗

declare function useReviewAuthors(): Readonly<ShallowRef<readonly ReviewAuthorInfo[]>>;

useReviewGutterfunctionSource ↗

Returns the live review-rail reservation for the viewport and rulers.

declare function useReviewGutter(): ShallowRef<ReviewGutter>;

useRevisionMarkupDialogfunctionSource ↗

Access the markup dialog draft and actions.

declare function useRevisionMarkupDialog(): UseRevisionMarkupDialogReturn;

useScopeClassNamefunctionSource ↗

The scope class a part you build adds to its own root element: 'docx-editor ', with dark under a DocxEditorRoot whose colorMode resolved dark, or '' when an ancestor is already scoped. Call it in setup; it reads the theme once, so read it again to follow a change.

declare function useScopeClassName(): '' | 'docx-editor ' | 'docx-editor dark ';

useScopedChromeAnchorfunctionSource ↗

Attach contextual chrome to a painted story instead of the top of the editor viewport.

declare function useScopedChromeAnchor(findAnchor: (viewport: HTMLElement) => HTMLElement | null, placement: ScopedChromeAnchorPlacement): ScopedChromeAnchor;

useSelectedChartfunctionSource ↗

The selected chart, its data and format, whether each can change, and execute for the chart commands. Use it inside DocxEditor.Root to build a chart pane of your own, and pass that pane to DocxEditor.SidePanel in its default slot.

declare function useSelectedChart(): UseSelectedChartReturn;

useSelectedShapefunctionSource ↗

The selected shape, its fill and outline, whether each can change, and execute for the shape commands. Use it inside DocxEditor.Root to build a Format shape pane of your own. It reads the shape on every editor change, because protection, locks, and collaboration change what can answers. Every refusal reason it returns is translated.

declare function useSelectedShape(): UseSelectedShapeReturn;

useSplitCellDialogfunctionSource ↗

Read the enclosing Split cells dialog draft.

declare function useSplitCellDialog(): UseSplitCellDialogReturn;

useTableBorderTargetLabelfunctionSource ↗

declare function useTableBorderTargetLabel(): ComputedRef<string>;

useTextFormFieldDialogfunctionSource ↗

Access the Field Options draft and actions.

declare function useTextFormFieldDialog(): UseTextFormFieldDialogReturn;

useToolbarContextfunctionSource ↗

declare function useToolbarContext(): ComputedRef<ToolbarContextValue>;

useToolbarLabelfunctionSource ↗

declare function useToolbarLabel(): (key: string) => string;

useToolbarLabelForfunctionSource ↗

declare function useToolbarLabelFor(t: ToolbarTranslate | undefined): (key: string) => string;

useTranslationfunctionSource ↗

The active catalogue's t(), the catalogue itself, and its language tag (_lang, en by default), which formats numbers the way the strings around them read. Its dir is the providers' direction, 'ltr' when the chrome inherits a right-to-left host page; use useChromeDir() for the direction a provider decided, undefined when inherited.

declare function useTranslation(): {
    t: TFunction;
    catalogue: ShallowRef<LocaleStrings>;
    lang: string;
    dir: 'ltr' | 'rtl';
};

useWatermarkfunctionSource ↗

The document watermark plus the command to change it.

declare function useWatermark(): UseWatermarkReturn;

useWatermarkDialogfunctionSource ↗

Read the enclosing Watermark dialog draft.

declare function useWatermarkDialog(): UseWatermarkDialogReturn;

useZoomfunctionSource ↗

declare function useZoom(): UseZoomResult;

Interfaces (201)

BookmarkDialogFieldsinterfaceSource ↗

The Bookmark dialog's draft.

interface BookmarkDialogFields
MemberTypeSummary
namestringThe name typed or picked from the list.
showHiddenbooleanWhether hidden bookmarks (names starting with an underscore) are listed.
sortByBookmarkSortOrder

ChartInsertPartComponentinterfaceSource ↗

interface ChartInsertPartComponent
MemberTypeSummary
(member-0)
docxSlot'insert.chart'

ChartInsertPropsinterfaceSource ↗

Props for DocxEditor.Toolbar.ChartInsert.

interface ChartInsertProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildrenThe default slot: the trigger content, or the trigger itself with `asChild`.
className?string
hidden?boolean

ChartSeriesColorsPropsinterfaceSource ↗

Props of DocxEditor.ChartSeriesColors.

interface ChartSeriesColorsProps extends ChartPartProps
MemberTypeSummary
index?numberShows the colour of this series (or pie point) only.

ColorPickerContentPropsinterfaceSource ↗

Props for ColorPicker.Content. Other attributes (aria-label) pass through.

interface ColorPickerContentProps
MemberTypeSummary
className?string
container?Element | nullRenders the grid in this element, through `Teleport`, for a host popover library that places it. The grid then takes no position of its own.
hexInput?booleanWhether the default content shows the hex field. Default true.
inline?booleanRenders the grid in place, inside a popup the host already owns.

ColorPickerHexInputPropsinterfaceSource ↗

Props for ColorPicker.HexInput.

interface ColorPickerHexInputProps
MemberTypeSummary
className?stringMore class names for the field.

ColorPickerNoColorPropsinterfaceSource ↗

Props for ColorPicker.NoColor. The default slot replaces the button text.

interface ColorPickerNoColorProps
MemberTypeSummary
className?string

ColorPickerRootPropsinterfaceSource ↗

Props for ColorPicker.Root.

interface ColorPickerRootProps
MemberTypeSummary
asChild?booleanRenders the single child of the default slot as the root, with the picker's attributes.
automaticHex?string
className?string
disabled?boolean
noColor?'none' | 'auto' | false
onOpenChange?(open: boolean) => void
onPick(pick: ColorPick | 'none') => void
open?boolean
themeHexes?readonly string[]
valueColorPickerValue

ColorPickerSwatchPropsinterfaceSource ↗

Props for ColorPicker.Swatch.

interface ColorPickerSwatchProps
MemberTypeSummary
className?string
hex?stringThe paint, `#RRGGBB`; default the paint of `pick` in the document's theme.
pickColorPick

ColorPickerTriggerPropsinterfaceSource ↗

Props for ColorPicker.Trigger. Other attributes (aria-label, title) pass through.

interface ColorPickerTriggerProps
MemberTypeSummary
asChild?booleanRenders the single child of the default slot as the trigger, without the colour chip.
className?string

CompareDocumentsDialogValuesinterfaceSource ↗

The Compare documents draft.

interface CompareDocumentsDialogValues
MemberTypeSummary
authorNamestring
detectFormatChangesboolean
removeDateAndTimebooleanWrite the revisions without dates. Default `false`. The preset has no control for it; a custom part sets it with `setValue('removeDateAndTime', true)`.
revisedFile | nullThe revised document. The open document is the original.

ContentControlActionPropsinterfaceSource ↗

Props for action parts that also take an icon.

interface ContentControlActionProps extends ContentControlPartProps
MemberTypeSummary
icon?DocxEditorChildren

ContentControlInspectorStateinterfaceSource ↗

interface ContentControlInspectorState
MemberTypeSummary
aliasstring | null
boundboolean
controlTypeContentControlType
effectiveLockContentControlLock | null
idstring
lockedboolean
placeholderboolean
removalLockedboolean
tagstring | null

ContentControlPartPropsinterfaceSource ↗

Shared props for every part.

interface ContentControlPartProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildren
className?string
hidden?boolean

ContentControlPropsinterfaceSource ↗

Props for DocxEditor.ContentControl.

interface ContentControlProps extends ContentControlPartProps
MemberTypeSummary
preset?booleanRender the packaged arrangement. `false` mounts only the shell and host children.

ContentControlWidgetDayPropsinterfaceSource ↗

Props for one calendar cell.

interface ContentControlWidgetDayProps extends DocxEditorContentControlWidgetPartProps
MemberTypeSummary
dayCalendarDay

ContentControlWidgetEntryinterfaceSource ↗

One selectable entry of a dropdown or combo-box control.

interface ContentControlWidgetEntry
MemberTypeSummary
displayTextstring
valuestring

ContentControlWidgetItemPropsinterfaceSource ↗

Props for one list entry.

interface ContentControlWidgetItemProps extends DocxEditorContentControlWidgetPartProps
MemberTypeSummary
itemContentControlWidgetEntry

ContentControlWidgetPicturePropsinterfaceSource ↗

Props for the picture file input.

interface ContentControlWidgetPictureProps extends DocxEditorContentControlWidgetPartProps
MemberTypeSummary
autoOpen?booleanOpen the browser's file dialog as soon as the part mounts. Defaults to true.

ContextMenuAnchorinterfaceSource ↗

Where the panel opened, in client coordinates, and how it was opened.

interface ContextMenuAnchor
MemberTypeSummary
trigger'pointer' | 'keyboard'`pointer` for a right-click, which opens at the pointer. `keyboard` for Shift+F10 or the Menu key, which opens below the caret, or at the top-left of the document area when the caret is not on a painted page.
xnumberHorizontal client coordinate the panel opened at, in CSS pixels.
ynumberVertical client coordinate the panel opened at, in CSS pixels.

ContextMenuCommandPropsinterfaceSource ↗

Props for a packaged context-menu row.

interface ContextMenuCommandProps
MemberTypeSummary
className?string
hidden?boolean
icon?DocxEditorChildren
labelKey?string
shortcutKey?string

ContextMenuContextValueinterfaceSource ↗

interface ContextMenuContextValue
MemberTypeSummary
anchorContextMenuAnchor | null
clipboardRefusalstring | null
close(restoreFocus?: boolean) => void
reportClipboardRefusal(reason: string) => void
targetHTMLElement | null
tocIdstring | null

ContextMenuItemPropsinterfaceSource ↗

interface ContextMenuItemProps
MemberTypeSummary
active?boolean
className?string
disabled?boolean
disabledReason?string
icon?DocxEditorChildren
labelstring
onSelect?() => void
shortcut?string

ContextMenuStartPropsinterfaceSource ↗

Props for DocxEditor.ContextMenu.Start.

interface ContextMenuStartProps
MemberTypeSummary
children?DocxEditorChildren

ContextMenuTableRowPropsinterfaceSource ↗

interface ContextMenuTableRowProps extends ContextMenuCommandProps
MemberTypeSummary
destructive?boolean

DialogCustomizationPropsinterfaceSource ↗

Layout customization for a packaged dialog.

interface DialogCustomizationProps
MemberTypeSummary
children?DocxEditorChildren
className?string
preset?boolean
style?CSSProperties

DialogPartPropsinterfaceSource ↗

Shared presentation props for dialog parts.

Anything beyond these members reaches the rendered element, so a part takes an id, an aria-* label or a data-* test hook. The part's own wiring wins every collision: a host cannot replace Apply's handler or its data-docx-part marker by passing one. To own the element and its handler outright, pass as-child and supply your own.

interface DialogPartProps
MemberTypeSummary
"aria-label"?string
(member-1)
asChild?boolean
children?DocxEditorChildren
className?string
hidden?boolean
id?string
style?CSSProperties
title?string

DocxEditorAuthorStylePropsinterfaceSource ↗

interface DocxEditorAuthorStyleProps extends RevisionAuthorStyle
MemberTypeSummary
authorstring

DocxEditorBookmarkDialogPropsinterfaceSource ↗

Props for DocxEditor.BookmarkDialog.

interface DocxEditorBookmarkDialogProps extends DialogCustomizationProps
MemberTypeSummary
onClose() => voidCalled on Cancel, Escape, overlay click, and after a successful Add.
openbooleanWhether the dialog is shown. The host owns this state.

DocxEditorChartPanePropsinterfaceSource ↗

Props for DocxEditor.ChartPane.

interface DocxEditorChartPaneProps
MemberTypeSummary
className?stringA class name added to the pane.

DocxEditorCompareDocumentsDialogPropsinterfaceSource ↗

A Compare documents session with customizable dialog parts.

interface DocxEditorCompareDocumentsDialogProps extends DialogCustomizationProps
MemberTypeSummary
sessionCompareDocumentsDialogSession | null

DocxEditorContentControlNamespaceinterfaceSource ↗

interface DocxEditorContentControlNamespace
MemberTypeSummary
(member-0)
Fieldstypeof ContentControlFields
Headertypeof ContentControlHeader
Removetypeof ContentControlRemove

DocxEditorContentControlWidgetNamespaceinterfaceSource ↗

The compound pop-up with its parts attached as statics.

interface DocxEditorContentControlWidgetNamespace
MemberTypeSummary
(member-0)
Applytypeof ContentControlWidgetApply
Calendartypeof ContentControlWidgetCalendar
Canceltypeof ContentControlWidgetCancel
Daytypeof ContentControlWidgetDay
Errortypeof ContentControlWidgetError
Gridtypeof ContentControlWidgetGrid
Headertypeof ContentControlWidgetHeader
Inputtypeof ContentControlWidgetInput
Itemtypeof ContentControlWidgetItem
Listtypeof ContentControlWidgetList
Monthtypeof ContentControlWidgetMonth
Navigationtypeof ContentControlWidgetNavigation
NextMonthtypeof ContentControlWidgetNextMonth
Picturetypeof ContentControlWidgetPicture
PreviousMonthtypeof ContentControlWidgetPreviousMonth
Titletypeof ContentControlWidgetTitle
Todaytypeof ContentControlWidgetToday
Weekdaystypeof ContentControlWidgetWeekdays
Yeartypeof ContentControlWidgetYear

DocxEditorContentControlWidgetPartPropsinterfaceSource ↗

Presentation overrides for a value pop-up part.

Anything beyond these members reaches the rendered element, so a part takes an id, an aria-* label or a data-* test hook. The part's own wiring wins every collision. Pass asChild to own the element outright and keep its behavior.

interface DocxEditorContentControlWidgetPartProps
MemberTypeSummary
"aria-label"?string
(member-1)
(member-2)
asChild?boolean
children?DocxEditorChildren
class?string
className?string
hidden?boolean
id?string
style?CSSProperties
title?string

DocxEditorContentControlWidgetPropsinterfaceSource ↗

Value-widget session and optional replacement controls.

interface DocxEditorContentControlWidgetProps
MemberTypeSummary
children?DocxEditorChildrenReplaces the packaged arrangement. Compose it from the compound's parts (`DocxEditorContentControlWidget.Calendar`, `.List`, …) or from `useContentControlWidget()`.
className?string
sessionContentControlWidgetSession
style?CSSProperties

DocxEditorContentPropsinterfaceSource ↗

interface DocxEditorContentProps
MemberTypeSummary
children?DocxEditorChildren
class?string
className?string

DocxEditorContextMenuNamespaceinterfaceSource ↗

interface DocxEditorContextMenuNamespace
MemberTypeSummary
(member-0)
CellVerticalAlignmenttypeof ContextMenuCellVerticalAlignment
Copytypeof ContextMenuCopy
Cuttypeof ContextMenuCut
Deletetypeof ContextMenuDelete
DeleteTabletypeof ContextMenuDeleteTable
DeleteTableColumntypeof ContextMenuDeleteTableColumn
DeleteTableRowtypeof ContextMenuDeleteTableRow
Grouptypeof MenuGroup
InsertColumnLefttypeof ContextMenuInsertColumnLeft
InsertColumnRighttypeof ContextMenuInsertColumnRight
InsertRowAbovetypeof ContextMenuInsertRowAbove
InsertRowBelowtypeof ContextMenuInsertRowBelow
Itemtypeof ContextMenuItem
MergeCellstypeof ContextMenuMergeCells
Pastetypeof ContextMenuPaste
PasteWithoutFormattingtypeof ContextMenuPasteWithoutFormatting
RefreshToctypeof ContextMenuRefreshToc
RefreshTocPageNumberstypeof ContextMenuRefreshTocPageNumbers
RemoveToctypeof ContextMenuRemoveToc
Rowtypeof MenuRow
SelectAlltypeof ContextMenuSelectAll
SelectTabletypeof ContextMenuSelectTable
Separatortypeof MenuSeparator
Slottypeof MenuItem
SplitCelltypeof ContextMenuSplitCell
Starttypeof ContextMenuStartHost rows that render above the packaged rows instead of after them.
Submenutypeof MenuSubmenu

DocxEditorContextMenuPropsinterfaceSource ↗

interface DocxEditorContextMenuProps
MemberTypeSummary
children?DocxEditorChildren
className?string
disabled?boolean
onOpenChange?(open: boolean) => void
preset?boolean
t?ToolbarTranslate

DocxEditorDocumentOutlinePropsinterfaceSource ↗

Props for the context-fed outline part.

interface DocxEditorDocumentOutlineProps
MemberTypeSummary
leftOffset?number
onClose?() => void
topOffset?number

DocxEditorExportDialogPropsinterfaceSource ↗

State and presentation for the File menu export dialog.

interface DocxEditorExportDialogProps
MemberTypeSummary
children?DocxEditorChildrenReplaces the default contents while retaining the modal and focus behavior.
className?stringAdditional class on the dialog element.
errorstringLocalized failure text, or an empty string while conversion runs.
formatChromeExportFormatThe format selected in File Export.
onCloseDismisses feedback without canceling the export.
openbooleanControls visibility when rendering the dialog directly.
pendingbooleanTrue while conversion runs. Closing the dialog does not cancel conversion.
style?CSSPropertiesInline styles on the dialog element.

DocxEditorFontNoticePropsinterfaceSource ↗

Props for DocxEditor.FontNotice.

interface DocxEditorFontNoticeProps
MemberTypeSummary
className?string
style?CSSProperties
t?TFunction

DocxEditorHeaderFooterChromePropsinterfaceSource ↗

Props for DocxEditor.HeaderFooterChrome.

interface DocxEditorHeaderFooterChromeProps
MemberTypeSummary
className?string

DocxEditorHyperLinkNamespaceinterfaceSource ↗

interface DocxEditorHyperLinkNamespace
MemberTypeSummary
(member-0)
Applytypeof HyperLinkApply
Canceltypeof HyperLinkCancel
Copytypeof HyperLinkCopy
Edittypeof HyperLinkEdit
Errortypeof HyperLinkError
Fieldstypeof HyperLinkFields
Urltypeof HyperLinkUrl

DocxEditorImageAltTextPopupPropsinterfaceSource ↗

Controlled image description popup.

interface DocxEditorImageAltTextPopupProps
MemberTypeSummary
anchorRef?RefObject<HTMLElement | null>
className?string
idstring
isEnabledboolean
onApply
onClose
onValueChange
valuestring

DocxEditorImageInsertErrorDialogPropsinterfaceSource ↗

Why a picture could not be inserted. Replace it through popups.imageInsertError, or pass false there to show nothing.

interface DocxEditorImageInsertErrorDialogProps
MemberTypeSummary
children?DocxEditorChildrenReplaces the packaged header, message and button.
className?string
messagestringThe translated reason the picture was refused.
onCloseClose the dialog.
style?CSSProperties

DocxEditorImagePropertiesDialogPropsinterfaceSource ↗

Props for DocxEditor.ImagePropertiesDialog.

interface DocxEditorImagePropertiesDialogProps
MemberTypeSummary
className?string
onClose() => void
openboolean
triggerRef?RefObject<HTMLElement | null>

DocxEditorInvalidTextFormFieldDialogPropsinterfaceSource ↗

Invalid-value acknowledgement with editor-owned clearing and focus restoration.

interface DocxEditorInvalidTextFormFieldDialogProps
MemberTypeSummary
children?DocxEditorChildren
className?string
sessionInvalidTextFormFieldSession
style?CSSProperties

DocxEditorLoadingComponentinterfaceSource ↗

interface DocxEditorLoadingComponent
MemberTypeSummary
(member-0)
Spinnertypeof DocxEditorLoadingSpinner

DocxEditorLoadingPropsinterfaceSource ↗

Props for DocxEditor.Loading. Two slots replace parts of the packaged screen: indicator replaces only the spinner and, with overlay, moves below the laid-out pages while a large document lays out its remaining pages; default replaces the whole first screen.

vue <DocxEditor.Loading overlay> <template #indicator><MyLogoSpinner label="Opening document" /></template> </DocxEditor.Loading>

interface DocxEditorLoadingProps
MemberTypeSummary
children?DocxEditorChildrenThe default slot: the whole first loading screen.
className?string
indicator?DocxEditorChildrenThe `indicator` slot: your own indicator, in place of the packaged spinner.
overlay?boolean
style?CSSProperties
when?boolean

DocxEditorLoadingSpinnerPropsinterfaceSource ↗

Props for DocxEditor.Loading.Spinner.

interface DocxEditorLoadingSpinnerProps
MemberTypeSummary
className?string

DocxEditorMenuNamespaceinterfaceSource ↗

interface DocxEditorMenuNamespace
MemberTypeSummary
(member-0)
Bookmarktypeof MenuBookmarkInsert › Bookmark, so a host can hide it or place it elsewhere by name.
Entrytypeof MenuEntry
ExportMarkdowntypeof MenuExportMarkdown
ExportPdftypeof MenuExportPdf
FileMenuPartComponent
FormatMenuPartComponent
Grouptypeof MenuGroup
HelpMenuPartComponent
ImageInserttypeof MenuImageInsert
InsertMenuPartComponent
Itemtypeof MenuItem
Menutypeof Menu
Opentypeof MenuOpen
PageSetuptypeof MenuPageSetup
Printtypeof MenuPrint
ReportIssuetypeof MenuReportIssue
Reviewtypeof MenuReview
Reviewerstypeof MenuReviewers
Rowtypeof MenuRow
Savetypeof MenuSave
Separatortypeof MenuSeparator
Submenutypeof MenuSubmenu
TableGridtypeof MenuTableGrid
Watermarktypeof MenuWatermarkInsert › Watermark, so a host can hide it or place it elsewhere by name.

DocxEditorMenuPropsinterfaceSource ↗

interface DocxEditorMenuProps
MemberTypeSummary
children?DocxEditorChildren
className?string
exporters?ChromeExportHandlersConverter handlers. Markdown requires docx-to-markdown; PDF requires docx-to-pdf on Node.js. File Print also uses the PDF handler. Missing handlers show an error.
fileName?string
onOpen?() => void
onOpenFile?(file: File) => void
onPageSetup?() => voidOwns Page Setup opening when `popups.pageSetup` is omitted. Use `popups` to customize its UI.
onReportIssue?() => void
onSave?() => void
overflow?booleanWhat the bar does when its menus do not fit on one line. Default `true`: the bar stays one line, measures its menus, and moves the ones that do not fit, from the end, into one "⋯" menu, where each becomes a submenu with the same rows. `false` lets the bar wrap onto more lines instead.
preset?boolean
printSettings?booleanWhether File Print first asks which markup to print and whether comments print. Defaults to `true` with the packaged print dialog. A custom `popups.print` component opts in with `true` and renders the `choosing` state, or `DocxEditor.PrintDialog` without children. `popups.print: false` prints the current view without asking.
reportIssue?boolean
t?ToolbarTranslate

DocxEditorNamespaceinterfaceSource ↗

interface DocxEditorNamespace
MemberTypeSummary
(member-0)The packaged editor. The second parameter types its slots for templates: `#openFailureActions` receives the refused open, the packaged message, and `dismiss`.
AuthorStyletypeof DocxEditorAuthorStyle
BookmarkDialogtypeof DocxEditorBookmarkDialogBookmark dialog — list, add, delete and go to bookmarks.
ChartAxestypeof DocxEditorChartAxesThe axes toggle of the selected chart (`chart.axes`).
ChartCategoryAxisTitletypeof DocxEditorChartCategoryAxisTitleThe category (X) axis title of the selected chart (`chart.categoryAxisTitle`).
ChartDatatypeof DocxEditorChartDataThe data editor of the selected chart (`chart.data`).
ChartDataLabelstypeof DocxEditorChartDataLabelsThe data labels toggle of the selected chart (`chart.dataLabels`).
ChartGridlinestypeof DocxEditorChartGridlinesThe gridlines toggle of the selected chart (`chart.gridlines`).
ChartInserttypeof ChartInsertThe chart type list that inserts a chart (`insert.chart`), with `Trigger`, `Content`, `Item`.
ChartLegendtypeof DocxEditorChartLegendThe legend position of the selected chart (`chart.legend`).
ChartPanetypeof DocxEditorChartPaneThe Chart pane: the type, elements, colors, and data of the selected chart.
ChartSeriesColorstypeof DocxEditorChartSeriesColorsThe series (or point) colours of the selected chart (`chart.seriesColor`).
ChartTitletypeof DocxEditorChartTitleThe title of the selected chart (`chart.title`).
ChartTypetypeof DocxEditorChartTypeThe type of the selected chart (`chart.type`).
ChartValueAxisTitletypeof DocxEditorChartValueAxisTitleThe value (Y) axis title of the selected chart (`chart.valueAxisTitle`).
ColorByChangeTypetypeof DocxEditorColorByChangeType
ColorPickertypeof ColorPickerThe shared colour picker compound (`Root`, `Trigger`, `Content`, `Swatch`, …).
CompareDocumentsDialogtypeof DocxEditorCompareDocumentsDialog
Contenttypeof DocxEditorContent
ContentControltypeof DocxEditorContentControl
ContentControlWidgettypeof DocxEditorContentControlWidget
ContextMenutypeof ContextMenu
DocumentOutlinetypeof DocxEditorDocumentOutline
Equationtypeof DocxEditorEquationThe default linear-math popover for a clicked Office Math equation.
ExportDialogtypeof DocxEditorExportDialogFile export progress and errors, configured through popups.export.
FontNoticetypeof DocxEditorFontNotice
HeaderFooterChrometypeof DocxEditorHeaderFooterChrome
HorizontalRulertypeof DocxEditorHorizontalRuler
ImageAltTextPopuptypeof DocxEditorImageAltTextPopup
ImagePropertiesDialogtypeof DocxEditorImagePropertiesDialog
InvalidTextFormFieldDialogtypeof DocxEditorInvalidTextFormFieldDialog
Loadingtypeof DocxEditorLoading
Menutypeof DocxEditorMenu
Navigationtypeof Navigation
NotePreviewtypeof DocxEditorNotePreview
NotePropertiesDialogtypeof DocxEditorNotePropertiesDialog
NotesChrometypeof DocxEditorNotesChrome
NotesContextMenutypeof DocxEditorNotesContextMenu
OpenFailuretypeof DocxEditorOpenFailureThe dialog that explains a file the editor refused to open. Mounted by default.
PageNumbertypeof DocxEditorPageNumber
PageSetupDialogtypeof DocxEditorPageSetupDialog
PaneSectionstypeof DocxEditorPaneSectionsThe sections of a pane (`PANE_SECTIONS`), each a heading over its slot parts.
ParagraphDialogtypeof DocxEditorParagraphDialogThe Paragraph dialog: alignment, indentation, spacing and the paragraph flags.
PrintDialogtypeof DocxEditorPrintDialogFile print progress and errors, configured through popups.print.
RevisionMarkuptypeof DocxEditorRevisionMarkup
RevisionMarkupDialogtypeof DocxEditorRevisionMarkupDialog
Roottypeof DocxEditorRoot
ShapeFilltypeof DocxEditorShapeFillThe fill colour of the selected shape (`shape.fill`).
ShapeFillTransparencytypeof DocxEditorShapeFillTransparencyThe fill transparency of the selected shape (`shape.fillTransparency`).
ShapeOutlineColortypeof DocxEditorShapeOutlineColorThe outline colour of the selected shape (`shape.outlineColor`).
ShapeOutlineDashtypeof DocxEditorShapeOutlineDashThe outline dash of the selected shape (`shape.outlineDash`).
ShapeOutlineWidthtypeof DocxEditorShapeOutlineWidthThe outline width of the selected shape (`shape.outlineWidth`).
ShapePanetypeof DocxEditorShapePaneThe Format shape pane: the fill and outline of the selected shape.
SidePaneltypeof DocxEditorSidePanelThe side panel that holds the Chart pane or the Format shape pane; the host renders it to show it.
SplitCellDialogtypeof DocxEditorSplitCellDialogSplit cells dialog — split the cell at the selection into columns and rows.
TextFormFieldDialogtypeof DocxEditorTextFormFieldDialog
Toolbartypeof DocxEditorToolbar
UnsupportedElementtypeof DocxEditorUnsupportedElement
VerticalRulertypeof DocxEditorVerticalRuler
Viewporttypeof DocxEditorViewport
WatermarkDialogtypeof DocxEditorWatermarkDialogWatermark dialog — none, picture or text — applied as one undo step.
Windowtypeof DocxEditorWindowThe editor panel in a pop-out window while `open`; see the pop-out guide.

DocxEditorNavigationNamespaceinterfaceSource ↗

interface DocxEditorNavigationNamespace
MemberTypeSummary
(member-0)
Closetypeof NavigationClose
Findtypeof NavigationFind
GoTotypeof NavigationGoTo
Headertypeof NavigationHeader
Headingstypeof NavigationHeadings
Tabtypeof NavigationTab
Tabstypeof NavigationTabs
Titletypeof NavigationTitle
Toggletypeof NavigationToggle

DocxEditorNavigationPropsinterfaceSource ↗

Props for DocxEditor.Navigation.

interface DocxEditorNavigationProps extends UseNavigationPaneOptions
MemberTypeSummary
children?DocxEditorChildren
className?string
findShortcut?booleanWhether Ctrl+F (Cmd+F on macOS) opens the pane on the Find tab. Defaults to `true`. The shortcut applies only while focus is in this editor, so the rest of the page keeps the browser's own search. Set `false` to leave the shortcut to the browser everywhere.
goToShortcut?booleanWhether Ctrl+G (Cmd+Option+G on macOS) opens the pane on the Go to tab. Defaults to `true`, and applies only while focus is in this editor. The `openGoTo` editor command opens the tab either way.
searchHighlight?DocumentSearchHighlightWhich Find matches to highlight while the Find tab is open: `'all'` (default), `'active'`, or `'none'`. The pane stops requesting highlights when it closes or leaves the tab; another `useDocumentSearch` consumer can still request them.
style?CSSProperties
t?(key: string, params?: Record<string, string | number>) => stringLabel resolver. Defaults to the `translate` given to `DocxEditorRoot`, and for keys it leaves unresolved, to the active locale catalogue.
toggle?boolean | NavigationPartProps

DocxEditorNotePreviewPropsinterfaceSource ↗

Note hover preview content and viewport coordinates.

interface DocxEditorNotePreviewProps
MemberTypeSummary
className?string
scopeIdstring
textstring
xnumber
ynumber

DocxEditorNotePropertiesDialogPropsinterfaceSource ↗

Note properties draft callbacks.

interface DocxEditorNotePropertiesDialogProps
MemberTypeSummary
onApply
onClose

DocxEditorNotesChromePropsinterfaceSource ↗

interface DocxEditorNotesChromeProps
MemberTypeSummary
className?string

DocxEditorNotesContextMenuPropsinterfaceSource ↗

Note context menu state and actions.

interface DocxEditorNotesContextMenuProps
MemberTypeSummary
className?string
convertAllDisabledReason?string
convertAllEnabledboolean
convertDisabledReason?string
convertEnabledboolean
deleteDisabledReason?string
deleteEnabledboolean
noteIdnumber
noteKind'footnote' | 'endnote'
onClose
onConvert
onConvertAll
onDelete
onOpenProperties
scopeIdstring
xnumber
ynumber

DocxEditorOpenFailureActionPropsinterfaceSource ↗

Props for DocxEditor.OpenFailure.Action.

interface DocxEditorOpenFailureActionProps
MemberTypeSummary
asChild?booleanRender your own element, such as a link, with the button's classes and handler.
children?DocxEditorChildrenThe `default` slot: the button label, or with `asChild` your own element.
dismiss?booleanClose the dialog after the click handler runs, unless it called `preventDefault()`.
variant?'primary' | 'secondary'`primary` is filled, `secondary` is outlined. Defaults to `secondary`.

DocxEditorOpenFailureComponentinterfaceSource ↗

The open-failure part with its button attached as a static.

interface DocxEditorOpenFailureComponent
MemberTypeSummary
(member-0)Renders the dialog while a refused open is waiting, and nothing otherwise. The second parameter types the `default` and `actions` slots for templates.
Actiontypeof DocxEditorOpenFailureActionA button styled for the dialog, for the `actions` and `default` slots.

DocxEditorOpenFailureContextinterfaceSource ↗

What the actions and default slots receive.

interface DocxEditorOpenFailureContext
MemberTypeSummary
dismissClose the dialog. It emits `dismiss`, as **Close** does.
failureDocumentOpenFailureThe refused open: its stable `code` and its `reason`.
messagestringThe packaged, translated message for the failure.

DocxEditorOpenFailurePropsinterfaceSource ↗

Props for DocxEditor.OpenFailure.

interface DocxEditorOpenFailureProps
MemberTypeSummary
actions?(context: DocxEditorOpenFailureContext) => DocxEditorChildrenThe `actions` slot: your own buttons, before **Close**.
children?(context: DocxEditorOpenFailureContext) => DocxEditorChildrenThe `default` slot: your own dialog content, in place of the header, body and footer.
className?stringAppended after the load-bearing `docx-dialog` class.
closeLabel?stringThe label of the **Close** button. Defaults to the translated `common.close`.
message?DocxEditorOpenFailureMessageYour own message in place of the packaged one, as content or per failure.
onDismiss?(failure: DocumentOpenFailure) => voidListener for the `dismiss` event: the person closed the dialog, by any route.
showClose?booleanShow the packaged **Close** button. Defaults to `true`. Turn it off only when the `actions` slot gives a way out. Escape still closes the dialog.
showCode?booleanShow the stable error code under the message. Defaults to `true`.
style?CSSPropertiesInline styles for the dialog element.
t?TFunctionTranslator override; defaults to the ambient locale context.
title?stringThe dialog title. Defaults to the translated `openFailure.title`. It also names the dialog for screen readers, including when your own content replaces the packaged one.

DocxEditorPageNumberPropsinterfaceSource ↗

Props for DocxEditor.PageNumber.

interface DocxEditorPageNumberProps
MemberTypeSummary
className?string
style?CSSProperties

DocxEditorPageSetupDialogPropsinterfaceSource ↗

interface DocxEditorPageSetupDialogProps extends DialogCustomizationProps
MemberTypeSummary
onClose() => void
openboolean

DocxEditorPaneSectionsPropsinterfaceSource ↗

Props for DocxEditor.PaneSections.

interface DocxEditorPaneSectionsProps<P extends EditorPaneId = EditorPaneId>
MemberTypeSummary
filter?(section: PaneSection<P>) => booleanLeaves out sections; `ChartPane` leaves out the format sections of a chart it cannot read.
panePThe pane whose sections to render: `shape` or `chart`.
sections?readonly PaneSectionId<P>[]Only these sections, by id (`fill` and `outline`; `type`, `elements`, `colors`, and `data`); default all.

DocxEditorParagraphDialogPropsinterfaceSource ↗

Props for DocxEditorParagraphDialog.

interface DocxEditorParagraphDialogProps extends DialogCustomizationProps
MemberTypeSummary
onClose() => void
openboolean

DocxEditorPopupsinterfaceSource ↗

Render overrides for automatically hosted editor popups. False disables a popup.

interface DocxEditorPopups
MemberTypeSummary
bookmark?DocxEditorPopup<DocxEditorBookmarkDialogProps>The Bookmark dialog the Insert menu and Ctrl/Cmd+Shift+F5 open.
compareDocuments?DocxEditorPopup<DocxEditorCompareDocumentsDialogProps>The Compare documents dialog the Review menu opens. Requires the review module.
contentControl?DocxEditorPopup<ContentControlProps>
contentControlCheckbox?DocxEditorPopup<DocxEditorContentControlWidgetProps>Renderer for checkbox presses. Omitted, the engine toggles the box itself and `contentControlWidget` never sees a checkbox session. Configure it to confirm, refuse or restyle the toggle; `DocxEditorContentControlWidget` without children applies it at once.
contentControlPicture?DocxEditorPopup<DocxEditorContentControlWidgetProps>Renderer for picture presses. Omitted, the engine opens its own file picker and `contentControlWidget` never sees a picture session. Configure it to pick from your own source; `DocxEditorContentControlWidget` without children opens a file picker at once.
contentControlWidget?DocxEditorPopup<DocxEditorContentControlWidgetProps>
contextMenu?DocxEditorPopup<DocxEditorContextMenuProps>
equation?DocxEditorPopup<Record<string, never>>
export?DocxEditorPopup<DocxEditorExportDialogProps>File export progress and errors. False hides feedback without stopping conversion.
imageAltText?DocxEditorPopup<DocxEditorImageAltTextPopupProps>
imageInsertError?DocxEditorPopup<DocxEditorImageInsertErrorDialogProps>Why a chosen or pasted picture could not be inserted. False shows nothing.
imageProperties?DocxEditorPopup<DocxEditorImagePropertiesDialogProps>
invalidTextFormField?DocxEditorPopup<DocxEditorInvalidTextFormFieldDialogProps>
notePreview?DocxEditorPopup<DocxEditorNotePreviewProps>
noteProperties?DocxEditorPopup<DocxEditorNotePropertiesDialogProps>
notesContextMenu?DocxEditorPopup<DocxEditorNotesContextMenuProps>
pageSetup?DocxEditorPopup<DocxEditorPageSetupDialogProps>
paragraph?DocxEditorPopup<DocxEditorParagraphDialogProps>
print?DocxEditorPopup<DocxEditorPrintDialogProps>File print progress and errors. False hides feedback; printing still runs.
revisionMarkup?DocxEditorPopup<DocxEditorRevisionMarkupDialogProps>Track changes options. False cancels the requested settings session.
splitCell?DocxEditorPopup<DocxEditorSplitCellDialogProps>The Split cells dialog the table context menu and toolbar open.
textFormField?DocxEditorPopup<DocxEditorTextFormFieldDialogProps>
watermark?DocxEditorPopup<DocxEditorWatermarkDialogProps>The Watermark dialog the Insert menu opens. Pass `presets` here to change its text choices.

DocxEditorPrintDialogPropsinterfaceSource ↗

State and presentation for the File menu print dialog.

interface DocxEditorPrintDialogProps
MemberTypeSummary
children?DocxEditorChildrenReplaces the default contents while retaining the modal and focus behavior.
choosing?booleanTrue while the dialog shows print settings, before conversion starts. Present only when the menu's `printSettings` step is on.
className?stringAdditional class on the dialog element.
errorstringLocalized failure text, or an empty string.
onCloseCloses the dialog. While `pending` is true, closing also cancels printing.
onPrint?() => voidStarts conversion with `settings`.
onSettingsChange?(change: ChromePrintSettings) => voidChanges one or both settings.
openbooleanControls visibility when rendering the dialog directly.
pendingbooleanTrue while the PDF handler converts the document.
settings?ResolvedChromePrintSettingsThe settings the form shows.
style?CSSPropertiesInline styles on the dialog element.
urlstringAn object URL for the converted PDF when printing failed after conversion, such as in a browser without a PDF viewer. Otherwise an empty string. The default dialog links only to `blob:` URLs.

DocxEditorPropsinterfaceSource ↗

Props for the Vue DocxEditor sugar host.

interface DocxEditorProps
MemberTypeSummary
author?string
chrome?boolean
class?string
colorMode?'light' | 'dark' | 'system'
contentLockPolicy?ContentLockPolicyOpt-in relaxation of content-control locks. With `allowFormattingInLockedContent: true`, readers can format `contentLocked` and `sdtContentLocked` controls while their text stays protected. Read once, when the editor is created: a later change in value is ignored, with a development warning.
contextMenu?boolean | DocxEditorContextMenuProps
document?DocumentSource
fieldResults?FieldResultsModeHow the reader edits saved field results. `'atomic'` (the default) keeps every field one unit. `'editable'` allows typing, deletion, and selection inside the saved result of a DATE, MERGEFIELD, HYPERLINK, or similar field. Read once, when the editor is created: a later change is ignored, with a development warning. Refused with a collaboration module.
fonts?FontConfiguration | FontConfigurationFragment | FontResolverFont sources. A new value replaces them in place, keeping edits, selection and history.
fontShaping?FontShapingOptionsExplicit shaping byte ceiling. A changed maxFontBytes value remounts; equal values keep the instance.
hyperlinkPopup?boolean
i18n?Translations
imageDecodePort?ImageDecodePortInject image decoding and preserved-image conversion. A changed port identity remounts the editor.
locale?stringBCP-47 locale for regional date input and engine-generated labels. Defaults to en-US. Changes apply to subsequent edits without a remount; stored date formats are preserved. UI translations are supplied separately through i18n.
lockedControlNavigation?LockedControlNavigationHow the caret moves through an inline content control whose content is locked. `'characters'` (the default) walks through its characters, as Word does. `'atomic'` makes the control one caret unit. Read once, when the editor is created: a later change is ignored, with a development warning.
menu?boolean | DocxEditorMenuProps
mode?EditorModeLive host mode.
modules?readonly EditorModule[]Construction-time capability modules. Later array changes need a remount.
navigation?boolean | DocxEditorNavigationPropsThe packaged navigation pane: `false` removes it, an object is `DocxEditorNavigationProps`. The pane captures Ctrl+F (Cmd+F on macOS) while focus is in this editor and opens Find; `:navigation="{ findShortcut: false }"` leaves the shortcut to the browser.
openFailure?boolean | DocxEditorOpenFailurePropsThe dialog that explains a file the editor refused to open, on by default. A refused open leaves the pages blank, so without it the reader sees nothing. An object is `DocxEditorOpenFailureProps`, passed straight through. `false` removes the dialog, for a host that reports the failure itself through `useOpenFailure`. For your own buttons, use the `openFailureActions` slot.
popups?DocxEditorPopups
reviewDisplayMode?ReviewDisplayModeInitial revision display mode.
revisionMarkup?RevisionMarkupOptionsControlled viewer markup settings. Omitted fields use defaults. Save callback values into this prop to accept API and dialog changes. Omit this prop for uncontrolled settings. Use one configuration source.
rulers?boolean
t?(key: string, params?: Record<string, string | number>) => stringLive resolver for chrome and drawing labels.
title?string
zoom?number
zoomMode?ZoomMode | 'auto'

DocxEditorRefinterfaceSource ↗

Imperative handle exposed by <DocxEditor ref="…">.

interface DocxEditorRef
MemberTypeSummary
exec
focus
getDocumentHandle
getEditor
load
save
snapshot

DocxEditorRevisionMarkupDialogPropsinterfaceSource ↗

A markup settings session with customizable dialog parts.

interface DocxEditorRevisionMarkupDialogProps extends DialogCustomizationProps
MemberTypeSummary
sessionRevisionMarkupDialogSession | null

DocxEditorRevisionMarkupPropsinterfaceSource ↗

Viewer-local markup declarations.

interface DocxEditorRevisionMarkupProps extends RevisionMarkupOptions
MemberTypeSummary
onRevisionMarkupChange?(settings: ResolvedRevisionMarkup) => void

DocxEditorRootListenersinterfaceSource ↗

Lifecycle listeners for [provideDocxEditor](provideDocxEditor); bind on [DocxEditorRoot](DocxEditorRoot).

interface DocxEditorRootListeners
MemberTypeSummary
onChange?(change: DocumentChange) => void
onFontError?(error: EditorFontError) => void
onReady?(editor: Editor) => void
onRevisionMarkupChange?(settings: ResolvedRevisionMarkup) => void

DocxEditorRootPropsinterfaceSource ↗

interface DocxEditorRootProps
MemberTypeSummary
author?stringAuthor for later comments, replies, and tracked changes. Changes apply without a remount.
children?DocxEditorChildren
colorMode?'light' | 'dark' | 'system'Colour theme of the composed chrome, as on `DocxEditor`. `'dark'` puts `.dark` beside `.docx-editor` on every part that scopes itself (toolbar, menu bar, viewport, dialogs), and `'system'` follows the OS setting as it changes. Defaults to `'light'`. The page content in the viewport is shown inverted in dark mode, as in `DocxEditor`. Changes apply without a remount.
contentLockPolicy?ContentLockPolicyOpt-in relaxation of content-control locks. With `allowFormattingInLockedContent: true`, readers can format `contentLocked` and `sdtContentLocked` controls while their text stays protected. Read once, when the editor is created: a later change in value is ignored, with a development warning.
document?DocumentSource
fieldResults?FieldResultsModeHow the reader edits saved field results. `'atomic'` (the default) keeps every field one unit. `'editable'` allows typing, deletion, and selection inside the saved result of a DATE, MERGEFIELD, HYPERLINK, or similar field. Read once, when the editor is created: a later change is ignored, with a development warning. Refused with a collaboration module.
fonts?FontConfiguration | FontConfigurationFragment | FontResolverFont sources. A new value replaces them in place (`setFonts`), keeping edits and history.
fontShaping?FontShapingOptionsExplicit shaping byte ceiling; a changed maxFontBytes value remounts.
imageDecodePort?ImageDecodePort
locale?stringBCP-47 locale for regional date input and engine-generated labels. Defaults to en-US. Changes apply to subsequent edits without a remount; stored date formats are preserved. For UI translations, wrap Root and its chrome in LocaleProvider with an i18n catalog.
lockedControlNavigation?LockedControlNavigationHow the caret moves through an inline content control whose content is locked. `'characters'` (the default) walks through its characters, as Word does. `'atomic'` makes the control one caret unit. Read once, when the editor is created: a later change is ignored, with a development warning.
mode?'edit' | 'view' | 'suggesting'Live host mode. Omit it to let document tracking settings select the mode.
modules?readonly EditorModule[]Construction-time capability modules. Later array changes need a remount.
onChange?(change: DocumentChange) => void
onFontError?(error: EditorFontError) => void
onReady?(editor: Editor) => void
onRevisionMarkupChange?(settings: ResolvedRevisionMarkup) => voidReceives proposed settings from API or dialog changes, excluding prop reconciliation.
popups?DocxEditorPopups
reviewDisplayMode?ReviewDisplayModeInitial revision display mode.
revisionMarkup?RevisionMarkupOptionsControlled viewer markup settings. Omitted fields use defaults. Save callback values into this prop to accept API and dialog changes. Omit this prop for uncontrolled settings. Use one configuration source.
tableInteractionLabel?(key: TableInteractionLabelKey) => string
translate?(key: string, params?: Record<string, string | number>) => stringLive drawing and form-control labels. Defaults to the active catalogue.
zoom?number
zoomMode?ZoomMode | 'auto'

DocxEditorRulerPropsinterfaceSource ↗

interface DocxEditorRulerProps
MemberTypeSummary
className?string
style?CSSProperties
unit?'inch' | 'cm'

DocxEditorShapePanePropsinterfaceSource ↗

Props for DocxEditor.ShapePane.

interface DocxEditorShapePaneProps
MemberTypeSummary
className?stringA class name added to the pane.

DocxEditorSidePanelPropsinterfaceSource ↗

Props for DocxEditor.SidePanel.

interface DocxEditorSidePanelProps
MemberTypeSummary
children?DocxEditorChildrenThe default slot: content that replaces the packaged panes. When Edit chart or Format shape asks for the focus, the panel moves it to the first field in this content.
className?stringA class name added to the panel.
onClose?() => voidShows a close button that calls it.

DocxEditorSplitCellDialogPropsinterfaceSource ↗

Props for DocxEditor.SplitCellDialog.

interface DocxEditorSplitCellDialogProps extends DialogCustomizationProps
MemberTypeSummary
onClose() => voidCalled on Cancel, Escape, overlay click, and after a successful Split.
openbooleanWhether the dialog is shown. The host owns this state.

DocxEditorTextFormFieldDialogPropsinterfaceSource ↗

Controlled Field Options dialog.

interface DocxEditorTextFormFieldDialogProps extends DialogCustomizationProps
MemberTypeSummary
sessionTextFormFieldDialogSession | null

DocxEditorToolbarGroupPropsinterfaceSource ↗

Props for DocxEditor.Toolbar.Group.

interface DocxEditorToolbarGroupProps
MemberTypeSummary
after?ChromeGroupId | (string & {})The group this one follows in the bar. Without it, a host group follows every built-in group, in order of appearance. Ignored for built-in ids.
children?DocxEditorChildrenThe group's controls, passed as the default slot.
className?string
hidden?booleanRemoves the group, built-in or host, from the bar and the "⋯" panel.
idChromeGroupId | (string & {})The group id. A built-in id (`'history'`, `'font'`, `'text'`, `'review'`, ...) adds the children to that group, after its own controls. Any other id makes a host group.
label?stringLiteral heading and accessible name for a host group. It wins over `labelKey`. Without either, the heading is `id`. Built-in groups keep their own label.
labelKey?stringCatalog key for the host group's "⋯" panel heading and accessible name. It goes through the toolbar's `t` and the locale catalog. Built-in groups keep their own label.
overflowContent?() => DocxEditorChildrenContent for the group's "⋯" panel section, rendered after a built-in group's own rows. It renders even when the group has no children, so a built-in id can add a panel-only row. Without it, the panel renders the children in panel rows: actions become labeled rows, and other content renders as is.
pinned?boolean`true` keeps the group in the bar at every width, like the review group.
priority?numberCollapse priority. A lower number leaves the bar first. Built-in groups use 10 (zoom) through 90 (history) in steps of 10. A host group without a priority collapses before every built-in group.

DocxEditorToolbarNamespaceinterfaceSource ↗

interface DocxEditorToolbarNamespace
MemberTypeSummary
(member-0)
Actiontypeof ToolbarAction
AddCommenttypeof ToolbarAddCommentOpens a comment draft on the selection in the review rail.
AlignCenterToolbarPartComponent
AlignJustifyToolbarPartComponent
AlignLeftToolbarPartComponent
AlignmentToolbarAlignmentComponent
AlignRightToolbarPartComponent
BoldToolbarPartComponent
BulletListToolbarPartComponent
Buttontypeof ToolbarButton$1
ChartInsertChartInsertPartComponentThe Insert chart dropdown (`insert.chart`).
ClearFormattingToolbarPartComponent
CommentsToolbarPartComponent
ContentControlFormFillToolbarPartComponent
ContentControlInspectorToolbarPartComponent
ContentControlRemoveToolbarPartComponent
ContentControlShowAllToolbarPartComponent
EditingModeToolbarSlotPartComponent
FontColorToolbarColorSplitComponent
FontFamilytypeof FontFamily
FontSizeToolbarSlotPartComponent
Grouptypeof ToolbarHostGroupA group of the preset bar: host content that is measured and collapses into the "⋯" panel, or, with a built-in id, controls added to that group or the group hidden.
HighlightToolbarColorSplitComponent
ImageAltTextImageAltTextPartComponent
ImageInsertToolbarPartComponent
ImagePropertiesToolbarPartComponent
ImageWrapImageWrapPartComponent
IndentToolbarPartComponent
ItalicToolbarPartComponent
LeftToRightToolbarPartComponent
LineSpacingToolbarSlotPartComponent
NumberedListToolbarPartComponent
OutdentToolbarPartComponent
RedoToolbarPartComponent
Reviewerstypeof ToolbarReviewers
RightToLeftToolbarPartComponent
SaveToolbarSlotPartComponent
Separatortypeof ToolbarSeparator
Slottypeof ToolbarSlotReplaces one built-in slot with arbitrary content, in the slot's place.
StrikeToolbarPartComponent
StylePickertypeof ParagraphStyle
SubscriptToolbarPartComponent
SuperscriptToolbarPartComponent
TableBorderColorTableBorderColorNamespace
TableBorderStyleTableBorderStyleNamespace
TableBorderTargetTableBorderTargetNamespace
TableBorderWidthTableBorderWidthNamespace
TableCellFillTableCellFillNamespace
TableInsertToolbarPartComponent
TableMergeCellsToolbarPartComponentMerge the selected cells.
TableSplitCellToolbarPartComponentOpen the Split cells dialog.
UnderlineToolbarPartComponent
UndoToolbarPartComponent
ZoomToolbarSlotPartComponent

DocxEditorToolbarPropsinterfaceSource ↗

interface DocxEditorToolbarProps
MemberTypeSummary
children?DocxEditorChildren
className?string
onSave?() => void
overflow?boolean
preset?boolean
t?ToolbarTranslate

DocxEditorToolbarSlotPropsinterfaceSource ↗

Props for DocxEditor.Toolbar.Slot.

interface DocxEditorToolbarSlotProps
MemberTypeSummary
children?DocxEditorChildrenThe replacement content, passed as the default slot.
hidden?booleanRender nothing: inside the preset arrangement this removes the slot in place. A named part with `hidden`, such as `<Toolbar.Bold hidden />`, is shorthand for this override.
overflowContent?() => DocxEditorChildrenContent for the slot's "⋯" panel row when the slot leaves the bar. Without it the panel row shows the default slot content under the slot's label.
slotIdChromeSlotIdThe built-in slot this content replaces, for example `'text.bold'`.

DocxEditorUnsupportedElementPropsinterfaceSource ↗

Props for a registered unsupported-content renderer.

interface DocxEditorUnsupportedElementProps extends UnsupportedElementRule
MemberTypeSummary
includePartial?UnsupportedElementRule['includePartial']Include partially rendered drawings (`support: 'partial'`). Defaults to `false`. Excludes fully supported drawings, hidden drawings, and drawings without a layout position. Excludes shapes with editable text. Partially rendered shapes without text remain eligible.

DocxEditorViewportPropsinterfaceSource ↗

interface DocxEditorViewportProps
MemberTypeSummary
children?DocxEditorChildren
class?string
className?string
style?CSSProperties

DocxEditorWatermarkDialogPropsinterfaceSource ↗

Props for DocxEditor.WatermarkDialog.

interface DocxEditorWatermarkDialogProps extends DialogCustomizationProps
MemberTypeSummary
onClose() => voidCalled on Cancel, Escape, overlay click, and after a successful Apply.
openbooleanWhether the dialog is shown. The host owns this state.
presets?readonly string[]The text choices offered for a text watermark. Defaults to `DEFAULT_WATERMARK_PRESETS`.

DocxEditorWindowPropsinterfaceSource ↗

Props for DocxEditorWindow.

interface DocxEditorWindowProps
MemberTypeSummary
children?DocxEditorChildrenThe editor panel: toolbar, viewport and content, or any part of them.
features?stringThe `window.open` features. Defaults to `popup,width=1000,height=900`.
name?stringThe window name. Defaults to `docx-editor`. Two `DocxEditorWindow` components with the same name share one browser window, so give each editor its own name.
onClose?() => voidThe pop-out went away (the user closed it, or the browser blocked it). The `close` event.
openbooleanRender the default slot in a pop-out window. While `false`, it renders in place.
styles?boolean | ((from: Document, to: Document) => () => void)Copy this page's stylesheets into the window, and keep copying new ones. Default `true`.
title?stringThe pop-out's title.
url?stringA same-origin page to open. Defaults to `about:blank`.

EditorCaretinterfaceSource ↗

interface EditorCaret
MemberTypeSummary
blockIdstringThe paragraph, as `TextPosition.blockId` and `TextMatch.blockId` name it.
offsetnumberUTF-16 offset in the paragraph's model text.
paragraphIdstringThe same paragraph id as `blockId`, for `at` parameters that take `paragraphId`.

EditorCommandStateinterfaceSource ↗

interface EditorCommandState
MemberTypeSummary
disabledReasonComputedRef<string | null>
executeEditorCommandExecute
isActiveComputedRef<boolean>
isEnabledComputedRef<boolean>
valueComputedRef<string | null>What the control SHOWS, for the slots whose answer is a value rather than a pressed state — the editing-mode pill, and the format painter's `off` / `once` / `locked`.

EditorValueCommandStateinterfaceSource ↗

interface EditorValueCommandState<T extends string | number>
MemberTypeSummary
disabledReasonComputedRef<string | null>
execute(value: T, options?: EditorExecOptions) => ExecResult
isEnabledComputedRef<boolean>
optionsComputedRef<readonly T[]>
valueComputedRef<T | null>

FontFamilyItemPropsinterfaceSource ↗

interface FontFamilyItemProps extends FontFamilyPartProps
MemberTypeSummary
valuestring

FontFamilyNamespaceinterfaceSource ↗

interface FontFamilyNamespace
MemberTypeSummary
(member-0)
Contenttypeof FontFamilyContent
docxSlot'font.family'
Itemtypeof FontFamilyItem
Triggertypeof FontFamilyTrigger

FontFamilyPartPropsinterfaceSource ↗

interface FontFamilyPartProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildren
className?string

FontFamilyPropsinterfaceSource ↗

interface FontFamilyProps extends FontFamilyPartProps
MemberTypeSummary
hidden?boolean

FontOptioninterfaceSource ↗

Shared FontOption shape + normaliser used by FontPicker components in both adapters. Lifted from packages/react/src/components/ui/ normalizeFontFamilies.ts so the type definition has a single home.

interface FontOption
MemberTypeSummary
category?'sans-serif' | 'serif' | 'monospace' | 'other'
fontFamilystring
namestring

HorizontalRulerPropsinterfaceSource ↗

interface HorizontalRulerProps
MemberTypeSummary
className?string
editable?booleanWhether the MARGIN handles drag.
indent?RulerIndent | nullThe paragraph's indent in twips; `firstLine` is SIGNED, negative for a hanging.
indentEditable?booleanWhether the INDENT handles drag — a different capability from `editable`.
onIndentChange?(indent: RulerIndent) => voidFires continuously through an indent drag, for the host to preview.
onIndentDragEnd?() => voidFires when an indent drag is released — the moment to commit one undoable step.
onLeftMarginChange?(marginTwips: number) => void
onMarginDragEnd?() => voidFires when a margin drag is released — the moment to commit what the drag previewed.
onRightMarginChange?(marginTwips: number) => void
onTabMarkRemove?(positionTwips: number) => void
pageSetup?RulerPageSetup | null
showIndentHandles?booleanPaint the four indent handles.
style?CSSProperties
tabMarks?RulerTabStop[] | null
unit?'inch' | 'cm'
zoom?number

HyperLinkActionPropsinterfaceSource ↗

Props for the action parts, which also take an icon.

interface HyperLinkActionProps extends HyperLinkPartProps
MemberTypeSummary
icon?DocxEditorChildren

HyperLinkPartPropsinterfaceSource ↗

Shared props for every part.

interface HyperLinkPartProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildren
className?string
hidden?boolean

HyperlinkPopupAnchorinterfaceSource ↗

interface HyperlinkPopupAnchor
MemberTypeSummary
leftnumber
topnumber

HyperlinkPopupStateinterfaceSource ↗

interface HyperlinkPopupState
MemberTypeSummary
anchorHyperlinkPopupAnchor | null
canEditboolean
copiedboolean
errorboolean
modeHyperlinkPopupMode
textstring
urlstring

HyperLinkPropsinterfaceSource ↗

Props for DocxEditor.HyperLink.

interface HyperLinkProps extends HyperLinkPartProps
MemberTypeSummary
preset?boolean

ImagePropertiesTriggerPropsinterfaceSource ↗

Props for the toolbar properties trigger.

interface ImagePropertiesTriggerProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildren
className?string
hidden?boolean

IndentUpdateinterfaceSource ↗

interface IndentUpdate
MemberTypeSummary
firstLine?number | null
left?number | null
right?number | null

ListStateinterfaceSource ↗

interface ListState
MemberTypeSummary
isInListboolean
levelnumber
numId?number
typeListType

LocaleProviderPropsinterfaceSource ↗

interface LocaleProviderProps
MemberTypeSummary
children?DocxEditorChildren
dir?'ltr' | 'rtl'The writing direction of the editor chrome. Defaults to the catalog's `_dir`, then to a right-to-left `_lang`, then to the direction of an outer provider. With `'rtl'`, the toolbar, menu bar, dialogs, context menu, panes, and review column mirror without a wrapper element. `'ltr'` keeps a left-to-right chrome on a right-to-left host page. Without any of these, as with the shipped left-to-right catalogs, the chrome inherits the host page direction.
i18n?Translations

Props for the pinned File rows.

interface MenuActionProps
MemberTypeSummary

Props for DocxEditor.Menu.Group: a titled section of rows.

interface MenuGroupProps
MemberTypeSummary

The props every Menu.Item takes besides the slot it names.

interface MenuItemBaseProps
MemberTypeSummary

Props for DocxEditor.Menu.Item: one chrome slot as a menu row. Set slotId. A row with neither slotId nor the deprecated slot renders nothing, with a development warning. An interface, so a host can extend it.

interface MenuItemProps extends MenuItemBaseProps
MemberTypeSummary

A menu pinned to one registry id, for DocxEditor.Menu.File and friends.

interface MenuPartComponent
MemberTypeSummary

Props for DocxEditor.Menu.Menu and the five pinned menu parts.

interface MenuProps
MemberTypeSummary

Props for DocxEditor.Menu.ReportIssue.

interface MenuReportIssueProps
MemberTypeSummary

Props for DocxEditor.Menu.Row: one presentational menu row.

interface MenuRowProps
MemberTypeSummary

Props for DocxEditor.Menu.Separator.

interface MenuSeparatorProps
MemberTypeSummary

The props every Menu.Submenu takes besides its label.

interface MenuSubmenuBaseProps
MemberTypeSummary

Props for DocxEditor.Menu.Submenu. Set labelKey or label. A submenu with neither has no name, with a development warning. An interface, so a host can extend it.

interface MenuSubmenuProps extends MenuSubmenuBaseProps
MemberTypeSummary

Props for DocxEditor.Menu.TableGrid.

interface MenuTableGridProps
MemberTypeSummary

Shared props for the pane's structural parts.

interface NavigationPartProps
MemberTypeSummary
interface NavigationShiftInput
MemberTypeSummary
interface NavigationTabProps extends NavigationPartProps
MemberTypeSummary

ObjectButtonPartPropsinterfaceSource ↗

The props of a part whose control is a button: the colour parts and the toggle parts. With asChild, the one child of the default slot becomes the button.

interface ObjectButtonPartProps extends ObjectControlProps
MemberTypeSummary
asChild?booleanRenders the one child of the default slot as the button, with the part's props merged in.
children?DocxEditorChildrenWith `asChild`, the element that becomes the button. Pass it in the default slot.
icon?DocxEditorChildrenReplaces the slot's icon in the compact variant.

ObjectControlPropsinterfaceSource ↗

The props every shape and chart part takes.

interface ObjectControlProps
MemberTypeSummary
className?stringA class name added to the part's root.
hidden?booleanRenders nothing, so a toolbar override can remove the slot.
label?stringReplaces the label, which defaults to the slot's translated name.
variant?ObjectControlVariantDefault `field`, or `compact` inside `DocxEditorToolbar`.

ObjectControlStateinterfaceSource ↗

What useObjectControl returns for every slot.

interface ObjectControlState<K extends ObjectSlotId>
MemberTypeSummary
disabledReasonComputedRef<string | null>Why the control is disabled, translated, or null.
execute(value: ObjectSlotValueMap[K], options?: EditorExecOptions) => ExecResultRun the slot with `value`, as `runToolbarCommand` does.
isActiveComputedRef<boolean>Whether a toggle is on, or whether the object shows the property.
isEnabledComputedRef<boolean>
labelComputedRef<string>The slot's translated name.
optionsComputedRef<readonly ObjectSlotValueMap[K][]>The values a list slot offers, in list order; empty for other slots.
slotIdK
valueComputedRef<ObjectSlotReadValueMap[K] | null>The value the object shows now, typed for the slot, or null when nothing is selected, the object shows several values, or the slot has no single value (`chart.seriesColor`, `chart.data`).

ObjectToggleControlinterfaceSource ↗

The member a toggle slot adds: a run with no value turns the element on or off.

interface ObjectToggleControl
MemberTypeSummary
toggle(options?: EditorExecOptions) => ExecResult

OutlineHeadingIteminterfaceSource ↗

interface OutlineHeadingItem
MemberTypeSummary
depthnumber
headingOutlineHeading$1

PageIndicatorPropsinterfaceSource ↗

interface PageIndicatorProps
MemberTypeSummary
currentPagenumber
totalPagesnumber
visibleboolean

PageSetupDialogFieldsinterfaceSource ↗

Page Setup draft values in twips.

interface PageSetupDialogFields
MemberTypeSummary
marginBottomnumber
marginLeftnumber
marginRightnumber
marginTopnumber
orientation'portrait' | 'landscape'
pageHeightnumber
pageWidthnumber
scope'document' | 'section'

PageSetupUpdateinterfaceSource ↗

interface PageSetupUpdate
MemberTypeSummary
marginBottomTwips?number
marginLeftTwips?number
marginRightTwips?number
marginTopTwips?number
orientation?'portrait' | 'landscape'
pageHeightTwips?number
pageWidthTwips?number
scope?'document' | 'section'

PaginatedDocxEditorHandleinterfaceSource ↗

interface PaginatedDocxEditorHandle
MemberTypeSummary
focus
formatting
navigate
redo
saveSave pending form input. Throws for invalid values or an active edit.
sectionProperties
selectAll
setParagraphProperty`options.mergeAttributes` keeps the attributes the call does not name — see the React twin.
setRunProperty
toggleRunProperty
type
undo

PaginatedDocxEditorPropsinterfaceSource ↗

interface PaginatedDocxEditorProps
MemberTypeSummary
className?string
documentFontFamily?string
measurer?TextMeasurer
onError?(reason: string, detail?: string) => void
onStateChange?(state: PaginatedSurfaceState) => void
ref?Ref<PaginatedDocxEditorHandle>
scale?number
sourceUint8Array

PaginatedDocxEditorShellPropsinterfaceSource ↗

interface PaginatedDocxEditorShellProps
MemberTypeSummary
className?string
colorMode?'light' | 'dark'
documentFontFamily?string
documentName?string
measurer?TextMeasurer
onError?(reason: string, detail?: string) => void
onSave?(bytes: Uint8Array) => void
onStateChange?(state: PaginatedSurfaceState) => void
onZoomChange?(zoom: number) => void
ref?Ref<PaginatedDocxEditorHandle>
renderTitleBarLeft?() => DocxEditorChildren
renderTitleBarRight?() => DocxEditorChildren
scale?number
sourceUint8Array

ParagraphStyleItemPropsinterfaceSource ↗

interface ParagraphStyleItemProps extends ParagraphStylePartProps
MemberTypeSummary
valuestring

ParagraphStyleNamespaceinterfaceSource ↗

interface ParagraphStyleNamespace
MemberTypeSummary
(member-0)
Contenttypeof ParagraphStyleContent
docxSlot'styles.style'
Itemtypeof ParagraphStyleItem
Triggertypeof ParagraphStyleTrigger

ParagraphStyleOptioninterfaceSource ↗

interface ParagraphStyleOption
MemberTypeSummary
namestring
preview{ readonly fontFamily: string | null; readonly fontSizePt: number | null; readonly bold: boolean; readonly italic: boolean; readonly color: string | null; }
styleIdstring

ParagraphStylePartPropsinterfaceSource ↗

interface ParagraphStylePartProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildren
className?string

ParagraphStylePropsinterfaceSource ↗

interface ParagraphStyleProps extends ParagraphStylePartProps
MemberTypeSummary
hidden?boolean

ProvideDocxEditorResultinterfaceSource ↗

interface ProvideDocxEditorResult
MemberTypeSummary
DocxEditorRoottypeof DocxEditorRoot
editorRefReturnType<typeof useDocxEditor>
rootListenersDocxEditorRootListeners
rootPropsShallowRef<Omit<DocxEditorRootProps, keyof DocxEditorRootListeners>>

ReviewGutterinterfaceSource ↗

Scroll-container reservations on each inline edge.

interface ReviewGutter
MemberTypeSummary
inlineEndnumber
inlineStartnumber

ReviewGutterInputinterfaceSource ↗

Inputs for [reviewGutter](reviewGutter).

interface ReviewGutterInput
MemberTypeSummary
docked?boolean
inlineStartReservation?number
openboolean
pageWidthPxnumber
scroll?boolean`overflow: 'scroll'`: the full column stands even when it does not fit.
viewportWidthnumber

ReviewRailRegistryinterfaceSource ↗

interface ReviewRailRegistry
MemberTypeSummary
gutters?numberClaims registered through `reserveGutter`: columns that need the review gutter but serve no comment draft. The viewport reserves the gutter while `mounted + gutters` is above zero.
mountednumberReview columns registered through `register`: the packaged rail, and any column that serves comment drafts. The Add comment controls in the toolbar and the context menu appear only while this is above zero.
register() => () => voidRegister a review column that serves comment drafts. Also reserves the review gutter. Call it on mount, together with `registerCommentDraft`. Returns the unregister function.
registerCommentDraft(handler: () => void) => () => voidReceive the Add comment requests. The handler takes no arguments: it reads the selection's position with `getSelectionPlacement`, pins the selection with `retainSelection`, and opens the pane. Release the pin with `releaseSelection` when the draft closes or is cancelled. The most recently registered handler receives each request. Do not register while the column cannot open a draft, such as in viewing mode: a request counts as served once a handler runs. While a handler is registered, the `review.addComment` control is enabled. Returns the unregister function.
requestCommentDraft() => booleanSend an Add comment request through the `review.addComment` control. The most recent registration receives it: a handler registered here, or one registered with `useCommentDraftRequest`. Returns `true` when a handler ran, even if it then opened nothing, and `false` when the control is disabled.
reserveGutter?() => () => voidReserve the review gutter without showing comment controls. Returns the release.

ScopedChromeAnchorinterfaceSource ↗

interface ScopedChromeAnchor
MemberTypeSummary
refDocxEditorRefCallback<HTMLDivElement>
styleShallowRef<CSSProperties>

SelectionFormattinginterfaceSource ↗

interface SelectionFormatting
MemberTypeSummary
alignment?ParagraphAlignment
bidi?boolean
bold?boolean
color?string
fontFamily?string
fontSize?number
highlight?string
indentLeft?number
italic?boolean
lineSpacing?number
listState?ListState
strike?boolean
styleId?string
subscript?boolean
superscript?boolean
underline?boolean

SlotPropsinterfaceSource ↗

interface SlotProps
MemberTypeSummary
children?DocxEditorChildren
class?string
className?string
ref?unknown
style?CSSProperties

SplitCellDialogFieldsinterfaceSource ↗

The Split cells dialog's draft, as typed.

interface SplitCellDialogFields
MemberTypeSummary
columnsstringThe number of columns, as typed.
rowsstringThe number of rows, as typed.

TableBorderColorNamespaceinterfaceSource ↗

interface TableBorderColorNamespace extends TableChromePartComponent
MemberTypeSummary
Content(props: TableChromePartProps) => DocxEditorChildren
docxSlot'table.borderColor'
Item(props: TableChromeItemProps) => DocxEditorChildren
Main(props: TableChromePartProps) => DocxEditorChildren
Trigger(props: TableChromePartProps) => DocxEditorChildren

TableBorderStyleNamespaceinterfaceSource ↗

interface TableBorderStyleNamespace extends TableChromePartComponent
MemberTypeSummary
Content(props: TableChromePartProps) => DocxEditorChildren
docxSlot'table.borderStyle'
Item(props: TableChromeItemProps) => DocxEditorChildren
Trigger(props: TableChromePartProps) => DocxEditorChildren

TableBorderTargetNamespaceinterfaceSource ↗

interface TableBorderTargetNamespace extends TableChromePartComponent
MemberTypeSummary
Content(props: TableChromePartProps) => DocxEditorChildren
docxSlot'table.borderTarget'
Item(props: TableChromeItemProps) => DocxEditorChildren
Trigger(props: TableChromePartProps) => DocxEditorChildren

TableBorderWidthNamespaceinterfaceSource ↗

interface TableBorderWidthNamespace extends TableChromePartComponent
MemberTypeSummary
Content(props: TableChromePartProps) => DocxEditorChildren
docxSlot'table.borderWidth'
Item(props: TableChromeItemProps) => DocxEditorChildren
Trigger(props: TableChromePartProps) => DocxEditorChildren

TableCellFillNamespaceinterfaceSource ↗

interface TableCellFillNamespace extends TableChromePartComponent
MemberTypeSummary
Content(props: TableChromePartProps) => DocxEditorChildren
docxSlot'table.cellFill'
Item(props: TableChromeItemProps) => DocxEditorChildren
Main(props: TableChromePartProps) => DocxEditorChildren
Trigger(props: TableChromePartProps) => DocxEditorChildren

TableChromeItemPropsinterfaceSource ↗

interface TableChromeItemProps extends TableChromePartProps
MemberTypeSummary
valuestring

TableChromePartComponentinterfaceSource ↗

interface TableChromePartComponent extends ToolbarSlotPartComponent
MemberTypeSummary
Content(props: TableChromePartProps) => DocxEditorChildren
docxSlotTableChromeSlotId
Item(props: TableChromeItemProps) => DocxEditorChildren
Trigger(props: TableChromePartProps) => DocxEditorChildren

TableChromePartPropsinterfaceSource ↗

interface TableChromePartProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildren
className?string
hidden?boolean

TextFormFieldDialogFieldsinterfaceSource ↗

Editable Field Options draft.

interface TextFormFieldDialogFields
MemberTypeSummary
defaultTextstring
enabledboolean
formatstring
maxLengthnumber
typestring

ToolbarActionPropsinterfaceSource ↗

interface ToolbarActionProps
MemberTypeSummary
active?boolean
asChild?boolean
children?DocxEditorChildren
class?string
className?string
disabled?boolean
disabledReason?string
icon?DocxEditorChildren
labelstring
onSelect?() => void

ToolbarAlignmentComponentinterfaceSource ↗

interface ToolbarAlignmentComponent
MemberTypeSummary
docxSlot'alignment'

ToolbarButtonPropsinterfaceSource ↗

interface ToolbarButtonProps
MemberTypeSummary
asChild?boolean
children?DocxEditorChildren
class?string
className?string
hidden?booleanRender nothing: inside the default arrangement this removes the slot in place. A named part is shorthand for the slot override, so `<Toolbar.Bold hidden />` is `<Toolbar.Slot slotId="text.bold" hidden />`.
icon?DocxEditorChildren
slot?ChromeSlotId
slotId?ChromeSlotIdThe chrome slot this button drives (`'text.bold'`, `'history.undo'`, ...). A button with neither `slotId` nor the deprecated `slot` renders nothing, with a development warning.

ToolbarContextValueinterfaceSource ↗

interface ToolbarContextValue
MemberTypeSummary
onSave(() => void) | undefined
tToolbarTranslate | undefined

ToolbarPartComponentinterfaceSource ↗

interface ToolbarPartComponent
MemberTypeSummary
docxSlotChromeSlotId

ToolbarPropsinterfaceSource ↗

Deprecated. Use `DocxEditor.Toolbar` from the composition layer instead.

Props for the deprecated formatting rail.

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

ToolbarSeparatorPropsinterfaceSource ↗

interface ToolbarSeparatorProps
MemberTypeSummary
class?string
className?string

ToolbarSlotPartComponentinterfaceSource ↗

interface ToolbarSlotPartComponent
MemberTypeSummary
docxSlotChromeSlotId

ToolbarSlotPartPropsinterfaceSource ↗

interface ToolbarSlotPartProps
MemberTypeSummary
class?string
className?string
hidden?booleanRender nothing: inside the default arrangement this removes the slot in place. A named part is shorthand for the slot override, so `<Toolbar.Bold hidden />` is `<Toolbar.Slot slotId="text.bold" hidden />`.

UseBookmarkDialogReturninterfaceSource ↗

Bookmark dialog draft and actions. apply is Add.

interface UseBookmarkDialogReturn extends UseDialogReturn<BookmarkDialogFields>
MemberTypeSummary
canDeleteComputedRef<boolean>Whether Delete and Go To can act on the typed name.
canGoToComputedRef<boolean>
duplicatesComputedRef<number>How many other places carry the typed bookmark's name, which collaborators adding one name offline can leave. 0 for a name with one bookmark, or no bookmark.
goTo
keepFirstKeep the first bookmark with the typed name and remove its copies.
remove
rowsComputedRef<readonly BookmarkSummary[]>The bookmarks the list shows, in the chosen order.

UseBookmarksReturninterfaceSource ↗

What useBookmarks returns.

interface UseBookmarksReturn
MemberTypeSummary
bookmarksReadonly<ShallowRef<readonly BookmarkSummary[]>>Every bookmark, hidden ones included, in document order. Reference-stable while unchanged.
goTo(name: string) => ExecResultSelect the bookmark and scroll to it.
insert(name: string) => ExecResultBookmark the selection under `name`. A bookmark with the name moves.
isWritableReadonly<ShallowRef<boolean>>Whether the document accepts bookmark edits now. Go To works either way.
keepFirst(name: string) => ExecResultKeep the first bookmark with this name and remove its copies, which collaborators adding one name offline can leave. The selection does not move.
remove(name: string) => ExecResultDelete the bookmark with this name. The text stays.

UseCompareDocumentsDialogReturninterfaceSource ↗

Compare documents draft and actions.

interface UseCompareDocumentsDialogReturn extends UseDialogReturn<CompareDocumentsDialogValues>
MemberTypeSummary
busyReadonly<Ref<boolean>>True while the chosen file is read and compared. `apply()` does nothing while it is true, so a second press cannot start a second compare.
cancelableReadonly<Ref<boolean>>Whether `cancel()` stops a running compare. True when the editor compares in the background.
noticeReadonly<Ref<string | undefined>>A message that is not an error, such as that the documents have no differences.
originalHasTrackedChangesReadonly<Ref<boolean>>Whether the open document has tracked changes, which the compare treats as accepted.
progressReadonly<Ref<CompareDocumentsProgress | null>>How far the running compare is, when the editor compares in the background (see `reviewModule({ compareWorker })`). Null when no compare runs or none reports its steps.

UseContentControlResultinterfaceSource ↗

interface UseContentControlResult
MemberTypeSummary
canRemoveComputedRef<boolean>
canSetValueComputedRef<boolean>
closeInspector() => void
controlComputedRef<ContentControlInspectorState | null>
controlsComputedRef<readonly ContentControlSummary[]>
formFillComputedRef<boolean>
inspectorOpenComputedRef<boolean>
openInspector() => void
remove() => ExecResult
removeDisabledReasonComputedRef<string | null>
setFormFill(on: boolean) => void
setShowAll(show: boolean) => void
setValue(value: string) => ExecResult
setValueDisabledReasonComputedRef<string | null>
showAllComputedRef<boolean>
toggleFormFill() => void
toggleInspector() => void
toggleShowAll() => void

UseContentControlWidgetResultinterfaceSource ↗

The draft state a content-control value pop-up renders over.

Read it from useContentControlWidget() inside DocxEditorContentControlWidget. value is the draft; apply() commits it through the session, which the engine validates. The calendar members drive the date picker: calendar is the month in view, built for the session's locale. Reactive members are refs.

interface UseContentControlWidgetResult
MemberTypeSummary
acceptstringPicture sessions: the image types `replaceImage` takes, as a file input `accept` list.
applyCommit `value`, or an explicit one; false when the engine refused it.
applyDateText
calendarReadonly<Ref<CalendarMonth>>
cancel
dateTextReadonly<Ref<string>>Numeric regional date entry, separate from the ISO value.
focusDayMove keyboard focus to a day, turning the month if it lies outside the view.
focusIsoReadonly<Ref<string | null>>The day keyboard focus should land on after the grid renders, if any.
isEnabledReadonly<Ref<boolean>>The engine still accepts a write for this control.
itemsReadonly<Ref<readonly ContentControlWidgetEntry[]>>
kindReadonly<Ref<ContentControlWidgetSession['kind']>>
listIdstringID shared by the combo input and listbox.
listNavigationContentControlListNavigationShared typeahead and roving-focus behavior for replacement lists.
nextMonth
previousMonth
refusedReadonly<Ref<boolean>>The last `apply()` was refused by the engine.
replaceImagePicture sessions: replace the control's image from a file or its bytes. The engine checks the format and size; false (and `refused`) when it declines or the session is not a picture session.
selectDayCommit one calendar day (`YYYY-MM-DD`).
selectTodayCommit the current local date.
sessionReadonly<Ref<ContentControlWidgetSession>>
setDateText
setValue
showMonthJump to a month without committing. Month is zero-based; year is 100–9999.
valueReadonly<Ref<string>>

UseDialogReturninterfaceSource ↗

Draft state and actions for a dialog.

interface UseDialogReturn<T extends object>
MemberTypeSummary
apply
cancel
errorsReadonly<Ref<Readonly<Partial<Record<keyof T | 'form', string>>>>>
isEnabledReadonly<Ref<boolean>>
reset
setValue
valuesReadonly<Ref<T>>

UseDocumentOutlineResultinterfaceSource ↗

interface UseDocumentOutlineResult
MemberTypeSummary
goTo(blockId: string) => void
headingsComputedRef<readonly OutlineHeading$1[]>
isEmptyComputedRef<boolean>
itemsComputedRef<readonly OutlineHeadingItem[]>
selectedBlockIdComputedRef<string | null>

UseDocumentSearchOptionsinterfaceSource ↗

How useDocumentSearch behaves.

interface UseDocumentSearchOptions
MemberTypeSummary
highlight?DocumentSearchHighlightWhich matches to mark: every match with the active one emphasized (`'all'`), only the active match (`'active'`), or none (`'none'`). Default: `'all'`.

UseDocumentSearchResultinterfaceSource ↗

What useDocumentSearch answers.

interface UseDocumentSearchResult
MemberTypeSummary
activeIndexComputedRef<number>Index of the current match, or `-1` before any navigation.
activeMatchComputedRef<TextMatch | null>The current match, or `null` before any navigation.
clear() => voidEmpty the query and drop the results, without changing the selection.
find(query: string, options?: DocumentSearchFindOptions) => readonly TextMatch[]Search now and return the matches. `selectFirst` selects the first match; `highlight` highlights the results until `clear()`, even without this hook's own request.
goTo(index: number) => booleanSelect a match by index and bring its page into view. Focus stays where it is, so a search box keeps it. Returns false for an index without a match.
isPendingComputedRef<boolean>Whether a typed query is waiting for its debounce to elapse.
matchCaseComputedRef<boolean>
matchesComputedRef<readonly TextMatch[]>Matches for the last searched query, in document order.
next() => booleanNext / previous match, wrapping at the ends the way Word's arrows do.
previous() => boolean
queryComputedRef<string>The text in the search box, updated synchronously as the user types.
setMatchCase(value: boolean) => void
setQuery(query: string) => voidUpdate the typed query. The search runs after a short debounce.
setWholeWord(value: boolean) => void
truncatedComputedRef<boolean>The search stopped at its cap with matches still ahead, so a count reads "2000+".
wholeWordComputedRef<boolean>

UseDocxSourceOptionsinterfaceSource ↗

interface UseDocxSourceOptions
MemberTypeSummary
fetchOptions?RequestInit
fonts?DocxFontsSource

UseDocxSourceResultinterfaceSource ↗

interface UseDocxSourceResult
MemberTypeSummary
documentComputedRef<Uint8Array | undefined>
errorComputedRef<Error | null>
fontsComputedRef<FontConfiguration | FontResolver | undefined>
isLoadingComputedRef<boolean>

UseEditorColorModeReturninterfaceSource ↗

What [useEditorColorMode](useEditorColorMode) returns.

interface UseEditorColorModeReturn
MemberTypeSummary
colorModeComputedRef<ResolvedColorMode>The resolved theme: `'dark'` or `'light'`. Updates when `colorMode` or the OS setting changes.

UseFontFamilyResultinterfaceSource ↗

interface UseFontFamilyResult
MemberTypeSummary
isEnabledComputedRef<boolean>
optionsComputedRef<readonly string[]>
setValue(family: string) => void
valueComputedRef<string | null>

UseGoToBookmarkOptionsinterfaceSource ↗

How useGoToBookmark is configured.

interface UseGoToBookmarkOptions
MemberTypeSummary
enabled?booleanWhether to read the document's bookmarks. Defaults to `true`. Pass `false` while your UI is hidden: the list is then empty and the document is not read on each change. Pass the options as a getter or a ref to change it; the list is read again when it turns true.

UseGoToBookmarkReturninterfaceSource ↗

What useGoToBookmark returns.

interface UseGoToBookmarkReturn
MemberTypeSummary
activeIndexComputedRef<number>Index into `rows` of the highlighted row, or -1 when none is. The highlight follows its bookmark when rows move, and clears when that bookmark goes away.
bookmarksReadonly<ShallowRef<readonly BookmarkSummary[]>>Every bookmark the document declares, hidden ones included. Empty while disabled.
go(name?: string) => ExecResultJump to `name`, or else to what the name box means: the highlighted row, the bookmark named exactly as typed, or the first row offered. Answers the `goToBookmark` result and sets `problem` when it is refused.
move(delta: number) => voidMove the highlight by `delta` rows, wrapping at either end.
problemReadonly<ShallowRef<GoToBookmarkProblem | null>>Why the last jump did not happen, or null. Cleared when the query changes.
problemNameReadonly<ShallowRef<string>>The name the last refused jump asked for, for a message. Empty when nothing was typed.
queryReadonly<ShallowRef<string>>The text in the name box. Use `setQuery` to change it.
rowsComputedRef<readonly BookmarkSummary[]>The bookmarks offered for the query: names that start with it first.
setActiveIndex(index: number) => voidHighlight the row at `index` of `rows`, or none with -1.
setQuery(query: string) => voidChange the text. The highlight goes back to none.
setShowHidden(showHidden: boolean) => void
setSortBy(sortBy: BookmarkSortOrder) => void
showHiddenReadonly<ShallowRef<boolean>>Whether hidden bookmarks (names starting with an underscore) are offered.
sortByReadonly<ShallowRef<BookmarkSortOrder>>

UseHighlightsReturninterfaceSource ↗

The value of the ref that [useHighlights](useHighlights) returns: the counts of the last application, and refresh to run the source again.

interface UseHighlightsReturn extends HighlightResult
MemberTypeSummary
refresh() => voidRun the source again, for changes Vue and the editor cannot see: a word added to a plain dictionary object, the caret leaving the word being typed, or an asynchronous result arriving in a cache that is not reactive. An array source applies again.

UseHistoryGroupReturninterfaceSource ↗

interface UseHistoryGroupReturn
MemberTypeSummary
options() => EditorExecOptions
ref(element: HTMLElement | null) => void

UseHyperlinkPopupResultinterfaceSource ↗

interface UseHyperlinkPopupResult
MemberTypeSummary
beginEdit() => void
close() => void
commitEdit() => boolean
copy() => Promise<boolean>
open(link?: SurfaceHyperlink | null, anchor?: HyperlinkPopupAnchor | null) => void
openAtCaret() => void
openTarget() => boolean
setText(text: string) => void
setUrl(url: string) => void
stateComputedRef<HyperlinkPopupState>

UseNavigationPaneOptionsinterfaceSource ↗

interface UseNavigationPaneOptions
MemberTypeSummary
defaultOpen?boolean
defaultTab?NavigationTab$1
onOpenChange?(open: boolean) => void
onTabChange?(tab: NavigationTab$1) => void
open?boolean
paneWidth?number
tab?NavigationTab$1

UseNavigationPaneResultinterfaceSource ↗

interface UseNavigationPaneResult
MemberTypeSummary
openComputedRef<boolean>
overlayComputedRef<boolean>Whether the open pane covers the page instead of moving it. True on a viewport too narrow to show a readable page beside the pane (see `NAVIGATION_PANE_MIN_PAGE_ROOM`); `shift` is then 0, and `DocxEditorNavigation` closes after a heading or result is picked.
paneWidthComputedRef<number>
setOpen(open: boolean) => void
setTab(tab: NavigationTab$1) => void
shiftComputedRef<number>
tabComputedRef<NavigationTab$1>
toggle() => void

UseOpenFailureOptionsinterfaceSource ↗

Options for [useOpenFailure](useOpenFailure).

interface UseOpenFailureOptions
MemberTypeSummary
t?TFunctionTranslator override; defaults to the ambient locale context.

UseOpenFailureReturninterfaceSource ↗

The current refused open, with the packaged message and a way to dismiss it.

interface UseOpenFailureReturn
MemberTypeSummary
dismissHide this refusal. A later refusal shows again, even for the same file. Pass the failure your UI showed, such as from a toast's close callback, so a late call cannot hide a newer refusal. It also works as a click handler directly, such as `onClick={dismiss}`: an event hides the refusal on screen.
failureComputedRef<DocumentOpenFailure | null>The refused open, or `null` when there is none or the person dismissed it.
messageComputedRef<string | null>The packaged, translated message for [UseOpenFailureReturn.failure](UseOpenFailureReturn.failure).

UsePageSetupDialogReturninterfaceSource ↗

Page Setup draft state and actions.

interface UsePageSetupDialogReturn extends UseDialogReturn<PageSetupDialogFields>

UsePageSetupReturninterfaceSource ↗

interface UsePageSetupReturn
MemberTypeSummary
apply(update: PageSetupUpdate) => boolean
isEnabledComputedRef<boolean>
pageSetupComputedRef<PageSetup | null>

UseParagraphDialogReturninterfaceSource ↗

Paragraph draft state, mixed values, and actions.

interface UseParagraphDialogReturn extends UseDialogReturn<ParagraphDialogFields>
MemberTypeSummary
mixedReadonly<Ref<ParagraphDialogMixed>>

UseParagraphFormatReturninterfaceSource ↗

What useParagraphFormat returns.

interface UseParagraphFormatReturn
MemberTypeSummary
apply(update: ParagraphFormatUpdate) => boolean
formatComputedRef<ParagraphFormatRead | null>
isEnabledComputedRef<boolean>

UseParagraphIndentReturninterfaceSource ↗

interface UseParagraphIndentReturn
MemberTypeSummary
apply(update: IndentUpdate) => boolean
indentComputedRef<IndentFormatting | null>
isEnabledComputedRef<boolean>

UseParagraphStyleResultinterfaceSource ↗

interface UseParagraphStyleResult
MemberTypeSummary
isEnabledComputedRef<boolean>
optionsComputedRef<readonly ParagraphStyleOption[]>
setValue(styleId: string) => void
valueComputedRef<string | null>

UseRevisionMarkupDialogReturninterfaceSource ↗

Viewer markup draft state and actions.

interface UseRevisionMarkupDialogReturn extends UseDialogReturn<ResolvedRevisionMarkup>
MemberTypeSummary
reset

UseSelectedChartReturninterfaceSource ↗

What useSelectedChart returns.

interface UseSelectedChartReturn
MemberTypeSummary
canEditDataComputedRef<boolean>Whether a `setChartData` command can run now.
canEditFormatComputedRef<boolean>Whether `setChartType`, `setChartFormat`, and `setChartColor` can run now.
chartComputedRef<SelectedChartState | null>The selected chart, or null when no single chart is selected.
dataComputedRef<ChartData | null>The categories and series, or null when there is no chart or they cannot be read.
dataDisabledReasonComputedRef<string | null>Why the data cannot change, translated, or null when it can.
editData(change: ChartPaneChange) => ExecResultApply one checked data change, as the packaged pane does: editData( type: 'value', series: 0, category: 1, text: '4.5' ). Text that is not a number refuses, with the reason as a translation key. One undo step.
execute(command: SelectedChartCommand) => ExecResultRun a chart edit on the chart this composable shows, as `editor.exec` does, without the `drawingNodeId`: `execute({ type: 'setChartType', chartType: 'line' })`.
formatComputedRef<ChartFormat | null>The type, elements, and colors, or null when there is no chart or they cannot be read.
formatDisabledReasonComputedRef<string | null>Why the type and elements cannot change, translated, or null when they can.
readReasonComputedRef<string | null>Why `data` or `format` is null for a selected chart, translated.

UseSelectedShapeReturninterfaceSource ↗

What useSelectedShape returns.

interface UseSelectedShapeReturn
MemberTypeSummary
canEditFillComputedRef<boolean>Whether `setShapeFill` can run now.
canEditOutlineComputedRef<boolean>Whether `setShapeOutline` can run now.
canEditTransparencyComputedRef<boolean>Whether the transparency of a solid fill can change now.
drawingNodeIdComputedRef<string | null>The drawing node id of the selected shape, text box, line, or group, or null.
edit(change: ShapePaneChange) => ExecResultApply one checked change, as the packaged pane does: edit( type: 'fillColor', color: 'accent1' )` or `edit( type: 'outlineWidth', text: '3' ). A theme color resolves through the document's theme. Text the pane cannot read refuses with a translated reason. One undo step.
execute(command: SelectedShapeCommand) => ExecResultRun a fill or outline edit on the shape this composable shows, as `editor.exec` does, without the `drawingNodeId`: execute( type: 'setShapeOutline', color: '0070C0', widthPt: 3 ). A refusal's reason is translated.
fillDisabledReasonComputedRef<string | null>Why the fill cannot change, translated, or null when it can.
formatComputedRef<ShapeFormatState | null>The fill and outline, or null when no shape with a fill or outline is selected.
memberIdComputedRef<string | null>The shape selected inside the group by a second press, or null.
outlineDisabledReasonComputedRef<string | null>Why the outline cannot change, translated, or null when it can.
transparencyDisabledReasonComputedRef<string | null>Why the transparency cannot change, translated, or null when it can.

UseSplitCellDialogReturninterfaceSource ↗

Split cells dialog draft and actions. apply is Split.

interface UseSplitCellDialogReturn extends UseDialogReturn<SplitCellDialogFields>
MemberTypeSummary
limitsSplitCellLimits | nullThe most columns and rows the cell splits into, or null outside a cell that splits.

UseTextFormFieldDialogReturninterfaceSource ↗

Field Options draft state and actions.

interface UseTextFormFieldDialogReturn extends UseDialogReturn<TextFormFieldDialogFields>

UseWatermarkDialogReturninterfaceSource ↗

Watermark dialog draft and actions.

interface UseWatermarkDialogReturn extends UseDialogReturn<WatermarkDialogFields>

UseWatermarkReturninterfaceSource ↗

What useWatermark returns.

interface UseWatermarkReturn
MemberTypeSummary
apply(watermark: Watermark | null) => ExecResultSet the watermark as one undo step. Null removes it.
isEnabledComputedRef<boolean>Whether the engine can write a watermark right now (mounted, editable).
read() => Watermark | nullThe full current watermark, with picture bytes, through `query({ type: 'watermark' })`.
watermarkReadonly<ShallowRef<WatermarkState | null>>The document's watermark, or null when it has none. Reference-stable while unchanged.

UseZoomResultinterfaceSource ↗

interface UseZoomResult
MemberTypeSummary
auto() => void
canZoomInComputedRef<boolean>
canZoomOutComputedRef<boolean>
fitToWidth() => void
isFitComputedRef<boolean>
levelsreadonly number[]
modeComputedRef<ZoomMode>
reset() => void
setMode(mode: ZoomMode | 'auto') => void
setZoom(zoom: number) => void
zoomComputedRef<number>
zoomIn() => void
zoomOut() => void

VerticalRulerPropsinterfaceSource ↗

interface VerticalRulerProps
MemberTypeSummary
className?string
editable?boolean
onBottomMarginChange?(marginTwips: number) => void
onMarginDragEnd?() => void
onTopMarginChange?(marginTwips: number) => void
pageSetup?RulerPageSetup | null
style?CSSProperties
unit?'inch' | 'cm'
zoom?number

WatermarkDialogFieldsinterfaceSource ↗

The Watermark dialog draft. Transparency is 0 to 1, color is RRGGBB.

interface WatermarkDialogFields
MemberTypeSummary
boldboolean
colorstring
fontFamilystring
fontSizePtnumber | nullPoints. Null is Auto.
imageDataUint8Array | nullThe picture bytes, or null when no picture is chosen.
imageNamestring | nullThe chosen file name. Null for no picture or for the document's current picture.
italicboolean
kindWatermarkDialogKind
layoutWatermarkDialogLayout
scalenumber | nullA factor of the picture's natural size. Null is Auto.
textstring
transparencynumber
washoutboolean

Type aliases (48)

ChartPartPropstypeSource ↗

Props of a chart part.

type ChartPartProps = ObjectControlProps;

ChartTogglePartPropstypeSource ↗

Props of a chart toggle part: it also takes icon and asChild.

type ChartTogglePartProps = ObjectButtonPartProps;

ChromeTranslatetypeSource ↗

type ChromeTranslate = (key: string, params?: Record<string, string | number>) => string;

ColorPickerCompoundtypeSource ↗

The parts of the ColorPicker compound.

type ColorPickerCompound = typeof ColorPicker;

ColorPickerValuetypeSource ↗

The value of a picker: a pick, none for No colour, or null when the target is mixed.

type ColorPickerValue = ColorPick | 'none' | null;

ContentControlLocktypeSource ↗

type ContentControlLock = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';

ContentControlSlotIdtypeSource ↗

type ContentControlSlotId = (typeof CONTENT_CONTROL_SLOTS)[keyof typeof CONTENT_CONTROL_SLOTS];

DocumentStyleSummarytypeSource ↗

One entry of Editor.getDocumentStyles() — the engine's document-style summary the picker consumes. Derived from the contract, not re-declared.

type DocumentStyleSummary = ReturnType<Editor['getDocumentStyles']>[number];

DocxEditorChildrentypeSource ↗

Slot and icon content in public component props.

Vue hosts pass [VNode](VNode). React hosts pass [ReactNode](https://react.dev/reference/react/ReactNode) through the paired [DocxEditorChildren](DocxEditorChildren) alias in @docx-editor.dev/react.

type DocxEditorChildren = VNode;

DocxEditorOpenFailureMessagetypeSource ↗

A message for the open-failure dialog: text, content, or a function of the failure. It renders in a div, so block content is valid.

type DocxEditorOpenFailureMessage = string | DocxEditorChildren | ((failure: DocumentOpenFailure) => string | DocxEditorChildren);

DocxEditorPopuptypeSource ↗

A render callback for an automatically hosted popup. False disables the popup.

type DocxEditorPopup<P extends object> = false | ((props: P) => DocxEditorChildren | null);

DocxEditorRefCallbacktypeSource ↗

type DocxEditorRefCallback<T> = (node: T | null) => void;

DocxFontOrigintypeSource ↗

type DocxFontOrigin = FontOrigin | (() => DocxFontsInput | Promise<DocxFontsInput>);

DocxFontsInputtypeSource ↗

type DocxFontsInput = FontConfiguration | FontConfigurationFragment;

DocxFontsSourcetypeSource ↗

type DocxFontsSource = DocxFontOrigin | readonly DocxFontOrigin[];

DocxSourcetypeSource ↗

type DocxSource = string | URL | Uint8Array | ArrayBuffer;

EditorModetypeSource ↗

type EditorMode = 'edit' | 'view' | 'suggesting';

FontsInputtypeSource ↗

type FontsInput = FontConfiguration | FontConfigurationFragment | FontResolver | Promise<FontConfiguration | FontConfigurationFragment | undefined> | undefined;

FormattingActiontypeSource ↗

type FormattingAction = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'superscript' | 'subscript' | 'clearFormatting' | 'bulletList' | 'numberedList' | 'indent' | 'outdent' | 'insertLink' | 'setRtl' | 'setLtr' | {
    type: 'fontFamily';
    value: string;
} | {
    type: 'fontSize';
    value: number;
} | {
    type: 'textColor';
    value: ColorValue | string;
} | {
    type: 'highlightColor';
    value: string;
} | {
    type: 'alignment';
    value: ParagraphAlignment;
} | {
    type: 'lineSpacing';
    value: number;
} | {
    type: 'applyStyle';
    value: string;
};

GoToBookmarkProblemtypeSource ↗

Why a Go To jump did not happen: nothing was typed, no bookmark has the name, or the editor refused the jump for another reason (it is not ready, or the story could not be shown).

type GoToBookmarkProblem = 'empty' | 'notFound' | 'failed';

HeaderFooterStatetypeSource ↗

type HeaderFooterState = Exclude<ReturnType<Editor['getHeaderFooterState']>, null>;

HyperlinkPopupModetypeSource ↗

type HyperlinkPopupMode = 'closed' | 'reading' | 'editing';

ListTypetypeSource ↗

Pure list-state helpers used by both adapter toolbars to track whether the selection is in a bullet/numbered list and at what indent level. Lifted from packages/react/src/components/ui/ ListButtons.tsx so the React + Vue toolbars share identical state-mutation logic.

type ListType = 'bullet' | 'numbered' | 'none';

MaybeRefOrGettertypeSource ↗

Reactive input accepted by Vue composables.

type MaybeRefOrGetter<T> = T | Ref<T> | (() => T);
type MenuId = ChromeMenuId | (string & {});
type MenuReviewersProps = {
    className?: string;
    hidden?: boolean;
};
type NavigationTab$1 = 'headings' | 'find' | 'goto';

NormalizedImagePayloadtypeSource ↗

type NormalizedImagePayload = {
    readonly ok: true;
    readonly bytes: Uint8Array;
    readonly mime: SupportedImageMime;
    readonly widthPoints: number;
    readonly heightPoints: number;
} | {
    readonly ok: false;
    readonly reasonKey: string;
};

NotePropertiesStatetypeSource ↗

type NotePropertiesState = Exclude<ReturnType<Editor['getNotePropertiesState']>, null>;

ObjectControlVarianttypeSource ↗

How a part renders: with a visible label (field), or as a toolbar control (compact).

type ObjectControlVariant = 'field' | 'compact';

ObjectPartComponenttypeSource ↗

A part component: it renders one slot, and docxSlot names the slot for toolbar overrides.

type ObjectPartComponent<C, S extends ObjectSlotId> = C & {
    readonly docxSlot: S;
};

ObjectSlotIdtypeSource ↗

A shape.* or chart.* slot.

type ObjectSlotId = keyof ObjectSlotValueMap;

OutlineHeadingtypeSource ↗

type OutlineHeading$1 = ReturnType<Editor['getOutline']>[number];

PaginatedDocxEditorExposetypeSource ↗

Vue name for the same contract React exports as PaginatedDocxEditorExpose.

type PaginatedDocxEditorExpose = PaginatedDocxEditorHandle;

ParagraphAlignmenttypeSource ↗

A paragraph alignment the legacy toolbar shows and sets.

type ParagraphAlignment = 'left' | 'center' | 'right' | 'both' | 'distribute';

ResolvedColorModetypeSource ↗

The theme the enclosing editor resolved from colorMode, never 'system', as [useEditorColorMode](useEditorColorMode) reports it.

type ResolvedColorMode = 'light' | 'dark';

ScopedChromeAnchorPlacementtypeSource ↗

Where a scoped chrome anchor sits relative to its story: before it, after it, or on its label.

type ScopedChromeAnchorPlacement = 'before' | 'after' | 'story-label';

ShapeColorPartPropstypeSource ↗

Props of a shape colour part: it also takes icon and asChild.

type ShapeColorPartProps = ObjectButtonPartProps;

ShapePartPropstypeSource ↗

Props of a shape part.

type ShapePartProps = ObjectControlProps;

TableActiontypeSource ↗

A table command the legacy toolbar dispatches.

type TableAction = 'addRowAbove' | 'addRowBelow' | 'addColumnLeft' | 'addColumnRight' | 'deleteRow' | 'deleteColumn' | 'mergeCells' | 'splitCell' | 'deleteTable' | 'selectTable' | 'selectRow' | 'selectColumn' | 'borderAll' | 'borderOutside' | 'borderInside' | 'borderNone' | 'borderTop' | 'borderBottom' | 'borderLeft' | 'borderRight' | {
    type: 'cellFillColor';
    color: string | null;
} | {
    type: 'borderColor';
    color: string;
} | {
    type: 'borderWidth';
    size: number;
} | {
    type: 'cellBorder';
    side: 'top' | 'bottom' | 'left' | 'right' | 'all';
    style: string;
    size: number;
    color: string;
};

ToolbarPartPropstypeSource ↗

type ToolbarPartProps = Omit<ToolbarButtonProps, 'slot'>;

ToolbarReviewersPropstypeSource ↗

type ToolbarReviewersProps = {
    className?: string;
    hidden?: boolean;
    icon?: DocxEditorChildren;
};

ToolbarTranslatetypeSource ↗

type ToolbarTranslate = (key: string) => string;

UseEditorHostDocumentReturntypeSource ↗

What [useEditorHostDocument](useEditorHostDocument) returns: a read-only ref to the host document.

type UseEditorHostDocumentReturn = Readonly<ShallowRef<Document | null>>;

UseObjectControlReturntypeSource ↗

What useObjectControl returns: the state and execute, and toggle for the toggle slots (chart.dataLabels, chart.axes, chart.gridlines).

type UseObjectControlReturn<K extends ObjectSlotId> = ObjectControlState<K> & (K extends ObjectToggleSlotId ? ObjectToggleControl : unknown);

WatermarkDialogFieldNametypeSource ↗

Named controls a host can replace with DocxEditor.WatermarkDialog.Field.

type WatermarkDialogFieldName = 'noWatermark' | 'pictureWatermark' | 'picture' | 'scale' | 'washout' | 'textWatermark' | 'preset' | 'text' | 'fontFamily' | 'fontSizePt' | 'bold' | 'italic' | 'transparency' | 'color' | 'layout';

WatermarkDialogKindtypeSource ↗

Which watermark the dialog writes.

type WatermarkDialogKind = 'none' | 'picture' | 'text';

WatermarkDialogLayouttypeSource ↗

How a text watermark crosses the page.

type WatermarkDialogLayout = NonNullable<WatermarkState['layout']>;

Variables (141)

ChartInsertconstSource ↗

The Insert chart dropdown: one item for each chart type.

ChartInsert: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    hidden: boolean;
    asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ColorPickerconstSource ↗

The colour picker compound: Root, Trigger, Content, and the parts of the grid. Every colour control of the editor is built from it.

ColorPicker: {
    Root: vue.DefineComponent<vue.ExtractPropTypes<{
        value: {
            type: PropType<ColorPickerValue>;
            default: null;
        };
        onPick: {
            type: PropType<(pick: ColorPick | 'none') => void>;
            required: true;
        };
        noColor: {
            type: PropType<'none' | 'auto' | false>;
            default: string;
        };
        automaticHex: {
            type: StringConstructor;
            default: undefined;
        };
        themeHexes: {
            type: PropType<readonly string[]>;
            default: undefined;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        open: {
            type: PropType<boolean | undefined>;
            default: undefined;
        };
        onOpenChange: {
            type: PropType<(open: boolean) => void>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        asChild: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        value: {
            type: PropType<ColorPickerValue>;
            default: null;
        };
        onPick: {
            type: PropType<(pick: ColorPick | 'none') => void>;
            required: true;
        };
        noColor: {
            type: PropType<'none' | 'auto' | false>;
            default: string;
        };
        automaticHex: {
            type: StringConstructor;
            default: undefined;
        };
        themeHexes: {
            type: PropType<readonly string[]>;
            default: undefined;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        open: {
            type: PropType<boolean | undefined>;
            default: undefined;
        };
        onOpenChange: {
            type: PropType<(open: boolean) => void>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        asChild: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, {
        value: ColorPickerValue;
        noColor: "auto" | "none" | false;
        automaticHex: string;
        themeHexes: readonly string[];
        disabled: boolean;
        open: boolean | undefined;
        onOpenChange: (open: boolean) => void;
        className: string;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Trigger: vue.DefineComponent<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
        asChild: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
        asChild: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, {
        className: string;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Content: vue.DefineComponent<vue.ExtractPropTypes<{
        hexInput: {
            type: BooleanConstructor;
            default: boolean;
        };
        inline: {
            type: BooleanConstructor;
            default: boolean;
        };
        container: {
            type: PropType<Element | null>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        hexInput: {
            type: BooleanConstructor;
            default: boolean;
        };
        inline: {
            type: BooleanConstructor;
            default: boolean;
        };
        container: {
            type: PropType<Element | null>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        hexInput: boolean;
        inline: boolean;
        container: Element | null;
        className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Grid: vue.DefineComponent<{}, () => vue_jsx_runtime.JSX.Element[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Swatch: vue.DefineComponent<vue.ExtractPropTypes<{
        pick: {
            type: PropType<ColorPick>;
            required: true;
        };
        hex: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        pick: {
            type: PropType<ColorPick>;
            required: true;
        };
        hex: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        hex: string;
        className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    NoColor: vue.DefineComponent<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    HexInput: vue.DefineComponent<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}

CONTENT_CONTROL_SLOTSconstSource ↗

CONTENT_CONTROL_SLOTS: {
    readonly showAll: 'contentControl.showAll';
    readonly formFill: 'contentControl.formFill';
    readonly inspector: 'contentControl.inspector';
    readonly remove: 'contentControl.remove';
}

ContextMenuCellVerticalAlignmentconstSource ↗

ContextMenuCellVerticalAlignment: vue.DefineComponent<vue.ExtractPropTypes<{
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ContextMenuCopyconstSource ↗

ContextMenuCopy: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuCopyFormattingconstSource ↗

Copy the formatting at the selection — the Format Painter's read half.

Stays available in a read-only document, like Copy: it writes nothing.

ContextMenuCopyFormatting: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuCutconstSource ↗

ContextMenuCut: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuDeleteconstSource ↗

ContextMenuDelete: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuDeleteTableconstSource ↗

ContextMenuDeleteTable: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuDeleteTableColumnconstSource ↗

ContextMenuDeleteTableColumn: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuDeleteTableRowconstSource ↗

ContextMenuDeleteTableRow: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuInsertColumnLeftconstSource ↗

ContextMenuInsertColumnLeft: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuInsertColumnRightconstSource ↗

ContextMenuInsertColumnRight: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuInsertRowAboveconstSource ↗

ContextMenuInsertRowAbove: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuInsertRowBelowconstSource ↗

ContextMenuInsertRowBelow: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuItemconstSource ↗

ContextMenuItem: vue.DefineComponent<vue.ExtractPropTypes<{
    label: {
        type: StringConstructor;
        required: true;
    };
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    shortcut: {
        type: StringConstructor;
        default: undefined;
    };
    disabled: {
        type: BooleanConstructor;
        default: undefined;
    };
    disabledReason: {
        type: StringConstructor;
        default: undefined;
    };
    active: {
        type: BooleanConstructor;
        default: undefined;
    };
    onSelect: {
        type: PropType<() => void>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    label: {
        type: StringConstructor;
        required: true;
    };
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    shortcut: {
        type: StringConstructor;
        default: undefined;
    };
    disabled: {
        type: BooleanConstructor;
        default: undefined;
    };
    disabledReason: {
        type: StringConstructor;
        default: undefined;
    };
    active: {
        type: BooleanConstructor;
        default: undefined;
    };
    onSelect: {
        type: PropType<() => void>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    shortcut: string;
    disabled: boolean;
    disabledReason: string;
    active: boolean;
    onSelect: () => void;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ContextMenuMergeCellsconstSource ↗

Merge the selected cells into one cell.

ContextMenuMergeCells: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuPasteconstSource ↗

ContextMenuPaste: vue.DefineComponent<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ContextMenuPasteFormattingconstSource ↗

Apply the copied formatting to the selection.

Disabled with the engine's own reason until something has been copied, so the row says why rather than looking live and doing nothing.

ContextMenuPasteFormatting: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuPasteWithoutFormattingconstSource ↗

Paste the clipboard's plain text as if typed, whatever richer flavours it holds — the Cmd+Shift+V twin as a menu row.

ContextMenuPasteWithoutFormatting: vue.DefineComponent<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ContextMenuRefreshTocconstSource ↗

ContextMenuRefreshToc: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuRefreshTocPageNumbersconstSource ↗

ContextMenuRefreshTocPageNumbers: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuRemoveTocconstSource ↗

ContextMenuRemoveToc: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuSelectAllconstSource ↗

ContextMenuSelectAll: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        shortcutKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    shortcutKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuSelectTableconstSource ↗

Select every cell of the table at the selection.

ContextMenuSelectTable: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        destructive: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
        destructive: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    destructive: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
    destructive: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuSplitCellconstSource ↗

Open the Split cells dialog for the cell at the selection.

ContextMenuSplitCell: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        icon: {
            type: PropType<VNode>;
            default: undefined;
        };
        labelKey: {
            type: StringConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        hidden: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    icon: {
        type: PropType<VNode>;
        default: undefined;
    };
    labelKey: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    hidden: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: string;
}

ContextMenuStartconstSource ↗

Host rows that render above the packaged rows instead of after them.

Use it for rows about the item under the pointer, such as spelling suggestions for the word that was right-clicked. Read that item with useContextMenuTarget(). A menu opened from the keyboard has no target: useContextMenuAnchor() reports trigger: 'keyboard', and editor.getSelectionRange() reads the caret instead. It must be a direct child of DocxEditor.ContextMenu; a component that returns it renders at the end.

ContextMenuStart: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {}, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<{}> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[], {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRowPlacement: 'start';
}

DEFAULT_WATERMARK_PRESETSconstSource ↗

The text choices the dialog offers when the host passes no presets.

DEFAULT_WATERMARK_PRESETS: readonly string[]

DocumentNameconstSource ↗

Deprecated. Use `<DocxEditor>` title props instead.

DocumentName: vue.DefineComponent<vue.ExtractPropTypes<{
    value: {
        type: StringConstructor;
        default: string;
    };
    onChange: {
        type: PropType<(value: string) => void>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    value: {
        type: StringConstructor;
        default: string;
    };
    onChange: {
        type: PropType<(value: string) => void>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    value: string;
    onChange: (value: string) => void;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocumentOutlineconstSource ↗

DocumentOutline: vue.DefineComponent<vue.ExtractPropTypes<{
    headings: {
        type: PropType<readonly OutlineHeading[]>;
        required: true;
    };
    onHeadingClick: {
        type: PropType<(blockId: string) => void>;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    topOffset: {
        type: NumberConstructor;
        default: number;
    };
    scrollLeft: {
        type: NumberConstructor;
        default: number;
    };
    leftOffset: {
        type: NumberConstructor;
        default: number;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    headings: {
        type: PropType<readonly OutlineHeading[]>;
        required: true;
    };
    onHeadingClick: {
        type: PropType<(blockId: string) => void>;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    topOffset: {
        type: NumberConstructor;
        default: number;
    };
    scrollLeft: {
        type: NumberConstructor;
        default: number;
    };
    leftOffset: {
        type: NumberConstructor;
        default: number;
    };
}>> & Readonly<{}>, {
    topOffset: number;
    scrollLeft: number;
    leftOffset: number;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorconstSource ↗

DocxEditor: DocxEditorNamespace

DocxEditorAuthorStyleconstSource ↗

DocxEditorAuthorStyle: {
    new (): {
        $props: DocxEditorAuthorStyleProps;
    };
}

DocxEditorBookmarkDialogconstSource ↗

The Bookmark dialog with replaceable controls and layout.

DocxEditorBookmarkDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly children: PropType<DocxEditorChildren>;
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: PropType<CSSProperties>;
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly children: PropType<DocxEditorChildren>;
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: PropType<CSSProperties>;
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly children: PropType<DocxEditorChildren>;
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: PropType<CSSProperties>;
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: "list" | "name" | "showHidden" | "sortBy";
    }>;
    Delete: vue.DefineComponent<DialogPartProps>;
    GoTo: vue.DefineComponent<DialogPartProps>;
    KeepFirst: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
    Error: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Header: vue.DefineComponent<DialogPartProps>;
    Reset: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
}

DocxEditorChartAxesconstSource ↗

Whether the chart shows its axes (chart.axes). Nothing for a chart with no axes.

DocxEditorChartAxes: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
    readonly icon: DocxEditorChildren;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.axes">

DocxEditorChartCategoryAxisTitleconstSource ↗

The category (or X) axis title (chart.categoryAxisTitle).

DocxEditorChartCategoryAxisTitle: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.categoryAxisTitle">

DocxEditorChartDataconstSource ↗

The categories and series of the selected chart, or why they cannot change.

DocxEditorChartData: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.data">

DocxEditorChartDataLabelsconstSource ↗

Whether each point shows its value (chart.dataLabels).

DocxEditorChartDataLabels: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
    readonly icon: DocxEditorChildren;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.dataLabels">

DocxEditorChartGridlinesconstSource ↗

Whether the value axis shows major gridlines (chart.gridlines).

DocxEditorChartGridlines: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
    readonly icon: DocxEditorChildren;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.gridlines">

DocxEditorChartLegendconstSource ↗

Where the legend sits, or none (chart.legend).

DocxEditorChartLegend: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.legend">

DocxEditorChartPaneconstSource ↗

The type, elements, and colors of the selected chart, then its data; or why it shows none.

DocxEditorChartPane: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorChartSeriesColorsconstSource ↗

The colour of each series, or of each point of a pie chart (chart.seriesColor): one shared colour picker per entry, with Automatic. index shows one entry only.

DocxEditorChartSeriesColors: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    index: {
        type: NumberConstructor;
        default: undefined;
    };
}>, () => vue.VNodeChild, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    index: {
        type: NumberConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    label: string;
    variant: ObjectControlVariant;
    hidden: boolean;
    index: number;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.seriesColor">

DocxEditorChartTitleconstSource ↗

The chart title (chart.title). A field shows a Title check box and, while it is on, the title text; a toolbar shows the text field alone, where empty text removes the title.

DocxEditorChartTitle: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => void | string | number | boolean | vue_jsx_runtime.JSX.Element | vue.VNodeArrayChildren | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.title">

DocxEditorChartTypeconstSource ↗

The chart type (chart.type). A field notes when a type change drops colours or axis titles, and when a pie chart shows only its first series.

DocxEditorChartType: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.type">

DocxEditorChartValueAxisTitleconstSource ↗

The value (or Y) axis title (chart.valueAxisTitle).

DocxEditorChartValueAxisTitle: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "chart.valueAxisTitle">

DocxEditorColorByChangeTypeconstSource ↗

DocxEditorColorByChangeType: vue.DefineComponent<{}, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorCompareDocumentsDialogconstSource ↗

Compare documents with replaceable controls and layout.

DocxEditorCompareDocumentsDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        session: {
            type: PropType<CompareDocumentsDialogSession | null>;
            default: null;
        };
        children: PropType<DocxEditorChildren>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        style: PropType<CSSProperties>;
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        session: CompareDocumentsDialogSession | null;
        preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        session: {
            type: PropType<CompareDocumentsDialogSession | null>;
            default: null;
        };
        children: PropType<DocxEditorChildren>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        style: PropType<CSSProperties>;
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        session: CompareDocumentsDialogSession | null;
        preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    session: {
        type: PropType<CompareDocumentsDialogSession | null>;
        default: null;
    };
    children: PropType<DocxEditorChildren>;
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    session: CompareDocumentsDialogSession | null;
    preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: keyof CompareDocumentsDialogValues;
    }>;
    Progress: vue.DefineComponent<DialogPartProps>;
    Notice: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
    Error: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
}

DocxEditorContentconstSource ↗

DocxEditorContent: vue.DefineComponent<vue.ExtractPropTypes<{
    class: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    class: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    class: string;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorContentControlconstSource ↗

DocxEditorContentControl: DocxEditorContentControlNamespace

DocxEditorContentControlWidgetconstSource ↗

Compact value editor for a configured content-control popup.

DocxEditorContentControlWidget: DocxEditorContentControlWidgetNamespace

DocxEditorContextMenuconstSource ↗

DocxEditorContextMenu: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    t: {
        type: PropType<ToolbarTranslate>;
        default: undefined;
    };
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
    disabled: {
        type: BooleanConstructor;
        default: undefined;
    };
    onOpenChange: {
        type: PropType<(open: boolean) => void>;
        default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    t: {
        type: PropType<ToolbarTranslate>;
        default: undefined;
    };
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
    disabled: {
        type: BooleanConstructor;
        default: undefined;
    };
    onOpenChange: {
        type: PropType<(open: boolean) => void>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    t: ToolbarTranslate;
    preset: boolean;
    disabled: boolean;
    onOpenChange: (open: boolean) => void;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorDocumentOutlineconstSource ↗

DocxEditorDocumentOutline: vue.DefineComponent<vue.ExtractPropTypes<{
    onClose: {
        type: PropType<() => void>;
        default: undefined;
    };
    topOffset: {
        type: NumberConstructor;
        default: number;
    };
    leftOffset: {
        type: NumberConstructor;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    onClose: {
        type: PropType<() => void>;
        default: undefined;
    };
    topOffset: {
        type: NumberConstructor;
        default: number;
    };
    leftOffset: {
        type: NumberConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    onClose: () => void;
    topOffset: number;
    leftOffset: number;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorEquationconstSource ↗

Default equation editor mounted by the packaged Vue host.

DocxEditorEquation: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorExportDialogconstSource ↗

Default progress and error dialog for popups.export.

DocxEditorExportDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    pending: {
        type: BooleanConstructor;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
    format: {
        type: PropType<ChromeExportFormat>;
        required: true;
    };
    error: {
        type: StringConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    pending: {
        type: BooleanConstructor;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
    format: {
        type: PropType<ChromeExportFormat>;
        required: true;
    };
    error: {
        type: StringConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorFontNoticeconstSource ↗

DocxEditorFontNotice: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
    t: {
        type: PropType<TFunction>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
    t: {
        type: PropType<TFunction>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
    t: TFunction;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorHeaderFooterChromeconstSource ↗

Thin overlay while a header or footer scope is open: region label and contextual options.

DocxEditorHeaderFooterChrome: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorHorizontalRulerconstSource ↗

DocxEditorHorizontalRuler: vue.DefineComponent<vue.ExtractPropTypes<{
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    unit: "cm" | "inch";
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
DocxEditorHyperLink: DocxEditorHyperLinkNamespace

DocxEditorImageAltTextPopupconstSource ↗

Packaged image description popup.

DocxEditorImageAltTextPopup: vue.DefineComponent<vue.ExtractPropTypes<{
    id: {
        type: StringConstructor;
        required: true;
    };
    value: {
        type: StringConstructor;
        required: true;
    };
    onValueChange: {
        type: PropType<(value: string) => void>;
        required: true;
    };
    onApply: {
        type: PropType<() => void>;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    isEnabled: {
        type: BooleanConstructor;
        required: true;
    };
    className: StringConstructor;
    anchorRef: PropType<RefObject<HTMLElement | null>>;
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    id: {
        type: StringConstructor;
        required: true;
    };
    value: {
        type: StringConstructor;
        required: true;
    };
    onValueChange: {
        type: PropType<(value: string) => void>;
        required: true;
    };
    onApply: {
        type: PropType<() => void>;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    isEnabled: {
        type: BooleanConstructor;
        required: true;
    };
    className: StringConstructor;
    anchorRef: PropType<RefObject<HTMLElement | null>>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorImageInsertErrorDialogconstSource ↗

The packaged picture refusal: an editor dialog, never a page-blocking browser alert.

DocxEditorImageInsertErrorDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    message: {
        type: StringConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    message: {
        type: StringConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorImagePropertiesDialogconstSource ↗

Properties dialog for the selected picture.

DocxEditorImagePropertiesDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    triggerRef: {
        type: PropType<RefObject<HTMLElement | null>>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    triggerRef: {
        type: PropType<RefObject<HTMLElement | null>>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    triggerRef: RefObject<HTMLElement | null>;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorInvalidTextFormFieldDialogconstSource ↗

Default acknowledgement shell for a custom popup renderer.

DocxEditorInvalidTextFormFieldDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    session: {
        type: PropType<InvalidTextFormFieldSession>;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    session: {
        type: PropType<InvalidTextFormFieldSession>;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorLoadingconstSource ↗

DocxEditorLoading: DocxEditorLoadingComponent

DocxEditorLoadingSpinnerconstSource ↗

DocxEditorLoadingSpinner: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorMenuconstSource ↗

DocxEditorMenu: DocxEditorMenuNamespace

DocxEditorNavigationconstSource ↗

DocxEditorNavigation: DocxEditorNavigationNamespace

DocxEditorNotePreviewconstSource ↗

Packaged note hover preview.

DocxEditorNotePreview: vue.DefineComponent<vue.ExtractPropTypes<{
    scopeId: {
        type: StringConstructor;
        required: true;
    };
    text: {
        type: StringConstructor;
        required: true;
    };
    x: {
        type: NumberConstructor;
        required: true;
    };
    y: {
        type: NumberConstructor;
        required: true;
    };
    className: StringConstructor;
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    scopeId: {
        type: StringConstructor;
        required: true;
    };
    text: {
        type: StringConstructor;
        required: true;
    };
    x: {
        type: NumberConstructor;
        required: true;
    };
    y: {
        type: NumberConstructor;
        required: true;
    };
    className: StringConstructor;
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorNotePropertiesDialogconstSource ↗

Packaged note properties dialog.

DocxEditorNotePropertiesDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    onApply: {
        type: PropType<(command: EditorCommand) => void>;
        required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    onApply: {
        type: PropType<(command: EditorCommand) => void>;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorNotesChromeconstSource ↗

DocxEditorNotesChrome: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorNotesContextMenuconstSource ↗

Packaged note context menu.

DocxEditorNotesContextMenu: vue.DefineComponent<vue.ExtractPropTypes<{
    scopeId: {
        type: StringConstructor;
        required: true;
    };
    noteKind: {
        type: PropType<'footnote' | 'endnote'>;
        required: true;
    };
    noteId: {
        type: NumberConstructor;
        required: true;
    };
    x: {
        type: NumberConstructor;
        required: true;
    };
    y: {
        type: NumberConstructor;
        required: true;
    };
    onDelete: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onConvert: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onConvertAll: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onOpenProperties: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    deleteEnabled: BooleanConstructor;
    convertEnabled: BooleanConstructor;
    convertAllEnabled: BooleanConstructor;
    deleteDisabledReason: StringConstructor;
    convertDisabledReason: StringConstructor;
    convertAllDisabledReason: StringConstructor;
    className: StringConstructor;
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    scopeId: {
        type: StringConstructor;
        required: true;
    };
    noteKind: {
        type: PropType<'footnote' | 'endnote'>;
        required: true;
    };
    noteId: {
        type: NumberConstructor;
        required: true;
    };
    x: {
        type: NumberConstructor;
        required: true;
    };
    y: {
        type: NumberConstructor;
        required: true;
    };
    onDelete: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onConvert: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onConvertAll: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onOpenProperties: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    deleteEnabled: BooleanConstructor;
    convertEnabled: BooleanConstructor;
    convertAllEnabled: BooleanConstructor;
    deleteDisabledReason: StringConstructor;
    convertDisabledReason: StringConstructor;
    convertAllDisabledReason: StringConstructor;
    className: StringConstructor;
}>> & Readonly<{}>, {
    deleteEnabled: boolean;
    convertEnabled: boolean;
    convertAllEnabled: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorOpenFailureconstSource ↗

A dialog that explains why a file did not open. It shows nothing until the editor refuses a document, and shows again for each later refusal. <DocxEditor> renders it by default; compose it yourself inside a DocxEditor.Root. The actions slot adds your own buttons before **Close**, and the default slot replaces the whole content. Both receive { failure, message, dismiss }.

vue <DocxEditor.OpenFailure @dismiss="onClosed"> <template #actions="{ failure, dismiss }"> <DocxEditor.OpenFailure.Action variant="primary" @click="report(failure.code); dismiss()"> Report </DocxEditor.OpenFailure.Action> </template> </DocxEditor.OpenFailure>

The packaged message is generic and names no contact. For a toast or banner instead of a dialog, use useOpenFailure.

DocxEditorOpenFailure: DocxEditorOpenFailureComponent

DocxEditorOpenFailureActionconstSource ↗

A button in the open-failure dialog, styled as the packaged **Close**. Use it in the actions slot, or in your own default slot. With as-child, it styles your own element instead, such as a link to your support page:

vue <DocxEditor.OpenFailure> <template #actions="{ failure }"> <DocxEditor.OpenFailure.Action as-child> <a :href="/support?code=${failure.code}">Get help</a> </DocxEditor.OpenFailure.Action> </template> </DocxEditor.OpenFailure>

DocxEditorOpenFailureAction: vue.DefineComponent<vue.ExtractPropTypes<{
    variant: {
        type: PropType<'primary' | 'secondary'>;
        default: string;
    };
    dismiss: {
        type: BooleanConstructor;
        default: boolean;
    };
    asChild: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    variant: {
        type: PropType<'primary' | 'secondary'>;
        default: string;
    };
    dismiss: {
        type: BooleanConstructor;
        default: boolean;
    };
    asChild: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, {
    variant: "primary" | "secondary";
    dismiss: boolean;
    asChild: boolean;
}, SlotsType<{
    default?: () => VNode[];
}>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorPageNumberconstSource ↗

Floating localized page readout for the active DocxEditorViewport.

It appears while a multi-page document scrolls and fades after 600 ms of inactivity. It is positioned absolute against the nearest positioned ancestor, so give the element that holds the viewport position: relative.

Place it as a sibling of the viewport or inside it. Inside the viewport, it renders into the viewport's parent element, so it stays in view while the pages scroll.

DocxEditorPageNumber: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
```vue
<div style="position: relative; height: 100%">
  <DocxEditorViewport>
    <DocxEditorContent />
  </DocxEditorViewport>
  <DocxEditorPageNumber />
</div>
```

DocxEditorPageSetupDialogconstSource ↗

Customizable Page Setup dialog.

DocxEditorPageSetupDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        open: {
            type: BooleanConstructor;
            required: true;
        };
        onClose: {
            type: PropType<() => void>;
            required: true;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        style: PropType<CSSProperties>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        className: string;
        preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        open: {
            type: BooleanConstructor;
            required: true;
        };
        onClose: {
            type: PropType<() => void>;
            required: true;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        style: PropType<CSSProperties>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        className: string;
        preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    children: PropType<DocxEditorChildren>;
    open: {
        type: BooleanConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: PropType<CSSProperties>;
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    className: string;
    preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Record<"Apply" | "Body" | "Cancel" | "Error" | "Footer" | "Header" | "Reset" | "Title", vue.DefineComponent<DialogPartProps>> & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: "marginBottom" | "marginLeft" | "marginRight" | "marginTop" | "orientation" | "pageSize" | "scope";
    }>;
}

DocxEditorPaneSectionsconstSource ↗

The sections of a pane, each a heading over its slot parts. The parts render as fields, also inside a toolbar.

DocxEditorPaneSections: vue.DefineComponent<vue.ExtractPropTypes<{
    pane: {
        type: PropType<EditorPaneId>;
        required: true;
    };
    sections: {
        type: PropType<readonly PaneSectionId[]>;
        default: undefined;
    };
    filter: {
        type: PropType<(section: PaneSection) => boolean>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    pane: {
        type: PropType<EditorPaneId>;
        required: true;
    };
    sections: {
        type: PropType<readonly PaneSectionId[]>;
        default: undefined;
    };
    filter: {
        type: PropType<(section: PaneSection) => boolean>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    sections: readonly PaneSectionId[];
    filter: (section: PaneSection) => boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorParagraphDialogconstSource ↗

Customizable Paragraph dialog.

DocxEditorParagraphDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        open: {
            type: BooleanConstructor;
            required: true;
        };
        onClose: {
            type: PropType<() => void>;
            required: true;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        style: PropType<CSSProperties>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        className: string;
        preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        open: {
            type: BooleanConstructor;
            required: true;
        };
        onClose: {
            type: PropType<() => void>;
            required: true;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        style: PropType<CSSProperties>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        className: string;
        preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    children: PropType<DocxEditorChildren>;
    open: {
        type: BooleanConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: PropType<CSSProperties>;
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    className: string;
    preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Record<"Apply" | "Body" | "Cancel" | "Error" | "Footer" | "Header" | "Reset" | "Title", vue.DefineComponent<DialogPartProps>> & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: "alignment" | "contextualSpacing" | "direction" | "indentLeft" | "indentRight" | "keepLines" | "keepNext" | "lineRule" | "lineValue" | "pageBreakBefore" | "spaceAfter" | "spaceBefore" | "special" | "specialBy" | "tabStops" | "widowControl";
    }>;
}

DocxEditorPrintDialogconstSource ↗

Default progress and error dialog for popups.print. The editor closes it when the browser print dialog opens.

DocxEditorPrintDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    pending: {
        type: BooleanConstructor;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
    error: {
        type: StringConstructor;
        required: true;
    };
    url: {
        type: StringConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    choosing: {
        type: BooleanConstructor;
        default: boolean;
    };
    settings: {
        type: PropType<ResolvedChromePrintSettings>;
        default: undefined;
    };
    onSettingsChange: {
        type: PropType<(change: ChromePrintSettings) => void>;
        default: undefined;
    };
    onPrint: {
        type: PropType<() => void>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    pending: {
        type: BooleanConstructor;
        required: true;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
    children: PropType<DocxEditorChildren>;
    error: {
        type: StringConstructor;
        required: true;
    };
    url: {
        type: StringConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    choosing: {
        type: BooleanConstructor;
        default: boolean;
    };
    settings: {
        type: PropType<ResolvedChromePrintSettings>;
        default: undefined;
    };
    onSettingsChange: {
        type: PropType<(change: ChromePrintSettings) => void>;
        default: undefined;
    };
    onPrint: {
        type: PropType<() => void>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    choosing: boolean;
    settings: Required<ChromePrintSettings>;
    onSettingsChange: (change: ChromePrintSettings) => void;
    onPrint: () => void;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorRevisionMarkupconstSource ↗

Declares markup settings without rendering an element.

DocxEditorRevisionMarkup: vue.DefineComponent<vue.ExtractPropTypes<{
    insertions: PropType<RevisionMarkupOptions['insertions']>;
    deletions: PropType<RevisionMarkupOptions['deletions']>;
    movedFrom: PropType<RevisionMarkupOptions['movedFrom']>;
    movedTo: PropType<RevisionMarkupOptions['movedTo']>;
    formatting: PropType<RevisionMarkupOptions['formatting']>;
    changedLines: PropType<RevisionMarkupOptions['changedLines']>;
    cells: PropType<RevisionMarkupOptions['cells']>;
    trackMoves: {
        type: BooleanConstructor;
        default: undefined;
    };
    trackFormatting: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    revisionMarkupChange: (_settings: ResolvedRevisionMarkup) => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    insertions: PropType<RevisionMarkupOptions['insertions']>;
    deletions: PropType<RevisionMarkupOptions['deletions']>;
    movedFrom: PropType<RevisionMarkupOptions['movedFrom']>;
    movedTo: PropType<RevisionMarkupOptions['movedTo']>;
    formatting: PropType<RevisionMarkupOptions['formatting']>;
    changedLines: PropType<RevisionMarkupOptions['changedLines']>;
    cells: PropType<RevisionMarkupOptions['cells']>;
    trackMoves: {
        type: BooleanConstructor;
        default: undefined;
    };
    trackFormatting: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{
    onRevisionMarkupChange?: ((_settings: ResolvedRevisionMarkup) => any) | undefined;
}>, {
    trackMoves: boolean;
    trackFormatting: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorRevisionMarkupDialogconstSource ↗

Customizable viewer-local Track changes options.

DocxEditorRevisionMarkupDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        session: {
            type: PropType<RevisionMarkupDialogSession | null>;
            default: null;
        };
        children: PropType<DocxEditorChildren>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        style: PropType<CSSProperties>;
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        session: RevisionMarkupDialogSession | null;
        preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        session: {
            type: PropType<RevisionMarkupDialogSession | null>;
            default: null;
        };
        children: PropType<DocxEditorChildren>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        style: PropType<CSSProperties>;
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        session: RevisionMarkupDialogSession | null;
        preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    session: {
        type: PropType<RevisionMarkupDialogSession | null>;
        default: null;
    };
    children: PropType<DocxEditorChildren>;
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    session: RevisionMarkupDialogSession | null;
    preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Record<"Apply" | "Body" | "Cancel" | "Error" | "Footer" | "Header" | "Reset" | "Title", vue.DefineComponent<DialogPartProps>> & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: keyof ResolvedRevisionMarkup;
    }>;
}

DocxEditorRootconstSource ↗

DocxEditorRoot: vue.DefineComponent<vue.ExtractPropTypes<{
    popups: PropType<DocxEditorPopups>;
    document: {
        type: PropType<DocumentSource>;
        default: undefined;
    };
    fonts: {
        type: PropType<DocxEditorRootProps['fonts']>;
        default: undefined;
    };
    fontShaping: {
        type: PropType<DocxEditorRootProps['fontShaping']>;
        default: undefined;
    };
    author: {
        type: StringConstructor;
        default: undefined;
    };
    locale: {
        type: StringConstructor;
        default: undefined;
    };
    translate: {
        type: PropType<DocxEditorRootProps['translate']>;
        default: undefined;
    };
    modules: {
        type: PropType<readonly EditorModule[]>;
        default: undefined;
    };
    mode: {
        type: PropType<'edit' | 'view' | 'suggesting'>;
        default: undefined;
    };
    revisionMarkup: PropType<RevisionMarkupOptions>;
    reviewDisplayMode: PropType<ReviewDisplayMode>;
    fieldResults: {
        type: PropType<FieldResultsMode>;
        default: undefined;
    };
    contentLockPolicy: {
        type: PropType<ContentLockPolicy>;
        default: undefined;
    };
    lockedControlNavigation: {
        type: PropType<LockedControlNavigation>;
        default: undefined;
    };
    zoom: {
        type: NumberConstructor;
        default: undefined;
    };
    zoomMode: {
        type: PropType<ZoomMode | 'auto'>;
        default: undefined;
    };
    tableInteractionLabel: {
        type: PropType<DocxEditorRootProps['tableInteractionLabel']>;
        default: undefined;
    };
    imageDecodePort: {
        type: PropType<ImageDecodePort>;
        default: undefined;
    };
    colorMode: {
        type: PropType<'light' | 'dark' | 'system'>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    ready: (_editor: Editor) => true;
    change: (_change: DocumentChange) => true;
    fontError: (_error: unknown) => true;
    revisionMarkupChange: (_settings: ResolvedRevisionMarkup) => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    popups: PropType<DocxEditorPopups>;
    document: {
        type: PropType<DocumentSource>;
        default: undefined;
    };
    fonts: {
        type: PropType<DocxEditorRootProps['fonts']>;
        default: undefined;
    };
    fontShaping: {
        type: PropType<DocxEditorRootProps['fontShaping']>;
        default: undefined;
    };
    author: {
        type: StringConstructor;
        default: undefined;
    };
    locale: {
        type: StringConstructor;
        default: undefined;
    };
    translate: {
        type: PropType<DocxEditorRootProps['translate']>;
        default: undefined;
    };
    modules: {
        type: PropType<readonly EditorModule[]>;
        default: undefined;
    };
    mode: {
        type: PropType<'edit' | 'view' | 'suggesting'>;
        default: undefined;
    };
    revisionMarkup: PropType<RevisionMarkupOptions>;
    reviewDisplayMode: PropType<ReviewDisplayMode>;
    fieldResults: {
        type: PropType<FieldResultsMode>;
        default: undefined;
    };
    contentLockPolicy: {
        type: PropType<ContentLockPolicy>;
        default: undefined;
    };
    lockedControlNavigation: {
        type: PropType<LockedControlNavigation>;
        default: undefined;
    };
    zoom: {
        type: NumberConstructor;
        default: undefined;
    };
    zoomMode: {
        type: PropType<ZoomMode | 'auto'>;
        default: undefined;
    };
    tableInteractionLabel: {
        type: PropType<DocxEditorRootProps['tableInteractionLabel']>;
        default: undefined;
    };
    imageDecodePort: {
        type: PropType<ImageDecodePort>;
        default: undefined;
    };
    colorMode: {
        type: PropType<'light' | 'dark' | 'system'>;
        default: undefined;
    };
}>> & Readonly<{
    onChange?: ((_change: DocumentChange) => any) | undefined;
    onFontError?: ((_error: unknown) => any) | undefined;
    onReady?: ((_editor: Editor) => any) | undefined;
    onRevisionMarkupChange?: ((_settings: ResolvedRevisionMarkup) => any) | undefined;
}>, {
    document: DocumentSource;
    fonts: _docx_editor_dev_core.FontConfiguration | _docx_editor_dev_core.FontConfigurationFragment | _docx_editor_dev_core.FontResolver | undefined;
    fontShaping: _docx_editor_dev_core.FontShapingOptions | undefined;
    author: string;
    locale: string;
    translate: ((key: string, params?: Record<string, string | number>) => string) | undefined;
    modules: readonly EditorModule[];
    mode: "edit" | "suggesting" | "view";
    fieldResults: FieldResultsMode;
    contentLockPolicy: ContentLockPolicy;
    lockedControlNavigation: LockedControlNavigation;
    zoom: number;
    zoomMode: "auto" | ZoomMode;
    tableInteractionLabel: ((key: _docx_editor_dev_core.TableInteractionLabelKey) => string) | undefined;
    imageDecodePort: ImageDecodePort;
    colorMode: "dark" | "light" | "system";
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorShapeFillconstSource ↗

The fill colour of the selected shape (shape.fill), with No fill.

DocxEditorShapeFill: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: vue.PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: vue.PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
    readonly icon: DocxEditorChildren;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "shape.fill">

DocxEditorShapeFillTransparencyconstSource ↗

The transparency of a solid fill, in percent (shape.fillTransparency).

DocxEditorShapeFillTransparency: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "shape.fillTransparency">

DocxEditorShapeOutlineColorconstSource ↗

The outline colour of the selected shape (shape.outlineColor), with No line.

DocxEditorShapeOutlineColor: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: vue.PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: vue.PropType<DocxEditorChildren>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
    readonly icon: DocxEditorChildren;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "shape.outlineColor">

DocxEditorShapeOutlineDashconstSource ↗

The outline dash (shape.outlineDash): solid, dotted, or dashed.

DocxEditorShapeOutlineDash: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "shape.outlineDash">

DocxEditorShapeOutlineWidthconstSource ↗

The outline width in points (shape.outlineWidth): a list of preset widths, and in a field a number box for any other width.

DocxEditorShapeOutlineWidth: ObjectPartComponent<vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly variant: {
        readonly type: vue.PropType<ObjectControlVariant>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly variant: ObjectControlVariant;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, "shape.outlineWidth">

DocxEditorShapePaneconstSource ↗

The fill and outline of the selected shape, or why the pane shows none.

DocxEditorShapePane: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorShellconstSource ↗

Deprecated. Use `<DocxEditor>` instead.

DocxEditorShell: DocxEditorNamespace

DocxEditorSidePanelconstSource ↗

The side panel that holds the Chart pane or the Format shape pane. The default slot replaces the packaged panes.

DocxEditorSidePanel: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    onClose: {
        type: PropType<() => void>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    onClose: {
        type: PropType<() => void>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    onClose: () => void;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorSplitCellDialogconstSource ↗

The Split cells dialog with replaceable controls and layout.

DocxEditorSplitCellDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly children: PropType<DocxEditorChildren>;
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: PropType<CSSProperties>;
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly children: PropType<DocxEditorChildren>;
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: PropType<CSSProperties>;
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly children: PropType<DocxEditorChildren>;
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: PropType<CSSProperties>;
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: "columns" | "rows";
    }>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
    Error: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Header: vue.DefineComponent<DialogPartProps>;
    Reset: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
}

DocxEditorTextFormFieldDialogconstSource ↗

Customizable legacy text field options.

DocxEditorTextFormFieldDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        session: {
            type: PropType<TextFormFieldDialogSession | null>;
            default: null;
        };
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        style: PropType<CSSProperties>;
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        session: TextFormFieldDialogSession | null;
        preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        session: {
            type: PropType<TextFormFieldDialogSession | null>;
            default: null;
        };
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        style: PropType<CSSProperties>;
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        session: TextFormFieldDialogSession | null;
        preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    children: PropType<DocxEditorChildren>;
    session: {
        type: PropType<TextFormFieldDialogSession | null>;
        default: null;
    };
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
    className: StringConstructor;
    style: PropType<CSSProperties>;
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    session: TextFormFieldDialogSession | null;
    preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Record<"Apply" | "Body" | "Cancel" | "Error" | "Footer" | "Header" | "Reset" | "Title", vue.DefineComponent<DialogPartProps>> & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: keyof TextFormFieldDialogFields;
    }>;
}

DocxEditorToolbarconstSource ↗

DocxEditorToolbar: DocxEditorToolbarNamespace

DocxEditorUnsupportedElementconstSource ↗

Register a renderer under DocxEditor or DocxEditor.Root. The first mounted matching declaration wins. Prop updates retain its priority. Omit match for a catch-all. Empty slot content, or a child component that renders nothing, keeps what the editor shows. The default slot renders once for each occurrence; put composables in a child component that it renders. To build a preview DOCX in that component, use drawingPreviewDocx from @docx-editor.dev/core/editor. Layout uses points and only sizes content without an existing layout box. Custom content gets the occurrence's box (element.bounds); size it to 100% of the width and height. Clicking a custom preview selects the underlying drawing for moving, resizing, or deletion. Links, buttons, and form fields retain their normal behavior. Components can remount when pagination or virtualization removes an occurrence.

DocxEditorUnsupportedElement: vue.DefineComponent<vue.ExtractPropTypes<{
    includePartial: {
        type: BooleanConstructor;
        default: boolean;
    };
    match: {
        type: PropType<UnsupportedElementRule['match']>;
        default: undefined;
    };
    layout: {
        type: PropType<UnsupportedElementRule['layout']>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    includePartial: {
        type: BooleanConstructor;
        default: boolean;
    };
    match: {
        type: PropType<UnsupportedElementRule['match']>;
        default: undefined;
    };
    layout: {
        type: PropType<UnsupportedElementRule['layout']>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    includePartial: boolean;
    match: ((element: UnsupportedElement) => boolean) | undefined;
    layout: _docx_editor_dev_core_layout.UnsupportedElementLayout | undefined;
}, SlotsType<{
    default: (props: {
        element: UnsupportedElement;
    }) => VNodeChild;
}>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorVerticalRulerconstSource ↗

DocxEditorVerticalRuler: vue.DefineComponent<vue.ExtractPropTypes<{
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    unit: "cm" | "inch";
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorViewportconstSource ↗

DocxEditorViewport: vue.DefineComponent<vue.ExtractPropTypes<{
    class: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    class: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    class: string;
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorWatermarkDialogconstSource ↗

Watermark dialog: no watermark, a picture, or text, with a live page preview and replaceable controls and layout. Applies the whole form as one undoable setWatermark command, and writes nothing when the form is unchanged.

DocxEditorWatermarkDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        open: {
            type: BooleanConstructor;
            required: true;
        };
        onClose: {
            type: PropType<() => void>;
            required: true;
        };
        presets: {
            type: PropType<readonly string[]>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        style: PropType<CSSProperties>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        presets: readonly string[];
        className: string;
        preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        children: PropType<DocxEditorChildren>;
        open: {
            type: BooleanConstructor;
            required: true;
        };
        onClose: {
            type: PropType<() => void>;
            required: true;
        };
        presets: {
            type: PropType<readonly string[]>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
        style: PropType<CSSProperties>;
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        presets: readonly string[];
        className: string;
        preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    children: PropType<DocxEditorChildren>;
    open: {
        type: BooleanConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    presets: {
        type: PropType<readonly string[]>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: PropType<CSSProperties>;
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    presets: readonly string[];
    className: string;
    preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Field: vue.DefineComponent<DialogPartProps & {
        name: WatermarkDialogFieldName;
    }>;
    Preview: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
    Error: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Header: vue.DefineComponent<DialogPartProps>;
    Reset: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
}

DocxEditorWindowconstSource ↗

Render the editor panel in its own browser window while open is true.

Place it inside DocxEditorRoot around the parts to pop out. The root stays in this window, so the editor moves into the pop-out and back with its undo history, selection and collaboration session. The window gets this page's stylesheets. When the user closes it, the panel comes back and the component emits update:open with false and close.

The panel remounts on each move, which is what moves the editor; it is never retargeted.

DocxEditorWindow: vue.DefineComponent<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    url: {
        type: StringConstructor;
        default: undefined;
    };
    name: {
        type: StringConstructor;
        default: undefined;
    };
    features: {
        type: StringConstructor;
        default: undefined;
    };
    title: {
        type: StringConstructor;
        default: undefined;
    };
    styles: {
        type: PropType<DocxEditorWindowProps['styles']>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'update:open': (_open: boolean) => true;
    close: () => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    url: {
        type: StringConstructor;
        default: undefined;
    };
    name: {
        type: StringConstructor;
        default: undefined;
    };
    features: {
        type: StringConstructor;
        default: undefined;
    };
    title: {
        type: StringConstructor;
        default: undefined;
    };
    styles: {
        type: PropType<DocxEditorWindowProps['styles']>;
        default: undefined;
    };
}>> & Readonly<{
    onClose?: (() => any) | undefined;
    "onUpdate:open"?: ((_open: boolean) => any) | undefined;
}>, {
    url: string;
    name: string;
    features: string;
    title: string;
    styles: boolean | ((from: Document, to: Document) => () => void) | undefined;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
```vue
<DocxEditorRoot :document="bytes">
  <button @click="popped = !popped">Pop out</button>
  <DocxEditorWindow v-model:open="popped">
    <DocxEditorToolbar />
    <DocxEditorViewport>
      <DocxEditorContent />
    </DocxEditorViewport>
  </DocxEditorWindow>
</DocxEditorRoot>
```

HorizontalRulerconstSource ↗

HorizontalRuler: vue.DefineComponent<vue.ExtractPropTypes<{
    pageSetup: {
        type: PropType<RulerPageSetup | null>;
        default: null;
    };
    zoom: {
        type: NumberConstructor;
        default: number;
    };
    editable: {
        type: BooleanConstructor;
        default: boolean;
    };
    onLeftMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onRightMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onMarginDragEnd: {
        type: PropType<() => void>;
        default: undefined;
    };
    showIndentHandles: {
        type: BooleanConstructor;
        default: boolean;
    };
    indent: {
        type: PropType<RulerIndent | null>;
        default: null;
    };
    indentEditable: {
        type: BooleanConstructor;
        default: boolean;
    };
    onIndentChange: {
        type: PropType<(indent: RulerIndent) => void>;
        default: undefined;
    };
    onIndentDragEnd: {
        type: PropType<() => void>;
        default: undefined;
    };
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: string;
    };
    className: {
        type: StringConstructor;
        default: string;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
    tabMarks: {
        type: PropType<RulerTabStop[] | null>;
        default: null;
    };
    onTabMarkRemove: {
        type: PropType<(positionTwips: number) => void>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    pageSetup: {
        type: PropType<RulerPageSetup | null>;
        default: null;
    };
    zoom: {
        type: NumberConstructor;
        default: number;
    };
    editable: {
        type: BooleanConstructor;
        default: boolean;
    };
    onLeftMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onRightMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onMarginDragEnd: {
        type: PropType<() => void>;
        default: undefined;
    };
    showIndentHandles: {
        type: BooleanConstructor;
        default: boolean;
    };
    indent: {
        type: PropType<RulerIndent | null>;
        default: null;
    };
    indentEditable: {
        type: BooleanConstructor;
        default: boolean;
    };
    onIndentChange: {
        type: PropType<(indent: RulerIndent) => void>;
        default: undefined;
    };
    onIndentDragEnd: {
        type: PropType<() => void>;
        default: undefined;
    };
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: string;
    };
    className: {
        type: StringConstructor;
        default: string;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
    tabMarks: {
        type: PropType<RulerTabStop[] | null>;
        default: null;
    };
    onTabMarkRemove: {
        type: PropType<(positionTwips: number) => void>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    pageSetup: _docx_editor_dev_core.PageSetup | null;
    zoom: number;
    editable: boolean;
    onLeftMarginChange: (marginTwips: number) => void;
    onRightMarginChange: (marginTwips: number) => void;
    onMarginDragEnd: () => void;
    showIndentHandles: boolean;
    indent: RulerIndent | null;
    indentEditable: boolean;
    onIndentChange: (indent: RulerIndent) => void;
    onIndentDragEnd: () => void;
    unit: "cm" | "inch";
    className: string;
    style: CSSProperties;
    tabMarks: RulerTabStop[] | null;
    onTabMarkRemove: (positionTwips: number) => void;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ImageAltTextconstSource ↗

ImageAltText: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    hidden: boolean;
    asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ImageInsertProviderconstSource ↗

ImageInsertProvider: vue.DefineComponent<{}, () => (DocxEditorChildren | null)[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ImageInsertTriggerconstSource ↗

ImageInsertTrigger: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    hidden: boolean;
    asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ImagePropertiesTriggerconstSource ↗

Opens the image properties dialog for the selected drawing.

ImagePropertiesTrigger: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    hidden: boolean;
    asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ImageWrapconstSource ↗

ImageWrap: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    hidden: boolean;
    asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

LocaleProviderconstSource ↗

LocaleProvider: vue.DefineComponent<vue.ExtractPropTypes<{
    i18n: {
        type: PropType<Translations>;
        default: undefined;
    };
    dir: {
        type: PropType<'ltr' | 'rtl'>;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    i18n: {
        type: PropType<Translations>;
        default: undefined;
    };
    dir: {
        type: PropType<'ltr' | 'rtl'>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    i18n: _docx_editor_dev_i18n.PartialLocaleStrings;
    dir: "ltr" | "rtl";
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

Deprecated. Use `<DocxEditor>` title slots instead.

Logo: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

Deprecated. Use `<DocxEditor.Menu>` instead.

MenuBar: DocxEditorMenuNamespace

Clearance kept between the panel's right edge and the page.

NAVIGATION_PANE_GAP = 16

Gap between the viewport's left edge and the panel.

Clears a vertical ruler: RULER_WIDTH is 20px pinned at the viewport's left edge, so anything less puts the panel and its collapsed disc on top of the tick marks.

NAVIGATION_PANE_INSET = 32

The narrowest page column, in px, an open pane must leave beside it.

Below it a shift cannot help: a 390px phone viewport less the default 328px reservation leaves a 62px strip of page. There the pane overlays the page instead, at the viewport's full width less its inset on each side, and the page does not move.

NAVIGATION_PANE_MIN_PAGE_ROOM = 320

Panel width, in px, when the host does not choose one.

NAVIGATION_PANE_WIDTH = 280
NavigationClose: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
NavigationFind: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

The Bookmarks panel: a bookmark search box, the sort order and hidden-bookmarks toggle, and the bookmarks it offers, grouped by place when sorted by location.

NavigationGoTo: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
NavigationHeader: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
NavigationHeadings: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
NavigationTab: vue.DefineComponent<vue.ExtractPropTypes<{
    value: {
        type: PropType<NavigationTab$1>;
        required: true;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    value: {
        type: PropType<NavigationTab$1>;
        required: true;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
NavigationTabs: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
NavigationTitle: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>
NavigationToggle: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

OBJECT_SLOT_PARTSconstSource ↗

The packaged part of each shape and chart slot.

OBJECT_SLOT_PARTS: Readonly<Record<ObjectSlotId, Component>>

OUTLINE_BUTTON_LEFT_OFFSETconstSource ↗

OUTLINE_BUTTON_LEFT_OFFSET = 12

OUTLINE_BUTTON_RESERVED_SPACEconstSource ↗

OUTLINE_BUTTON_RESERVED_SPACE: number

OUTLINE_LEFT_OFFSETconstSource ↗

OUTLINE_LEFT_OFFSET = 12

OUTLINE_RESERVED_SPACEconstSource ↗

OUTLINE_RESERVED_SPACE: number

PageIndicatorconstSource ↗

PageIndicator: vue.DefineComponent<vue.ExtractPropTypes<{
    currentPage: {
        type: NumberConstructor;
        required: true;
    };
    totalPages: {
        type: NumberConstructor;
        required: true;
    };
    visible: {
        type: BooleanConstructor;
        required: true;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    currentPage: {
        type: NumberConstructor;
        required: true;
    };
    totalPages: {
        type: NumberConstructor;
        required: true;
    };
    visible: {
        type: BooleanConstructor;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

PageNumberTranslationContextconstSource ↗

Internal bridge from the batteries-included editor's t prop to this composition part.

PageNumberTranslationContext: InjectionKey<((key: string) => string) | null>

PaginatedDocxEditorconstSource ↗

PaginatedDocxEditor: vue.DefineComponent<vue.ExtractPropTypes<{
    source: {
        type: PropType<Uint8Array>;
        required: true;
    };
    scale: {
        type: NumberConstructor;
        default: undefined;
    };
    measurer: {
        type: PropType<TextMeasurer>;
        default: undefined;
    };
    onStateChange: {
        type: PropType<(state: PaginatedSurfaceState) => void>;
        default: undefined;
    };
    onError: {
        type: PropType<(reason: string, detail?: string) => void>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    documentFontFamily: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => VNode, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    source: {
        type: PropType<Uint8Array>;
        required: true;
    };
    scale: {
        type: NumberConstructor;
        default: undefined;
    };
    measurer: {
        type: PropType<TextMeasurer>;
        default: undefined;
    };
    onStateChange: {
        type: PropType<(state: PaginatedSurfaceState) => void>;
        default: undefined;
    };
    onError: {
        type: PropType<(reason: string, detail?: string) => void>;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    documentFontFamily: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    scale: number;
    measurer: TextMeasurer;
    onStateChange: (state: PaginatedSurfaceState) => void;
    onError: (reason: string, detail?: string) => void;
    className: string;
    documentFontFamily: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

PaginatedDocxEditorShellconstSource ↗

Deprecated. Use `<DocxEditor>` from the composition layer instead.

PaginatedDocxEditorShell: vue.DefineComponent<vue.ExtractPropTypes<{
    source: {
        type: PropType<Uint8Array>;
        required: true;
    };
    documentName: {
        type: StringConstructor;
        default: undefined;
    };
    scale: {
        type: NumberConstructor;
        default: undefined;
    };
    measurer: {
        type: PropType<TextMeasurer>;
        default: undefined;
    };
    onStateChange: {
        type: PropType<(state: PaginatedSurfaceState) => void>;
        default: undefined;
    };
    onError: {
        type: PropType<(reason: string, detail?: string) => void>;
        default: undefined;
    };
    onSave: {
        type: PropType<(bytes: Uint8Array) => void>;
        default: undefined;
    };
    colorMode: {
        type: PropType<'light' | 'dark'>;
        default: undefined;
    };
    onZoomChange: {
        type: PropType<(zoom: number) => void>;
        default: undefined;
    };
    documentFontFamily: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    source: {
        type: PropType<Uint8Array>;
        required: true;
    };
    documentName: {
        type: StringConstructor;
        default: undefined;
    };
    scale: {
        type: NumberConstructor;
        default: undefined;
    };
    measurer: {
        type: PropType<TextMeasurer>;
        default: undefined;
    };
    onStateChange: {
        type: PropType<(state: PaginatedSurfaceState) => void>;
        default: undefined;
    };
    onError: {
        type: PropType<(reason: string, detail?: string) => void>;
        default: undefined;
    };
    onSave: {
        type: PropType<(bytes: Uint8Array) => void>;
        default: undefined;
    };
    colorMode: {
        type: PropType<'light' | 'dark'>;
        default: undefined;
    };
    onZoomChange: {
        type: PropType<(zoom: number) => void>;
        default: undefined;
    };
    documentFontFamily: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    documentName: string;
    scale: number;
    measurer: TextMeasurer;
    onStateChange: (state: PaginatedSurfaceState) => void;
    onError: (reason: string, detail?: string) => void;
    onSave: (bytes: Uint8Array) => void;
    colorMode: "dark" | "light";
    onZoomChange: (zoom: number) => void;
    documentFontFamily: string;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

REVIEW_MARKERS_GUTTERconstSource ↗

Reservation for markers and the add-comment button.

REVIEW_MARKERS_GUTTER = 44

REVIEW_PANE_GUTTERconstSource ↗

Full reservation for the card column and page-edge gap.

REVIEW_PANE_GUTTER = 316

ReviewRailContextconstSource ↗

ReviewRailContext: InjectionKey<ShallowRef<ReviewRailRegistry>>

RULER_WIDTHconstSource ↗

RULER_WIDTH = 20

SlotconstSource ↗

Renders its single child vnode with the slot props merged in.

Slot: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

TitleBarconstSource ↗

Deprecated. Use `<DocxEditor>` title slots instead.

TitleBar: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

TitleBarRightconstSource ↗

Deprecated. Use `<DocxEditor>` title slots instead.

TitleBarRight: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ToolbarconstSource ↗

Deprecated. Use `DocxEditor.Toolbar` from the composition layer instead.

Toolbar: vue.DefineComponent<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, {
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ToolbarButtonconstSource ↗

Deprecated. Use `DocxEditor.Toolbar` button parts instead.

ToolbarButton: vue.DefineComponent<vue.ExtractPropTypes<{
    active: {
        type: BooleanConstructor;
        default: undefined;
    };
    disabled: {
        type: BooleanConstructor;
        default: undefined;
    };
    title: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    ariaLabel: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "click"[], "click", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    active: {
        type: BooleanConstructor;
        default: undefined;
    };
    disabled: {
        type: BooleanConstructor;
        default: undefined;
    };
    title: {
        type: StringConstructor;
        default: undefined;
    };
    className: {
        type: StringConstructor;
        default: undefined;
    };
    ariaLabel: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{
    onClick?: ((...args: any[]) => any) | undefined;
}>, {
    active: boolean;
    disabled: boolean;
    title: string;
    className: string;
    ariaLabel: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ToolbarChartInsertconstSource ↗

ToolbarChartInsert: ChartInsertPartComponent

ToolbarContextconstSource ↗

ToolbarContext: InjectionKey<MaybeRef<ToolbarContextValue>>

ToolbarGroupconstSource ↗

Deprecated. Use `DocxEditor.Toolbar` group parts instead.

ToolbarGroup: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ToolbarImagePropertiesconstSource ↗

ToolbarImageProperties: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        asChild: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        className: string;
        hidden: boolean;
        asChild: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        className: {
            type: StringConstructor;
            default: undefined;
        };
        hidden: {
            type: BooleanConstructor;
            default: undefined;
        };
        asChild: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        className: string;
        hidden: boolean;
        asChild: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    className: {
        type: StringConstructor;
        default: undefined;
    };
    hidden: {
        type: BooleanConstructor;
        default: undefined;
    };
    asChild: {
        type: BooleanConstructor;
        default: undefined;
    };
}>> & Readonly<{}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    className: string;
    hidden: boolean;
    asChild: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxSlot: 'image.properties';
}

VERSIONconstSource ↗

VERSION: string

VerticalRulerconstSource ↗

VerticalRuler: vue.DefineComponent<vue.ExtractPropTypes<{
    pageSetup: {
        type: PropType<RulerPageSetup | null>;
        default: null;
    };
    zoom: {
        type: NumberConstructor;
        default: number;
    };
    editable: {
        type: BooleanConstructor;
        default: boolean;
    };
    onTopMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onBottomMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onMarginDragEnd: {
        type: PropType<() => void>;
        default: undefined;
    };
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: string;
    };
    className: {
        type: StringConstructor;
        default: string;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    pageSetup: {
        type: PropType<RulerPageSetup | null>;
        default: null;
    };
    zoom: {
        type: NumberConstructor;
        default: number;
    };
    editable: {
        type: BooleanConstructor;
        default: boolean;
    };
    onTopMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onBottomMarginChange: {
        type: PropType<(marginTwips: number) => void>;
        default: undefined;
    };
    onMarginDragEnd: {
        type: PropType<() => void>;
        default: undefined;
    };
    unit: {
        type: PropType<'inch' | 'cm'>;
        default: string;
    };
    className: {
        type: StringConstructor;
        default: string;
    };
    style: {
        type: PropType<CSSProperties>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    pageSetup: _docx_editor_dev_core.PageSetup | null;
    zoom: number;
    editable: boolean;
    onTopMarginChange: (marginTwips: number) => void;
    onBottomMarginChange: (marginTwips: number) => void;
    onMarginDragEnd: () => void;
    unit: "cm" | "inch";
    className: string;
    style: CSSProperties;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>