@docx-editor.dev/vue

isFieldLinkfunctionSource ↗

declare function isFieldLink(link: SurfaceHyperlink): boolean;

navigationPaneReservationfunctionSource ↗

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

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

navigationShiftfunctionSource ↗

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;

useChromeTranslatefunctionSource ↗

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

useContentControlfunctionSource ↗

declare function useContentControl(): UseContentControlResult;

useContentControlInstancefunctionSource ↗

declare function useContentControlInstance(): UseContentControlResult;

useContextMenuTargetfunctionSource ↗

declare function useContextMenuTarget(): HTMLElement | null;

useDocumentOutlinefunctionSource ↗

declare function useDocumentOutline(): UseDocumentOutlineResult;

useDocumentSearchfunctionSource ↗

declare function useDocumentSearch(): 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>;

useEditorCommandfunctionSource ↗

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

useEditorEventfunctionSource ↗

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

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 ↗

declare function useEditorValueCommand(slotId: 'image.wrap'): EditorValueCommandState<ImageWrapTarget>;

useEditorValueCommandfunctionSource ↗

declare function useEditorValueCommand(slotId: 'image.altText'): EditorValueCommandState<string>;

useFontFamilyfunctionSource ↗

declare function useFontFamily(): UseFontFamilyResult;

useFontsfunctionSource ↗

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

useHeaderFooterStatefunctionSource ↗

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

useHyperlinkPopupfunctionSource ↗

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>;

usePageSetupfunctionSource ↗

declare function usePageSetup(): UsePageSetupReturn;

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>;

useScopeClassNamefunctionSource ↗

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

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: AnchorPlacement): ScopedChromeAnchor;

useTableBorderTargetLabelfunctionSource ↗

declare function useTableBorderTargetLabel(): ComputedRef<string>;

useToolbarContextfunctionSource ↗

declare function useToolbarContext(): ComputedRef<ToolbarContextValue>;

useToolbarLabelfunctionSource ↗

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

useToolbarLabelForfunctionSource ↗

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

useTranslationfunctionSource ↗

declare function useTranslation(): {
    t: TFunction;
    catalogue: ShallowRef<LocaleStrings>;
};

useZoomfunctionSource ↗

declare function useZoom(): UseZoomResult;

ContentControlActionPropsinterfaceSource ↗

Props for action parts that also take an icon.

interface ContentControlActionProps extends ContentControlPartProps

ContentControlInspectorStateinterfaceSource ↗

interface ContentControlInspectorState

ContentControlPartPropsinterfaceSource ↗

Shared props for every part.

interface ContentControlPartProps

ContentControlPropsinterfaceSource ↗

Props for DocxEditor.ContentControl.

interface ContentControlProps extends ContentControlPartProps

ContextMenuAnchorinterfaceSource ↗

interface ContextMenuAnchor

ContextMenuCommandPropsinterfaceSource ↗

Props for a packaged context-menu row.

interface ContextMenuCommandProps

ContextMenuContextValueinterfaceSource ↗

interface ContextMenuContextValue

ContextMenuItemPropsinterfaceSource ↗

interface ContextMenuItemProps

ContextMenuTableRowPropsinterfaceSource ↗

interface ContextMenuTableRowProps extends ContextMenuCommandProps

DocxEditorAuthorStylePropsinterfaceSource ↗

interface DocxEditorAuthorStyleProps extends RevisionAuthorStyle

DocxEditorContentControlNamespaceinterfaceSource ↗

interface DocxEditorContentControlNamespace

DocxEditorContentPropsinterfaceSource ↗

interface DocxEditorContentProps

DocxEditorContextMenuNamespaceinterfaceSource ↗

interface DocxEditorContextMenuNamespace

DocxEditorContextMenuPropsinterfaceSource ↗

interface DocxEditorContextMenuProps

DocxEditorDocumentOutlinePropsinterfaceSource ↗

Props for the context-fed outline part.

interface DocxEditorDocumentOutlineProps

DocxEditorFontNoticePropsinterfaceSource ↗

Props for DocxEditor.FontNotice.

interface DocxEditorFontNoticeProps

DocxEditorHeaderFooterChromePropsinterfaceSource ↗

Props for DocxEditor.HeaderFooterChrome.

interface DocxEditorHeaderFooterChromeProps

DocxEditorHyperLinkNamespaceinterfaceSource ↗

interface DocxEditorHyperLinkNamespace

DocxEditorImagePropertiesDialogPropsinterfaceSource ↗

Props for DocxEditor.ImagePropertiesDialog.

interface DocxEditorImagePropertiesDialogProps

