@a3s-lab/office 0.29.0 → 0.31.0

package/dist/internal/features/work/editors/document-command-catalog.d.ts

@@ -598,6 +598,51 @@ export declare const documentCommandCatalog: {
             readonly editor: readonly ["Mod-Shift-e"];
         };
     };
+    readonly tableOfContents: {
+        readonly id: "references.tableOfContents";
+        readonly label: "插入或自定义目录";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "references";
+            readonly group: "tableOfContents";
+        };
+    };
+    readonly refreshTableOfContents: {
+        readonly id: "references.refreshTableOfContents";
+        readonly label: "更新目录";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "references";
+            readonly group: "tableOfContents";
+        };
+    };
+    readonly markIndexEntry: {
+        readonly id: "references.markIndexEntry";
+        readonly label: "标记索引项";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "references";
+            readonly group: "index";
+        };
+    };
+    readonly index: {
+        readonly id: "references.index";
+        readonly label: "插入或自定义索引";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "references";
+            readonly group: "index";
+        };
+    };
+    readonly refreshIndex: {
+        readonly id: "references.refreshIndex";
+        readonly label: "更新索引";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "references";
+            readonly group: "index";
+        };
+    };
     readonly refreshFields: {
         readonly id: "references.refreshFields";
         readonly label: "更新域";

package/dist/internal/features/work/editors/document-dom-selection.d.ts

@@ -0,0 +1,7 @@
+import type { Editor } from '@tiptap/core';
+/**
+ * Reconciles a visible browser text selection before a capture-phase command
+ * snapshots editor state. Selection-change delivery can lag behind a keyboard
+ * shortcut under load, leaving ProseMirror with an older collapsed selection.
+ */
+export declare function synchronizeDocumentEditorSelectionFromDom(editor: Editor): boolean;

package/dist/internal/features/work/editors/document-editor-support.d.ts

@@ -28,3 +28,4 @@ interface CustomSelectionMenuItem<Context> {
 export declare function customSelectionMenuItems<Context>(items: readonly CustomSelectionMenuItem<Context>[], createAction: () => CustomSelectionAction<Context>): WorkspaceContextMenuItem[];
 export declare function documentPageCount(editor: Editor): number;
 export declare function documentCurrentPage(editor: Editor): number;
+export declare function documentHasRefreshableFields(editor: Editor): boolean;

package/dist/internal/features/work/editors/document-font-dialog-model.d.ts

@@ -2,6 +2,7 @@ import type { Editor } from '@tiptap/core';
 import { type WorkDocumentEmphasisMark } from '../work-document-emphasis';
 import { type DocumentFontDialogScriptFontPatch, type DocumentFontFamilySource } from './document-font-dialog-script-font-model';
 import { type DocumentFontDialogRunBorderDraft, type DocumentFontDialogRunBorderPatch, type DocumentFontDialogRunBorderSource } from './document-font-dialog-run-border-model';
+import { type DocumentFontDialogRunShadingDraft, type DocumentFontDialogRunShadingPatch, type DocumentFontDialogRunShadingSource } from './document-font-dialog-run-shading-model';
 export type { DocumentFontFamilySource } from './document-font-dialog-script-font-model';
 export type DocumentCharacterSpacingMode = 'condensed' | 'expanded' | 'mixed' | 'normal';
 export type DocumentCharacterPositionMode = 'lowered' | 'mixed' | 'normal' | 'raised';
@@ -49,6 +50,7 @@ export interface DocumentFontDialogSource {
         value: boolean | null;
     };
     runBorder: DocumentFontDialogRunBorderSource;
+    runShading: DocumentFontDialogRunShadingSource;
     latinFont: DocumentFontFamilySource;
     eastAsiaFont: DocumentFontFamilySource;
     complexScriptFont: DocumentFontFamilySource;
@@ -57,7 +59,7 @@ export interface DocumentFontDialogSource {
     previewText: string;
     selectedCharacters: number;
 }
-export interface DocumentFontDialogDraft extends DocumentFontDialogRunBorderDraft {
+export interface DocumentFontDialogDraft extends DocumentFontDialogRunBorderDraft, DocumentFontDialogRunShadingDraft {
     characterScaleMode: DocumentCharacterScaleMode;
     characterScalePercent: string;
     characterPositionMode: DocumentCharacterPositionMode;
@@ -76,7 +78,7 @@ export interface DocumentFontDialogDraft extends DocumentFontDialogRunBorderDraf
     eastAsiaFont: string;
     complexScriptFont: string;
 }
-export interface DocumentFontDialogPatch extends DocumentFontDialogScriptFontPatch, DocumentFontDialogRunBorderPatch {
+export interface DocumentFontDialogPatch extends DocumentFontDialogScriptFontPatch, DocumentFontDialogRunBorderPatch, DocumentFontDialogRunShadingPatch {
     characterScalePercent?: number;
     characterPositionHalfPoints?: number;
     characterSpacingTwips?: number;
@@ -101,6 +103,7 @@ export interface DocumentFontDialogTouched {
     legacyTextEmboss: boolean;
     legacyTextImprint: boolean;
     runBorder: boolean;
+    runShading: boolean;
     kerning: boolean;
     latinFont: boolean;
 }

package/dist/internal/features/work/editors/document-font-dialog-run-shading-model.d.ts

@@ -0,0 +1,23 @@
+import type { CSSProperties } from 'react';
+import { type DocumentRunShading, type DocumentRunShadingPattern } from '../work-document-run-shading';
+export type DocumentFontDialogRunShadingMode = 'inherit' | 'mixed' | 'none' | 'value';
+export interface DocumentFontDialogRunShadingSource {
+    mixed: boolean;
+    value: DocumentRunShading | null;
+}
+export interface DocumentFontDialogRunShadingDraft {
+    runShadingMode: DocumentFontDialogRunShadingMode;
+    runShadingPattern: Exclude<DocumentRunShadingPattern, 'nil'>;
+    runShadingColor: 'auto' | `#${string}`;
+    runShadingFill: 'auto' | `#${string}`;
+}
+export interface DocumentFontDialogRunShadingPatch {
+    runShading?: DocumentRunShading | null;
+}
+export declare function addDocumentFontDialogRunShadingValue(values: Map<string, DocumentRunShading | null>, source: unknown): void;
+export declare function selectedDocumentFontDialogRunShadingValue(values: ReadonlyMap<string, DocumentRunShading | null>): DocumentFontDialogRunShadingSource;
+export declare function createDocumentFontDialogRunShadingDraft(source: DocumentFontDialogRunShadingSource): DocumentFontDialogRunShadingDraft;
+export declare function documentFontDialogRunShadingDraftError(draft: DocumentFontDialogRunShadingDraft): string | null;
+export declare function documentFontDialogRunShadingPatch(source: DocumentFontDialogRunShadingSource, draft: DocumentFontDialogRunShadingDraft, touched: boolean): DocumentFontDialogRunShadingPatch;
+export declare function documentFontDialogRunShadingFromDraft(source: DocumentFontDialogRunShadingSource, draft: DocumentFontDialogRunShadingDraft): DocumentRunShading | null;
+export declare function documentFontDialogRunShadingPreviewStyle(source: DocumentFontDialogRunShadingSource, draft: DocumentFontDialogRunShadingDraft): CSSProperties;

package/dist/internal/features/work/editors/document-font-dialog-run-shading-section.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentFontDialogRunShadingDraft, DocumentFontDialogRunShadingSource } from './document-font-dialog-run-shading-model';
+export declare function DocumentFontDialogRunShadingSection({ source, draft, touched, onDraftChange, onTouched, }: {
+    source: DocumentFontDialogRunShadingSource;
+    draft: DocumentFontDialogRunShadingDraft;
+    touched: boolean;
+    onDraftChange: (patch: Partial<DocumentFontDialogRunShadingDraft>) => void;
+    onTouched: () => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-index-dialog.d.ts

@@ -0,0 +1,10 @@
+import type { WorkDocumentIndexOptions } from '../work-document-index';
+export interface DocumentIndexDialogProps {
+    editing: boolean;
+    options: WorkDocumentIndexOptions;
+    restoreFocusTarget: () => HTMLElement | null;
+    onCancel: () => void;
+    onOptionsChange: (options: WorkDocumentIndexOptions) => void;
+    onSubmit: () => void;
+}
+export declare function DocumentIndexDialog({ editing, options, restoreFocusTarget, onCancel, onOptionsChange, onSubmit, }: DocumentIndexDialogProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-index-entry-dialog.d.ts

@@ -0,0 +1,10 @@
+import type { WorkDocumentIndexEntryDraft } from '../work-document-index';
+export interface DocumentIndexEntryDialogProps {
+    editing: boolean;
+    value: WorkDocumentIndexEntryDraft;
+    restoreFocusTarget: () => HTMLElement | null;
+    onCancel: () => void;
+    onChange: (value: WorkDocumentIndexEntryDraft) => void;
+    onSubmit: () => void;
+}
+export declare function DocumentIndexEntryDialog({ editing, value, restoreFocusTarget, onCancel, onChange, onSubmit, }: DocumentIndexEntryDialogProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-page-chrome-ribbon.d.ts

@@ -1,11 +1,12 @@
 import type { Editor } from '@tiptap/core';
 export type DocumentPageChromeEditingPart = 'footer' | 'header';
-export declare function DocumentPageChromeRibbon({ editor, editingPart, showPageNumber, onEditingPartChange, onTogglePageNumber, onOpenFontDialog, onClose, }: {
+export declare function DocumentPageChromeRibbon({ editor, editingPart, showPageNumber, onEditingPartChange, onTogglePageNumber, onOpenFontDialog, onOpenProofingDialog, onClose, }: {
     editor: Editor;
     editingPart: DocumentPageChromeEditingPart;
     showPageNumber: boolean;
     onEditingPartChange: (part: DocumentPageChromeEditingPart) => void;
     onTogglePageNumber: () => void;
     onOpenFontDialog?: () => void;
+    onOpenProofingDialog?: () => void;
     onClose: () => void;
 }): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-proofing-dialog-model.d.ts

@@ -0,0 +1,22 @@
+import type { Editor } from '@tiptap/core';
+import { type WorkDocumentProofingLanguageSlot } from '../work-document-proofing';
+export interface DocumentProofingDialogValue<T> {
+    mixed: boolean;
+    value: T | null;
+}
+export interface DocumentProofingDialogSource {
+    latin: DocumentProofingDialogValue<string>;
+    eastAsia: DocumentProofingDialogValue<string>;
+    bidi: DocumentProofingDialogValue<string>;
+    noProof: DocumentProofingDialogValue<boolean>;
+    selectedCharacters: number;
+}
+export interface DocumentProofingDialogPatch {
+    languages?: Partial<Record<WorkDocumentProofingLanguageSlot, string | null>>;
+    noProof?: boolean | null;
+}
+export declare function documentProofingDialogSource(editor: Editor): DocumentProofingDialogSource;
+export declare function applyDocumentProofingDialogPatch(editor: Editor, selection: {
+    from: number;
+    to: number;
+}, patch: DocumentProofingDialogPatch): boolean;

package/dist/internal/features/work/editors/document-proofing-dialog.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentProofingDialogPatch, DocumentProofingDialogSource } from './document-proofing-dialog-model';
+export declare function DocumentProofingDialog({ source, restoreFocusTarget, onApply, onClose, }: {
+    source: DocumentProofingDialogSource;
+    restoreFocusTarget: () => HTMLElement | null;
+    onApply: (patch: DocumentProofingDialogPatch) => boolean;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-references-ribbon.d.ts

@@ -0,0 +1,19 @@
+import type { Editor } from '@tiptap/core';
+import type { WorkDocumentCaptionKind } from '../work-document-captions';
+import type { WorkDocumentNoteKind } from '../work-document-notes';
+export interface DocumentReferencesRibbonProps {
+    editor: Editor;
+    citationsOpen: boolean;
+    citationSourceCount: number;
+    onInsertNote: (kind: WorkDocumentNoteKind) => void;
+    onInsertCaption: (kind: WorkDocumentCaptionKind) => void;
+    onInsertCrossReference: () => void;
+    onOpenTableOfContents: () => void;
+    onRefreshTableOfContents: () => void;
+    onOpenIndexEntry: () => void;
+    onOpenIndex: () => void;
+    onRefreshIndex: () => void;
+    onToggleCitations: () => void;
+    onRefreshFields: () => void;
+}
+export declare function DocumentReferencesRibbon({ editor, citationsOpen, citationSourceCount, onInsertNote, onInsertCaption, onInsertCrossReference, onOpenTableOfContents, onRefreshTableOfContents, onOpenIndexEntry, onOpenIndex, onRefreshIndex, onToggleCitations, onRefreshFields, }: DocumentReferencesRibbonProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-table-of-contents-dialog.d.ts

@@ -0,0 +1,10 @@
+import type { WorkDocumentTableOfContentsOptions } from '../work-document-table-of-contents';
+export interface DocumentTableOfContentsDialogProps {
+    editing: boolean;
+    options: WorkDocumentTableOfContentsOptions;
+    restoreFocusTarget: () => HTMLElement | null;
+    onCancel: () => void;
+    onOptionsChange: (options: WorkDocumentTableOfContentsOptions) => void;
+    onSubmit: () => void;
+}
+export declare function DocumentTableOfContentsDialog({ editing, options, restoreFocusTarget, onCancel, onOptionsChange, onSubmit, }: DocumentTableOfContentsDialogProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-toolbar.d.ts

@@ -57,11 +57,16 @@ interface DocumentToolbarProps {
     onInsertNote: (kind: WorkDocumentNoteKind) => void;
     onInsertCaption: (kind: WorkDocumentCaptionKind) => void;
     onInsertCrossReference: () => void;
+    onOpenTableOfContents: () => void;
+    onOpenIndexEntry: () => void;
+    onOpenIndex: () => void;
     citationsOpen: boolean;
     citationSourceCount: number;
     onToggleCitations: () => void;
     onInsertField: (kind: WorkDocumentFieldKind) => void;
     onRefreshFields: () => void;
+    onRefreshIndex: () => void;
+    onRefreshTableOfContents: () => void;
     canInsertComment: boolean;
     onInsertComment: () => void;
     commentsOpen: boolean;
@@ -79,5 +84,5 @@ interface DocumentToolbarProps {
     onOpenWordCount: () => void;
     onOpenFindReplace: (mode: DocumentFindReplaceMode) => void;
 }
-export declare function DocumentToolbar({ editor, defaultRibbonCollapsed, reviewOnly, suggestionOnly, history, layoutOpen, layout, layoutFonts, navigationOpen, pageColor, showPageNumbers, showHiddenText, showRulers, spellcheckEnabled, viewMode, zoom, pageChromeEditor, pageChromeEditingPart, pageChromeShowPageNumber, onRequestImage, onPageChromeEditingPartChange, onClosePageChrome, onTogglePageChromePageNumber, onToggleLayout, onLayoutChange, onOpenLayout, onToggleNavigation, onTogglePageNumbers, onToggleHiddenText, onToggleRulers, onPageColorChange, onToggleSpellcheck, onViewModeChange, onZoomChange, onZoomFit, onInsertSection, onInsertNote, onInsertCaption, onInsertCrossReference, citationsOpen, citationSourceCount, onToggleCitations, onInsertField, onRefreshFields, canInsertComment, onInsertComment, commentsOpen, commentCount, onToggleComments, trackChanges, changesOpen, changeCount, findReplaceMode, fileActions, onRibbonTabChange, onToggleTrackChanges, onToggleChanges, onDecideChange, onOpenWordCount, onOpenFindReplace, }: DocumentToolbarProps): import("react").JSX.Element;
+export declare function DocumentToolbar({ editor, defaultRibbonCollapsed, reviewOnly, suggestionOnly, history, layoutOpen, layout, layoutFonts, navigationOpen, pageColor, showPageNumbers, showHiddenText, showRulers, spellcheckEnabled, viewMode, zoom, pageChromeEditor, pageChromeEditingPart, pageChromeShowPageNumber, onRequestImage, onPageChromeEditingPartChange, onClosePageChrome, onTogglePageChromePageNumber, onToggleLayout, onLayoutChange, onOpenLayout, onToggleNavigation, onTogglePageNumbers, onToggleHiddenText, onToggleRulers, onPageColorChange, onToggleSpellcheck, onViewModeChange, onZoomChange, onZoomFit, onInsertSection, onInsertNote, onInsertCaption, onInsertCrossReference, onOpenTableOfContents, onOpenIndexEntry, onOpenIndex, citationsOpen, citationSourceCount, onToggleCitations, onInsertField, onRefreshFields, onRefreshIndex, onRefreshTableOfContents, canInsertComment, onInsertComment, commentsOpen, commentCount, onToggleComments, trackChanges, changesOpen, changeCount, findReplaceMode, fileActions, onRibbonTabChange, onToggleTrackChanges, onToggleChanges, onDecideChange, onOpenWordCount, onOpenFindReplace, }: DocumentToolbarProps): import("react").JSX.Element;
 export {};

package/dist/internal/features/work/editors/spreadsheet-data-validation.d.ts

@@ -1,12 +1,18 @@
-import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem, WorkSpreadsheetSheet } from '../work-types';
+import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationErrorStyle, WorkSpreadsheetDataValidationItem, WorkSpreadsheetSheet } from '../work-types';
 import { type SpreadsheetCellRange } from './spreadsheet-cell-range';
 export declare const MAX_SPREADSHEET_DATA_VALIDATION_CELLS = 10000;
 export type SpreadsheetDataValidationType = 'date' | 'dropdown' | 'number' | 'number_integer' | 'text_length';
 export type SpreadsheetDataValidationOperator = 'between' | 'equal' | 'greaterOrEqualTo' | 'lessThan' | 'lessThanOrEqualTo' | 'moreThanThe' | 'noEarlierThan' | 'noLaterThan' | 'notBetween' | 'notEqualTo' | 'earlierThan' | 'laterThan';
 export interface SpreadsheetDataValidationDialogValue {
+    allowBlank: boolean;
+    errorMessage: string;
+    errorStyle: WorkSpreadsheetDataValidationErrorStyle;
+    errorTitle: string;
     hintShow: boolean;
+    hintTitle: string;
     hintValue: string;
     prohibitInput: boolean;
+    showDropdownArrow: boolean;
     type: SpreadsheetDataValidationType;
     type2: SpreadsheetDataValidationOperator | '';
     value1: string;

package/dist/internal/features/work/editors/use-document-insert-commands.d.ts

@@ -11,7 +11,12 @@ export interface DocumentInsertCommands {
     insertField: (kind: WorkDocumentFieldKind) => void;
     insertImage: (file: File) => Promise<void>;
     insertNote: (kind: WorkDocumentNoteKind) => boolean;
+    openIndexEntry: () => void;
+    openIndex: () => void;
+    openTableOfContents: () => void;
     refreshFields: () => boolean;
+    refreshIndex: () => boolean;
+    refreshTableOfContents: () => boolean;
 }
 export declare function useDocumentInsertCommands({ contentRef, editor, resolveFieldContext, }: {
     contentRef: MutableRefObject<WorkDocumentContent>;

package/dist/internal/features/work/work-document-character-formatting.d.ts

@@ -2,6 +2,8 @@ import { Extension, type Editor } from '@tiptap/core';
 import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
 import { type WorkDocumentTextCase } from './work-document-text-case';
 import { type DocumentRunBorder } from './work-document-run-border';
+import { type DocumentRunShading } from './work-document-run-shading';
+import { type WorkDocumentProofingLanguages } from './work-document-proofing';
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
         documentCharacterFormatting: {
@@ -22,6 +24,12 @@ declare module '@tiptap/core' {
             setDocumentRunBorder: (border: DocumentRunBorder) => ReturnType;
             unsetDocumentRunBorder: () => ReturnType;
             toggleDocumentRunBorder: () => ReturnType;
+            setDocumentRunShading: (shading: DocumentRunShading) => ReturnType;
+            unsetDocumentRunShading: () => ReturnType;
+            setDocumentProofingLanguages: (languages: WorkDocumentProofingLanguages) => ReturnType;
+            unsetDocumentProofingLanguages: () => ReturnType;
+            setDocumentNoProof: (noProof: boolean) => ReturnType;
+            unsetDocumentNoProof: () => ReturnType;
         };
     }
 }

package/dist/internal/features/work/work-document-format-changes.d.ts

@@ -5,6 +5,8 @@ import { type WorkDocumentTextCase } from './work-document-text-case';
 import { type WorkDocumentUnderlineFormatting } from './work-document-underline';
 import { type WorkDocumentStrikeFormatting } from './work-document-strike';
 import { type WorkDocumentScriptFontSlot, type WorkDocumentScriptFonts } from './work-document-script-fonts';
+import { type WorkDocumentHighlight } from './work-document-highlight';
+import { type WorkDocumentProofingLanguages } from './work-document-proofing';
 export declare const DOCUMENT_CHARACTER_FORMAT_MARKS: readonly ["bold", "italic", "underline", "strike", "subscript", "superscript", "textStyle", "highlight"];
 export type DocumentCharacterFormatMarkName = (typeof DOCUMENT_CHARACTER_FORMAT_MARKS)[number];
 export interface DocumentCharacterFormatMark {
@@ -36,6 +38,9 @@ export declare function importedDocumentCharacterFormatting(formatting: {
     legacyTextEmboss?: boolean;
     legacyTextImprint?: boolean;
     runBorder?: string;
+    runShading?: string;
+    proofingLanguages?: WorkDocumentProofingLanguages;
+    noProof?: boolean;
     wordLineHeightFactor?: number;
     wordSnapToGrid?: boolean;
     fontSize?: number;
@@ -43,5 +48,6 @@ export declare function importedDocumentCharacterFormatting(formatting: {
     backgroundColor?: string;
     themeColor?: string;
     themeFill?: string;
+    highlight?: WorkDocumentHighlight;
     textCase?: WorkDocumentTextCase;
 }): string;

package/dist/internal/features/work/work-document-highlight.d.ts

@@ -0,0 +1,9 @@
+export declare const DOCUMENT_HIGHLIGHT_ATTRIBUTE = "data-office-highlight";
+export type WorkDocumentHighlight = 'black' | 'blue' | 'cyan' | 'darkBlue' | 'darkCyan' | 'darkGray' | 'darkGreen' | 'darkMagenta' | 'darkRed' | 'darkYellow' | 'green' | 'lightGray' | 'magenta' | 'none' | 'red' | 'white' | 'yellow';
+export declare const DOCUMENT_HIGHLIGHT_VALUES: Set<WorkDocumentHighlight>;
+export declare function normalizeDocumentHighlight(source: unknown): WorkDocumentHighlight | null;
+export declare function documentHighlightFromDocxValue(source: unknown): WorkDocumentHighlight | null;
+export declare function documentHighlightCssColor(source: unknown): string | null;
+export declare function documentHighlightForCssColor(source: unknown): WorkDocumentHighlight | null;
+export declare function documentHighlightFromElement(element: HTMLElement): WorkDocumentHighlight | null;
+export declare function documentHighlightDomAttributes(source: unknown): Record<string, string>;

package/dist/internal/features/work/work-document-index-fields.d.ts

@@ -0,0 +1,19 @@
+import { type WorkDocumentIndexEntryDraft, type WorkDocumentIndexOptions } from './work-document-index';
+export type WorkDocumentIndexEntryInstructionResult = {
+    supported: true;
+    value: WorkDocumentIndexEntryDraft;
+} | {
+    supported: false;
+    reason: 'not-index-entry' | 'invalid-instruction' | 'invalid-entry' | 'unsupported-switch';
+};
+export type WorkDocumentIndexInstructionResult = {
+    supported: true;
+    options: WorkDocumentIndexOptions;
+} | {
+    supported: false;
+    reason: 'not-index' | 'invalid-instruction' | 'invalid-columns' | 'unsupported-switch';
+};
+export declare function parseDocumentIndexEntryInstruction(instruction: string): WorkDocumentIndexEntryInstructionResult;
+export declare function documentIndexEntryInstruction(source: WorkDocumentIndexEntryDraft): string;
+export declare function parseDocumentIndexInstruction(instruction: string): WorkDocumentIndexInstructionResult;
+export declare function documentIndexInstruction(source: WorkDocumentIndexOptions): string;

package/dist/internal/features/work/work-document-index-nodes.d.ts

@@ -0,0 +1,32 @@
+import { Node, type CommandProps } from '@tiptap/core';
+import { type WorkDocumentIndexBuildOptions, type WorkDocumentIndexEntry, type WorkDocumentIndexEntryDraft, type WorkDocumentIndexOptions } from './work-document-index';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentIndexEntry: {
+            markDocumentIndexEntry: (value: WorkDocumentIndexEntryDraft) => ReturnType;
+            updateDocumentIndexEntry: (value: WorkDocumentIndexEntryDraft) => ReturnType;
+        };
+        documentIndex: {
+            insertDocumentIndex: (options?: WorkDocumentIndexOptions, buildOptions?: WorkDocumentIndexBuildOptions) => ReturnType;
+            updateDocumentIndex: (options: WorkDocumentIndexOptions, buildOptions?: WorkDocumentIndexBuildOptions) => ReturnType;
+            refreshDocumentIndexes: (buildOptions?: WorkDocumentIndexBuildOptions) => ReturnType;
+        };
+    }
+}
+export declare const DocumentIndexEntry: Node<any, any>;
+export declare const DocumentIndex: Node<any, any>;
+export declare function selectedDocumentIndexEntry(editor: {
+    state: CommandProps['state'];
+}): WorkDocumentIndexEntry | null;
+export declare function selectedDocumentIndexOptions(editor: {
+    state: CommandProps['state'];
+}): WorkDocumentIndexOptions | null;
+export declare function selectedDocumentIndexDraft(editor: {
+    state: CommandProps['state'];
+}): WorkDocumentIndexEntryDraft | null;
+export declare function documentHasIndexEntries(editor: {
+    state: CommandProps['state'];
+}): boolean;
+export declare function documentHasIndex(editor: {
+    state: CommandProps['state'];
+}): boolean;

package/dist/internal/features/work/work-document-index.d.ts

@@ -0,0 +1,63 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { WorkDocumentFieldContextResolver } from './work-document-fields';
+export type WorkDocumentIndexLeader = 'dot' | 'dash' | 'underline' | 'none';
+export type WorkDocumentIndexFormat = 'indented' | 'run-in';
+export interface WorkDocumentIndexEntryDraft {
+    mainEntry: string;
+    subEntry: string;
+    crossReference: string;
+    pageBold: boolean;
+    pageItalic: boolean;
+}
+export interface WorkDocumentIndexEntry extends WorkDocumentIndexEntryDraft {
+    id: string;
+}
+export interface WorkDocumentIndexPage {
+    pageNumber: number;
+    pageBold: boolean;
+    pageItalic: boolean;
+    targetIds: string[];
+}
+export interface WorkDocumentIndexGeneratedEntry {
+    mainEntry: string;
+    subEntry: string;
+    crossReference: string;
+    pages: WorkDocumentIndexPage[];
+}
+export interface WorkDocumentIndexOptions {
+    columns: number;
+    format: WorkDocumentIndexFormat;
+    rightAlignPageNumbers: boolean;
+    leader: WorkDocumentIndexLeader;
+}
+export interface WorkDocumentIndexValue {
+    id: string;
+    options: WorkDocumentIndexOptions;
+    entries: WorkDocumentIndexGeneratedEntry[];
+    truncated: boolean;
+}
+export interface WorkDocumentIndexBuildOptions {
+    resolveContext?: WorkDocumentFieldContextResolver;
+}
+export declare const DEFAULT_DOCUMENT_INDEX_OPTIONS: WorkDocumentIndexOptions;
+export declare const MAX_DOCUMENT_INDEX_ENTRIES = 512;
+export declare const MAX_DOCUMENT_INDEX_MARKERS = 2048;
+export declare const MAX_DOCUMENT_INDEX_TERM_LENGTH = 240;
+export declare function normalizeDocumentIndexEntryDraft(source: Partial<WorkDocumentIndexEntryDraft> | null | undefined): WorkDocumentIndexEntryDraft | null;
+export declare function normalizeDocumentIndexEntry(source: Partial<WorkDocumentIndexEntry> | null | undefined, fallbackId?: string): WorkDocumentIndexEntry | null;
+export declare function normalizeDocumentIndexOptions(source: Partial<WorkDocumentIndexOptions> | null | undefined): WorkDocumentIndexOptions;
+export declare function normalizeDocumentIndexValue(source: Omit<WorkDocumentIndexValue, 'truncated'> & {
+    truncated?: boolean;
+}): WorkDocumentIndexValue;
+export declare function buildDocumentIndexEntries(document: ProseMirrorNode, options?: WorkDocumentIndexBuildOptions): {
+    entries: WorkDocumentIndexGeneratedEntry[];
+    truncated: boolean;
+};
+export declare function documentIndexEntryHtml(source: Partial<WorkDocumentIndexEntry>): string;
+export declare function documentIndexHtml(source: Omit<WorkDocumentIndexValue, 'truncated'> & {
+    truncated?: boolean;
+}): string;
+export declare function documentIndexEntryFromElement(element: HTMLElement, index?: number): WorkDocumentIndexEntry | null;
+export declare function documentIndexValueFromElement(element: HTMLElement, index?: number): WorkDocumentIndexValue;
+export declare function normalizeDocumentIndexesHtml(source: string): string;
+export declare function indexLeader(value: unknown): WorkDocumentIndexLeader | null;

package/dist/internal/features/work/work-document-outline.d.ts

@@ -10,5 +10,6 @@ export interface WorkDocumentOutlineItem {
     hasChildren: boolean;
 }
 export declare function collectWorkDocumentOutline(document: ProseMirrorNode): WorkDocumentOutlineItem[];
+export declare function workDocumentOutlineLevel(node: ProseMirrorNode): number | null;
 export declare function currentWorkDocumentOutlineItem(items: readonly WorkDocumentOutlineItem[], position: number): WorkDocumentOutlineItem | null;
 export declare function visibleWorkDocumentOutlineItems(items: readonly WorkDocumentOutlineItem[], collapsedIds: ReadonlySet<string>, rawQuery: string): WorkDocumentOutlineItem[];

package/dist/internal/features/work/work-document-paragraph-shading.d.ts

@@ -16,3 +16,9 @@ export declare function parseDocumentParagraphShading(source: unknown): Document
 export declare function serializeDocumentParagraphShading(source: unknown): string | undefined;
 export declare function parseDocumentParagraphShadingElement(element: HTMLElement): DocumentParagraphShading | null;
 export declare function documentParagraphShadingDomAttributes(source: unknown): Record<string, string>;
+export declare function documentParagraphShadingPresentation(shading: DocumentParagraphShading): {
+    backgroundColor: string;
+    backgroundImage?: string;
+    backgroundSize?: string;
+};
+export declare function paragraphShadingBackgroundUsesForeground(shading: DocumentParagraphShading): boolean;

package/dist/internal/features/work/work-document-proofing.d.ts

@@ -0,0 +1,19 @@
+import { type WorkDocumentScriptFontSlot } from './work-document-script-fonts';
+export declare const DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE = "data-office-proofing-languages";
+export declare const DOCUMENT_NO_PROOF_ATTRIBUTE = "data-office-no-proof";
+export interface WorkDocumentProofingLanguages {
+    latin?: string;
+    eastAsia?: string;
+    bidi?: string;
+}
+export type WorkDocumentProofingLanguageSlot = keyof WorkDocumentProofingLanguages;
+export declare function normalizeDocumentLanguageTag(source: unknown): string | null;
+export declare function normalizeDocumentProofingLanguages(source: unknown): WorkDocumentProofingLanguages | null;
+export declare function serializeDocumentProofingLanguages(source: unknown): string | undefined;
+export declare function parseDocumentProofingLanguages(source: unknown): WorkDocumentProofingLanguages | null;
+export declare function normalizeDocumentNoProof(source: unknown): boolean | null;
+export declare function documentProofingLanguagesFromElement(element: HTMLElement): WorkDocumentProofingLanguages | null;
+export declare function documentNoProofFromElement(element: HTMLElement): boolean | null;
+export declare function documentProofingLanguageForScript(source: unknown, slot?: WorkDocumentScriptFontSlot | null): string | undefined;
+export declare function documentProofingDomAttributes(languagesSource: unknown, noProofSource?: unknown, slot?: WorkDocumentScriptFontSlot | null): Record<string, string>;
+export declare function patchDocumentProofingLanguages(source: unknown, patch: Partial<Record<WorkDocumentProofingLanguageSlot, string | null>>): WorkDocumentProofingLanguages | null;

package/dist/internal/features/work/work-document-run-shading.d.ts

@@ -0,0 +1,12 @@
+import { type DocumentParagraphShading, type DocumentParagraphShadingColor, type DocumentParagraphShadingPattern } from './work-document-paragraph-shading';
+export declare const DOCUMENT_RUN_SHADING_ATTRIBUTE = "data-office-run-shading";
+export type DocumentRunShading = DocumentParagraphShading;
+export type DocumentRunShadingColor = DocumentParagraphShadingColor;
+export type DocumentRunShadingPattern = DocumentParagraphShadingPattern;
+export declare const DOCUMENT_RUN_SHADING_PATTERNS: Set<DocumentParagraphShadingPattern>;
+export declare function normalizeDocumentRunShading(source: unknown): DocumentRunShading | null;
+export declare function parseDocumentRunShading(source: unknown): DocumentRunShading | null;
+export declare function serializeDocumentRunShading(source: unknown): string | undefined;
+export declare function parseDocumentRunShadingElement(element: HTMLElement): DocumentRunShading | null;
+export declare function documentRunShadingDomAttributes(source: unknown): Record<string, string>;
+export declare function documentRunShadingIsVisible(source: unknown): boolean;

package/dist/internal/features/work/work-document-table-of-contents-node.d.ts

@@ -0,0 +1,18 @@
+import { Node, type CommandProps } from '@tiptap/core';
+import { type WorkDocumentTableOfContentsBuildOptions, type WorkDocumentTableOfContentsOptions } from './work-document-table-of-contents';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentTableOfContents: {
+            insertDocumentTableOfContents: (options?: WorkDocumentTableOfContentsOptions, buildOptions?: WorkDocumentTableOfContentsBuildOptions) => ReturnType;
+            updateDocumentTableOfContents: (options: WorkDocumentTableOfContentsOptions, buildOptions?: WorkDocumentTableOfContentsBuildOptions) => ReturnType;
+            refreshDocumentTablesOfContents: (buildOptions?: WorkDocumentTableOfContentsBuildOptions) => ReturnType;
+        };
+    }
+}
+export declare const DocumentTableOfContents: Node<any, any>;
+export declare function selectedDocumentTableOfContentsOptions(editor: {
+    state: CommandProps['state'];
+}): WorkDocumentTableOfContentsOptions | null;
+export declare function documentHasTableOfContents(editor: {
+    state: CommandProps['state'];
+}): boolean;

package/dist/internal/features/work/work-document-table-of-contents.d.ts

@@ -0,0 +1,51 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { WorkDocumentFieldContextResolver } from './work-document-fields';
+export type WorkDocumentTableOfContentsLeader = 'dot' | 'dash' | 'underline' | 'none';
+export interface WorkDocumentTableOfContentsOptions {
+    minLevel: number;
+    maxLevel: number;
+    hyperlinks: boolean;
+    showPageNumbers: boolean;
+    rightAlignPageNumbers: boolean;
+    leader: WorkDocumentTableOfContentsLeader;
+}
+export interface WorkDocumentTableOfContentsEntry {
+    targetId: string;
+    title: string;
+    level: number;
+    pageNumber: number;
+}
+export interface WorkDocumentTableOfContentsValue {
+    id: string;
+    options: WorkDocumentTableOfContentsOptions;
+    entries: WorkDocumentTableOfContentsEntry[];
+    truncated: boolean;
+}
+export interface WorkDocumentTableOfContentsBuildOptions {
+    resolveContext?: WorkDocumentFieldContextResolver;
+}
+export type WorkDocumentTableOfContentsInstructionResult = {
+    supported: true;
+    options: WorkDocumentTableOfContentsOptions;
+} | {
+    supported: false;
+    reason: 'not-table-of-contents' | 'invalid-instruction' | 'invalid-level-range' | 'unsupported-switch' | 'unsupported-page-range' | 'unsupported-separator';
+};
+export declare const DEFAULT_DOCUMENT_TABLE_OF_CONTENTS_OPTIONS: WorkDocumentTableOfContentsOptions;
+export declare const MAX_DOCUMENT_TABLE_OF_CONTENTS_ENTRIES = 512;
+export declare function normalizeDocumentTableOfContentsOptions(source: Partial<WorkDocumentTableOfContentsOptions> | null | undefined): WorkDocumentTableOfContentsOptions;
+export declare function buildDocumentTableOfContentsEntries(document: ProseMirrorNode, options: WorkDocumentTableOfContentsOptions, buildOptions?: WorkDocumentTableOfContentsBuildOptions): {
+    entries: WorkDocumentTableOfContentsEntry[];
+    truncated: boolean;
+};
+export declare function documentTableOfContentsHtml(source: Omit<WorkDocumentTableOfContentsValue, 'truncated'> & {
+    truncated?: boolean;
+}): string;
+export declare function normalizeDocumentTableOfContentsHtml(source: string): string;
+export declare function documentTableOfContentsValueFromElement(element: HTMLElement, index?: number): WorkDocumentTableOfContentsValue;
+export declare function parseDocumentTableOfContentsInstruction(instruction: string): WorkDocumentTableOfContentsInstructionResult;
+export declare function documentTableOfContentsInstruction(source: WorkDocumentTableOfContentsOptions): string;
+export declare function tableOfContentsLeader(value: unknown): WorkDocumentTableOfContentsLeader | null;
+export declare function normalizeDocumentTableOfContentsValue(source: Omit<WorkDocumentTableOfContentsValue, 'truncated'> & {
+    truncated?: boolean;
+}): WorkDocumentTableOfContentsValue;

package/dist/internal/features/work/work-document-word-line-metrics.d.ts

@@ -14,6 +14,9 @@ declare module '@tiptap/extension-text-style' {
         legacyTextEmboss?: boolean | null;
         legacyTextImprint?: boolean | null;
         runBorder?: string | null;
+        runShading?: string | null;
+        proofingLanguages?: string | null;
+        noProof?: boolean | null;
         kerningThresholdHalfPoints?: number | null;
         scriptFonts?: string | null;
         scriptFontSlot?: WorkDocumentScriptFontSlot | null;

package/dist/internal/features/work/work-docx-field-instructions.d.ts

@@ -12,5 +12,5 @@ export interface DocxFieldOccurrence {
 export declare function docxFieldInstructions(root: ParentNode): string[];
 export declare function docxFieldOccurrences(root: ParentNode): DocxFieldOccurrence[];
 export declare function docxFieldOccurrenceIsInlineEditable(field: DocxFieldOccurrence): boolean;
-export declare function hasInvalidDocxFieldStructure(root: ParentNode): boolean;
+export declare function hasInvalidDocxFieldStructure(root: ParentNode, ignore?: (field: DocxFieldOccurrence) => boolean): boolean;
 export declare function docxFieldResultText(field: DocxFieldOccurrence): string;