DocxEditorLoadingComponentinterfaceSource ↗

interface DocxEditorLoadingComponent

DocxEditorLoadingPropsinterfaceSource ↗

Props for DocxEditor.Loading.

interface DocxEditorLoadingProps

DocxEditorLoadingSpinnerPropsinterfaceSource ↗

Props for DocxEditor.Loading.Spinner.

interface DocxEditorLoadingSpinnerProps

DocxEditorMenuNamespaceinterfaceSource ↗

interface DocxEditorMenuNamespace

DocxEditorMenuPropsinterfaceSource ↗

interface DocxEditorMenuProps

DocxEditorNamespaceinterfaceSource ↗

interface DocxEditorNamespace

DocxEditorNavigationNamespaceinterfaceSource ↗

interface DocxEditorNavigationNamespace

DocxEditorNavigationPropsinterfaceSource ↗

Props for DocxEditor.Navigation.

interface DocxEditorNavigationProps extends UseNavigationPaneOptions

DocxEditorNotesChromePropsinterfaceSource ↗

interface DocxEditorNotesChromeProps

DocxEditorPageNumberPropsinterfaceSource ↗

Props for DocxEditor.PageNumber.

interface DocxEditorPageNumberProps

DocxEditorPageSetupDialogPropsinterfaceSource ↗

interface DocxEditorPageSetupDialogProps

DocxEditorPropsinterfaceSource ↗

Props for the Vue DocxEditor sugar host.

interface DocxEditorProps

DocxEditorRefinterfaceSource ↗

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

interface DocxEditorRef

DocxEditorRootListenersinterfaceSource ↗

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

interface DocxEditorRootListeners

DocxEditorRootPropsinterfaceSource ↗

interface DocxEditorRootProps

DocxEditorRulerPropsinterfaceSource ↗

interface DocxEditorRulerProps

DocxEditorToolbarNamespaceinterfaceSource ↗

interface DocxEditorToolbarNamespace

DocxEditorToolbarPropsinterfaceSource ↗

interface DocxEditorToolbarProps

DocxEditorViewportPropsinterfaceSource ↗

interface DocxEditorViewportProps

EditorCaretinterfaceSource ↗

interface EditorCaret

EditorCommandStateinterfaceSource ↗

interface EditorCommandState

EditorValueCommandStateinterfaceSource ↗

interface EditorValueCommandState<T extends string | number>

FontFamilyItemPropsinterfaceSource ↗

interface FontFamilyItemProps extends FontFamilyPartProps

FontFamilyNamespaceinterfaceSource ↗

interface FontFamilyNamespace

FontFamilyPartPropsinterfaceSource ↗

interface FontFamilyPartProps

FontFamilyPropsinterfaceSource ↗

interface FontFamilyProps extends FontFamilyPartProps

HorizontalRulerPropsinterfaceSource ↗

interface HorizontalRulerProps

HyperLinkActionPropsinterfaceSource ↗

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

interface HyperLinkActionProps extends HyperLinkPartProps

HyperLinkPartPropsinterfaceSource ↗

Shared props for every part.

interface HyperLinkPartProps

HyperlinkPopupAnchorinterfaceSource ↗

interface HyperlinkPopupAnchor

HyperlinkPopupStateinterfaceSource ↗

interface HyperlinkPopupState

HyperLinkPropsinterfaceSource ↗

Props for DocxEditor.HyperLink.

interface HyperLinkProps extends HyperLinkPartProps

ImagePropertiesTriggerPropsinterfaceSource ↗

Props for the toolbar properties trigger.

interface ImagePropertiesTriggerProps

IndentUpdateinterfaceSource ↗

interface IndentUpdate

LocaleProviderPropsinterfaceSource ↗

interface LocaleProviderProps

MenuActionPropsinterfaceSource ↗

Props for the pinned File rows.

interface MenuActionProps

MenuGroupPropsinterfaceSource ↗

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

interface MenuGroupProps

MenuItemPropsinterfaceSource ↗

Props for DocxEditor.Menu.Item: one chrome slot as a menu row.

interface MenuItemProps

MenuPartComponentinterfaceSource ↗

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

interface MenuPartComponent

MenuPropsinterfaceSource ↗

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

interface MenuProps

MenuReportIssuePropsinterfaceSource ↗

Props for DocxEditor.Menu.ReportIssue.

interface MenuReportIssueProps

MenuRowPropsinterfaceSource ↗

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

interface MenuRowProps

MenuSeparatorPropsinterfaceSource ↗

Props for DocxEditor.Menu.Separator.

interface MenuSeparatorProps

MenuSubmenuPropsinterfaceSource ↗

interface MenuSubmenuProps

MenuTableGridPropsinterfaceSource ↗

Props for DocxEditor.Menu.TableGrid.

interface MenuTableGridProps

NavigationPartPropsinterfaceSource ↗

Shared props for the pane's structural parts.

interface NavigationPartProps

NavigationShiftInputinterfaceSource ↗

interface NavigationShiftInput

NavigationTabPropsinterfaceSource ↗

interface NavigationTabProps extends NavigationPartProps

OutlineHeadingIteminterfaceSource ↗

interface OutlineHeadingItem

PageIndicatorPropsinterfaceSource ↗

interface PageIndicatorProps

PageSetupUpdateinterfaceSource ↗

interface PageSetupUpdate

PaginatedDocxEditorHandleinterfaceSource ↗

interface PaginatedDocxEditorHandle

PaginatedDocxEditorPropsinterfaceSource ↗

interface PaginatedDocxEditorProps

PaginatedDocxEditorShellPropsinterfaceSource ↗

interface PaginatedDocxEditorShellProps

ParagraphStyleItemPropsinterfaceSource ↗

interface ParagraphStyleItemProps extends ParagraphStylePartProps

ParagraphStyleNamespaceinterfaceSource ↗

interface ParagraphStyleNamespace

ParagraphStyleOptioninterfaceSource ↗

interface ParagraphStyleOption

ParagraphStylePartPropsinterfaceSource ↗

interface ParagraphStylePartProps

ParagraphStylePropsinterfaceSource ↗

interface ParagraphStyleProps extends ParagraphStylePartProps

ProvideDocxEditorResultinterfaceSource ↗

interface ProvideDocxEditorResult

ReviewGutterinterfaceSource ↗

Scroll-container reservations on each inline edge.

interface ReviewGutter

ReviewGutterInputinterfaceSource ↗

Inputs for [reviewGutter](reviewGutter).

interface ReviewGutterInput

ReviewRailRegistryinterfaceSource ↗

interface ReviewRailRegistry

ScopedChromeAnchorinterfaceSource ↗

interface ScopedChromeAnchor

SlotPropsinterfaceSource ↗

interface SlotProps

TableBorderColorNamespaceinterfaceSource ↗

interface TableBorderColorNamespace extends TableChromePartComponent

TableBorderStyleNamespaceinterfaceSource ↗

interface TableBorderStyleNamespace extends TableChromePartComponent

TableBorderTargetNamespaceinterfaceSource ↗

interface TableBorderTargetNamespace extends TableChromePartComponent

TableBorderWidthNamespaceinterfaceSource ↗

interface TableBorderWidthNamespace extends TableChromePartComponent

TableCellFillNamespaceinterfaceSource ↗

interface TableCellFillNamespace extends TableChromePartComponent

TableChromeItemPropsinterfaceSource ↗

interface TableChromeItemProps extends TableChromePartProps

TableChromePartComponentinterfaceSource ↗

interface TableChromePartComponent extends ToolbarSlotPartComponent

TableChromePartPropsinterfaceSource ↗

interface TableChromePartProps

ToolbarActionPropsinterfaceSource ↗

interface ToolbarActionProps

ToolbarAlignmentComponentinterfaceSource ↗

interface ToolbarAlignmentComponent

ToolbarButtonPropsinterfaceSource ↗

interface ToolbarButtonProps

ToolbarContextValueinterfaceSource ↗

interface ToolbarContextValue

ToolbarPartComponentinterfaceSource ↗

interface ToolbarPartComponent

ToolbarPropsinterfaceSource ↗

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

Props for the deprecated formatting rail.

interface ToolbarProps

ToolbarSeparatorPropsinterfaceSource ↗

interface ToolbarSeparatorProps

ToolbarSlotPartComponentinterfaceSource ↗

interface ToolbarSlotPartComponent

ToolbarSlotPartPropsinterfaceSource ↗

interface ToolbarSlotPartProps

UseContentControlResultinterfaceSource ↗

interface UseContentControlResult

UseDocumentOutlineResultinterfaceSource ↗

interface UseDocumentOutlineResult

UseDocumentSearchResultinterfaceSource ↗

interface UseDocumentSearchResult

UseDocxSourceOptionsinterfaceSource ↗

interface UseDocxSourceOptions

UseDocxSourceResultinterfaceSource ↗

interface UseDocxSourceResult

UseFontFamilyResultinterfaceSource ↗

interface UseFontFamilyResult

UseHyperlinkPopupResultinterfaceSource ↗

interface UseHyperlinkPopupResult

UseNavigationPaneOptionsinterfaceSource ↗

interface UseNavigationPaneOptions

UseNavigationPaneResultinterfaceSource ↗

interface UseNavigationPaneResult

UsePageSetupReturninterfaceSource ↗

interface UsePageSetupReturn

UseParagraphIndentReturninterfaceSource ↗

interface UseParagraphIndentReturn

UseParagraphStyleResultinterfaceSource ↗

interface UseParagraphStyleResult

UseZoomResultinterfaceSource ↗

interface UseZoomResult

VerticalRulerPropsinterfaceSource ↗

interface VerticalRulerProps

ChromeTranslatetypeSource ↗

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

ContentControlLocktypeSource ↗

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

ContentControlSlotIdtypeSource ↗

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

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;

DocxFontsInputtypeSource ↗

type DocxFontsInput = FontConfiguration | FontConfigurationFragment;

DocxFontsSourcetypeSource ↗

type DocxFontsSource = DocxFontsInput | Promise<DocxFontsInput> | (() => DocxFontsInput | Promise<DocxFontsInput>);

DocxSourcetypeSource ↗

type DocxSource = string | URL | Uint8Array | ArrayBuffer;

EditorModetypeSource ↗

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

FontsInputtypeSource ↗

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

HeaderFooterStatetypeSource ↗

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

HyperlinkPopupModetypeSource ↗

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

MaybeRefOrGettertypeSource ↗

Reactive input accepted by Vue composables.

type MaybeRefOrGetter<T> = T | Ref<T> | (() => T);

MenuIdtypeSource ↗

type MenuId = ChromeMenuId | (string & {});

NavigationTabValuetype

type NavigationTab$1 = 'headings' | 'find';

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>;

OutlineHeadingtypeSource ↗

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

PaginatedDocxEditorExposetypeSource ↗

Vue name for the same contract React exports as PaginatedDocxEditorExpose.

type PaginatedDocxEditorExpose = PaginatedDocxEditorHandle;

ToolbarPartPropstypeSource ↗

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

ToolbarTranslatetypeSource ↗

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

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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }, 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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }>;
    __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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
}, {}, 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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }, 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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }>;
    __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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
}, {}, 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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }, 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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }>;
    __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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
}, {}, 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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
        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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
    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<{}>, {
    disabledReason: string;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    active: boolean;
    disabled: boolean;
    className: string;
    onSelect: () => void;
    shortcut: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

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<{}>, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
}, {}, {}, {}, 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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
    }, 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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
    }>;
    __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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
}, {}, 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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
    }, 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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        className: string;
    }>;
    __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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    className: string;
}, {}, 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, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }, 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, {}, {}, {}, {
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        labelKey: string;
        shortcutKey: string;
        className: string;
    }>;
    __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, {
    hidden: boolean;
    icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    labelKey: string;
    shortcutKey: string;
    className: string;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    docxRow: 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;
    };
}

DocxEditorColorByChangeTypeconstSource ↗

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

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

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<{}>, {
    t: ToolbarTranslate;
    disabled: boolean;
    className: string;
    preset: 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>

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<{}>, {
    t: TFunction;
    style: CSSProperties;
    className: string;
}, {}, {}, {}, 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<{}>, {
    style: CSSProperties;
    className: string;
    unit: "cm" | "inch";
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorHyperLinkconstSource ↗

DocxEditorHyperLink: DocxEditorHyperLinkNamespace

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>

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

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>

DocxEditorPageNumberconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorPageSetupDialogconstSource ↗

DocxEditorPageSetupDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    open: {
        type: BooleanConstructor;
        required: true;
    };
    onClose: {
        type: PropType<() => void>;
        required: true;
    };
    className: {
        type: StringConstructor;
        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;
    };
}>> & Readonly<{}>, {
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorRootconstSource ↗

DocxEditorRoot: vue.DefineComponent<vue.ExtractPropTypes<{
    document: {
        type: PropType<DocumentSource>;
        default: undefined;
    };
    fonts: {
        type: PropType<DocxEditorRootProps["fonts"]>;
        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;
    };
    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;
    };
}>, () => 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;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    document: {
        type: PropType<DocumentSource>;
        default: undefined;
    };
    fonts: {
        type: PropType<DocxEditorRootProps["fonts"]>;
        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;
    };
    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;
    };
}>> & Readonly<{
    onChange?: ((_change: DocumentChange) => any) | undefined;
    onReady?: ((_editor: Editor) => any) | undefined;
    onFontError?: ((_error: unknown) => any) | undefined;
}>, {
    document: DocumentSource;
    locale: string;
    zoom: number;
    fonts: _docx_editor_dev_core.FontConfiguration | _docx_editor_dev_core.FontConfigurationFragment | _docx_editor_dev_core.FontResolver | undefined;
    author: string;
    mode: "suggesting" | "edit" | "view";
    imageDecodePort: ImageDecodePort;
    translate: ((key: string, params?: Record<string, string | number>) => string) | undefined;
    modules: readonly EditorModule[];
    tableInteractionLabel: ((key: "table.insertRowBelow" | "table.insertColumnRight") => string) | undefined;
    zoomMode: "auto" | ZoomMode;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorShellconstSource ↗

Deprecated. Use `<DocxEditor>` instead.

DocxEditorShell: DocxEditorNamespace

DocxEditorToolbarconstSource ↗

DocxEditorToolbar: DocxEditorToolbarNamespace

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<{}>, {
    style: CSSProperties;
    className: string;
    unit: "cm" | "inch";
}, {}, {}, {}, 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<{}>, {
    style: CSSProperties;
    class: string;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

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<{}>, {
    zoom: number;
    pageSetup: _docx_editor_dev_core.PageSetup | null;
    style: CSSProperties;
    indent: RulerIndent | null;
    editable: boolean;
    className: string;
    onLeftMarginChange: (marginTwips: number) => void;
    onRightMarginChange: (marginTwips: number) => void;
    onMarginDragEnd: () => void;
    showIndentHandles: boolean;
    indentEditable: boolean;
    onIndentChange: (indent: RulerIndent) => void;
    onIndentDragEnd: () => void;
    unit: "cm" | "inch";
    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<{}>, {
    hidden: boolean;
    className: string;
    asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

ImageInsertProviderconstSource ↗

ImageInsertProvider: 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>

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<{}>, {
    hidden: boolean;
    className: string;
    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<{}>, {
    hidden: boolean;
    className: string;
    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<{}>, {
    hidden: boolean;
    className: string;
    asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

LocaleProviderconstSource ↗

LocaleProvider: vue.DefineComponent<vue.ExtractPropTypes<{
    i18n: {
        type: PropType<Translations>;
        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;
    };
}>> & Readonly<{}>, {
    i18n: _docx_editor_dev_i18n.PartialLocaleStrings;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

LogoconstSource ↗

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>

MenuBarconstSource ↗

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

MenuBar: DocxEditorMenuNamespace

NAVIGATION_PANE_GAPconstSource ↗

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

NAVIGATION_PANE_GAP = 16

NAVIGATION_PANE_INSETconstSource ↗

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

NAVIGATION_PANE_WIDTHconstSource ↗

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

NAVIGATION_PANE_WIDTH = 280

NavigationCloseconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

NavigationFindconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

NavigationHeaderconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

NavigationHeadingsconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

NavigationTabconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

NavigationTabsconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

NavigationTitleconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

NavigationToggleconstSource ↗

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<{}>, {
    style: CSSProperties;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

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<{}>, {
    measurer: TextMeasurer;
    scale: number;
    className: string;
    onError: (reason: string, detail?: string) => void;
    onStateChange: (state: PaginatedSurfaceState) => void;
    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<{}>, {
    measurer: TextMeasurer;
    scale: number;
    className: string;
    onError: (reason: string, detail?: string) => void;
    onSave: (bytes: Uint8Array) => void;
    colorMode: "light" | "dark";
    onStateChange: (state: PaginatedSurfaceState) => void;
    documentFontFamily: string;
    documentName: string;
    onZoomChange: (zoom: number) => void;
}, {}, {}, {}, 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

SEARCH_DEBOUNCE_MSconstSource ↗

SEARCH_DEBOUNCE_MS = 150

SEARCH_MATCH_LIMITconstSource ↗

SEARCH_MATCH_LIMIT = 2000

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;
}>, {
    ariaLabel: string;
    title: string;
    active: boolean;
    disabled: boolean;
    className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

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, {
        hidden: boolean;
        className: string;
        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, {}, {}, {}, {
        hidden: boolean;
        className: string;
        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, {
    hidden: boolean;
    className: string;
    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<{}>, {
    zoom: number;
    pageSetup: _docx_editor_dev_core.PageSetup | null;
    style: CSSProperties;
    editable: boolean;
    className: string;
    onMarginDragEnd: () => void;
    unit: "cm" | "inch";
    onTopMarginChange: (marginTwips: number) => void;
    onBottomMarginChange: (marginTwips: number) => void;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>