@arbidocs/blocks 0.4.101 → 0.4.102

package/node_modules/@docx-editor.dev/core/dist/editor.d.ts

@@ -0,0 +1,1394 @@
+/**
+ * `@docx-editor.dev/core/editor` — the editor facade and its chrome vocabulary.
+ *
+ * `createDocxEditor` implements the full `Editor` contract over a paginated surface, and the
+ * chrome registry (`CHROME_GROUPS`, `ChromeSlotId`) is the toolbar taxonomy both adapters derive
+ * their default arrangement from. Enabled state has exactly one source — `toolbarCommandState`,
+ * which asks the engine — so a control and the engine can never disagree.
+ *
+ * @packageDocumentation
+ * @public
+ */
+export { k as FieldResultsMode } from './tree-package-fragment-BeeKxDw8.js';
+import { O as OoxmlPart, aG as TreeDocColorValue, r as ColorValue, ao as DrawingPositionInput, A as ParagraphTabStop } from './types-barrel-D3xCgQX6.js';
+export { aH as IMAGE_WRAP_TARGETS, an as ImageWrapTarget, z as ParagraphFlags, R as ReviewModelInput, aI as TEXT_FORM_FORMATS } from './types-barrel-D3xCgQX6.js';
+export { D as DEFAULT_IMAGE_RESOURCE_LIMITS, a as ImageDecodePort, I as ImageResourceLimits, R as RenderableImageMime, S as SupportedImageMime, c as VectorImageMime, r as resolveImageResourceLimits, d as resolveSvgIntrinsicSize, s as sniffImageMime, v as validateRasterHeader } from './image-resources-BN-hUgCn.js';
+export { CollectReviewItems, EditorModule, EditorModuleRegistry, ReviewModuleContribution, RevisionMarkupDialog, RevisionMarkupDialogHost, resolveEditorModules } from './contracts/modules.js';
+import { T as TreeDocxSessionView, f as DocumentThemeColorEntry } from './tree-session-contract-CVbmlMlq.js';
+export { a as TreeApplyResult } from './tree-session-contract-CVbmlMlq.js';
+import { a as FontConfiguration, E as EditorFontError, d as EditorSnapshot, e as EditorCommand, C as CanResult, Z as ZoomMode, f as ClearAnchorHighlightOptions, A as AnchorHighlightOptions, S as ScrollToAnchorOptions, g as ScrollPlacement, h as AnchorHighlightAnimation, H as HighlightRange, i as Editor, j as HighlightResult, k as HighlightOptions, T as TextMatch } from './editor-Ci7IZGmG.js';
+export { l as HighlightHit, m as HighlightRect, I as ImageContext, n as ImageCropPercent, o as ImageCropPermille, R as ReviewItemHit, p as SelectedImageState, q as TrackedChangeFilterMode, r as TrackedChangePredicate, s as cropPercentFromCropPermille, t as cropPercentFromPermille, u as cropPercentFromSourceCrop, v as cropPermilleFromCropPercent, w as cropPermilleFromPercent, x as sourceCropFromCropPercent, y as validateImageCropPercent } from './editor-Ci7IZGmG.js';
+import { L as LayoutShapingInstrumentation, a as LayoutShapingOptions } from './layout-shaping-BEyuiQOk.js';
+export { d as disposeLayoutShaping } from './layout-shaping-BEyuiQOk.js';
+export { C as ComposeFontOriginsOptions, D as DEFAULT_FONT, b as FONT_RESOLVER_BRAND, c as FONT_RESOLVER_MARK_KEY, d as FontConfigurationBase, e as FontConfigurationFragment, a as FontOrigin, F as FontOriginFailure, f as FontResolutionRequest, g as FontResolver, h as FontResolverMark, M as MAX_RESOLVER_FAMILIES, i as MarkedFontResolver, W as WORD_DEFAULT_FONT, j as composeFontConfiguration, k as composeFontOrigins, l as defineFontResolver, m as isFontResolver } from './font-resolver-BVQB14qT.js';
+import { P as PaginatedSurfaceOptions, O as OpenPaginatedResult, a as PaginatedSurface, T as TableCommandPlan, D as DocxEditorInstance } from './index-Bsg7oIKP.js';
+export { A as AnchorFrameOrigin, C as CHROME_GROUPS, b as CHROME_MENUS, c as CHROME_UNAVAILABLE_KEY, d as ChromeControl, e as ChromeControlId, f as ChromeControlState, g as ChromeExportError, h as ChromeExportFormat, i as ChromeExportHandlers, j as ChromeExportResult, k as ChromeExportView, l as ChromeGroup, m as ChromeGroupId, n as ChromeMenu, o as ChromeMenuEntry, p as ChromeMenuId, q as ChromeMenuItemEntry, r as ChromeMenuSeparatorEntry, s as ChromeMenuSubmenuEntry, t as ChromePrintError, u as ChromePrintErrorCode, v as ChromePrintJob, w as ChromePrintOptions, x as ChromeSlotId, y as ContentControlWidgetChromeHandlers, z as ContentControlWidgetSession, B as CustomFontsOptions, E as CustomFontsResolver, F as DEFAULT_TABLE_CHROME_DRAFT, G as DocxEditorConfig, H as DrawingSelectionIntent, I as EMU_PER_POINT, J as EditorCommandExecute, K as EquationActivation, L as EquationChromeHandlers, M as EquationOps, N as FinalizedImageOverlayInteraction, Q as FontLoadFailure, R as FontLoadFailureReason, S as FontMeasurementState, U as FontUrlSource, V as HistoryGroupBinding, W as HistoryGroupBindingOptions, X as HyperlinkActivation, Y as HyperlinkChromeHandlers, Z as HyperlinkOps, _ as IMAGE_OVERLAY_NUDGE_PT, $ as IMAGE_OVERLAY_NUDGE_SHIFT_PT, a0 as ImageInteractionSession, a1 as ImageOverlayScrollPort, a2 as ImageResizeHandle, a3 as ImageResizeResult, a4 as InvalidTextFormFieldChromeHandlers, a5 as InvalidTextFormFieldSession, a6 as LoadFontsRequest, a7 as LoadFontsResult, a8 as OpeningIndicatorHost, a9 as OverlayFrameRect, aa as PaginatedSurfaceState, ab as ParagraphPropertyEdit, ac as PopupChromeRegistrationOptions, ad as RemoteCaretLabelAnchor, ae as RemoteCaretLabelHost, af as ReviewWriteIntent, ag as RunTableChromeCommandResult, ah as SectionAnchor, ai as SectionBreakInsertType, aj as SelectedDrawingOverlayTarget, ak as SurfaceEquation, al as SurfaceFormatting, am as SurfaceHyperlink, an as SurfaceInsertImageInput, ao as SurfaceNavigation, ap as SurfaceOverlayCoordinates, aq as SurfaceParagraphFormat, ar as TABLE_BORDER_STYLE_OPTIONS, as as TABLE_BORDER_TARGET_OPTIONS, at as TABLE_BORDER_WIDTH_OPTIONS, au as TABLE_CHROME_SLOT_IDS, av as TableBorderStyleOption, aw as TableBorderTargetOption, ax as TableBorderTargetValue, ay as TableBorderWidthOption, az as TableChromeDraft, aA as TableChromePick, aB as TableChromeSlotId, aC as TableInteractionLabelKey, aD as TextFormFieldChromeHandlers, aE as TextFormFieldDialogSession, aF as ToolbarCommandState, aG as ToolbarSlotValue, aH as ToolbarValueMap, aI as ToolbarValueSlot, aJ as applyTableChromePick, aK as bindHistoryGroup, aL as blankDocumentBytes, aM as canExecuteImageCommand, aN as captureImageMutationPreconditions, aO as chromeControlCount, aP as chromeMenuSlots, aQ as chromeProbeForSlot, aR as chromeSlotId, aS as chromeSlotIsToggle, aT as commandExecOptions, aU as commandForSlot, aV as commandForSlotValue, aW as commandForTableChromeSlotValue, aX as computeImageResizeResult, aY as computeMovedImagePosition, aZ as computeResizedImageExtentEmu, a_ as createDocxEditor, a$ as createFontSource, b0 as createImageOverlayScrollPort, b1 as cssPixelsToLayoutPoints, b2 as customFonts, b3 as defaultChromeGroups, b4 as defaultTableLabel, b5 as emuToOverlayPoints, b6 as equationAtPosition, b7 as executeImageCommand, b8 as finalizeImageOverlayInteraction, b9 as formattingBarChromeGroups, ba as isChromePrintShortcut, bb as isStaleImageInteractionCommit, bc as isTableChromeSlot, bd as layoutPointsToCssPixels, be as loadFonts, bf as overlayFrameToSheetCssPixels, bg as overlayHostOrigin, bh as pointsToEmu, bi as probeTableChromeCommand, bj as resizePreservesAspect, bk as runChromeExport, bl as runChromePrint, bm as runSave, bn as runTableChromeCommand, bo as runTableCommand, bp as runToolbarCommand, bq as selectedDrawingOverlayTargetOf, br as selectedImageStateOf, bs as surfacePaintScale, bt as tableChromeIconPaths, bu as tableChromeLabelKeyForTarget, bv as tableChromeToolbarState, bw as tableChromeVisible, bx as tableCommandToolbarState, by as toolbarCommandState, bz as toolbarCommandStates } from './index-Bsg7oIKP.js';
+import { a as AutomationCapabilities, b as AutomationHost } from './protocol-Bqk4Izjc.js';
+import { S as SemanticLayout } from './semantic-records-4B3WwFAi.js';
+export { T as TextMeasurer } from './semantic-records-4B3WwFAi.js';
+import { b as ReviewPaneOverflow } from './review-pane-D9jm8DcY.js';
+export { C as CommentMarkerStyle, D as DEFAULT_REVIEW_PANE, a as ResolvedReviewPane, c as ReviewPaneItemFields, d as ReviewPaneOpening, R as ReviewPaneOptions, e as RevisionDisplay, r as resolveReviewPane, f as reviewPaneListsItem } from './review-pane-D9jm8DcY.js';
+export { D as DEFAULT_REVISION_MARKUP, f as REVISION_MARKUP_COLORS, d as ResolvedRevisionMarkup, a as ReviewDisplayMode, g as RevisionChangedLinesMark, h as RevisionDeletionMark, i as RevisionMarkupChromeHandlers, j as RevisionMarkupColor, R as RevisionMarkupDialogSession, k as RevisionMarkupMark, l as RevisionMarkupNamedColor, e as RevisionMarkupOptions, m as RevisionMarkupStyle, n as RevisionMarkupTextStyle, r as resolveRevisionMarkup } from './revision-projection-DZ4kKVev.js';
+export { N as NavigationCommand, S as SemanticPosition, a as SemanticSelection } from './semantic-interaction-CIC-PooQ.js';
+export { S as SectionProperties } from './semantic-cell-selection-D9D1KSXq.js';
+export { F as FieldShadingMode, R as ReviewAuthorInfo, b as RevisionAuthorAssignments, c as RevisionAuthorStyle, d as RevisionStyles } from './semantic-paint-BME37OMv.js';
+export { CollaborationModuleContribution } from './collaboration.js';
+import './editor-scope-OHPwVQ5l.js';
+import './collaboration/replication.js';
+import './failure-NS2lsya4.js';
+import './custom-node-writes-cvL5rhcD.js';
+import './headless-document-view-qH331moE.js';
+import 'prosemirror-model';
+import './contracts/document.js';
+import './contracts/interaction.js';
+import './document-protection-BAGVGqaP.js';
+import './note-properties-4Y9o6Gyk.js';
+import './omml-equation-CuzBL5DD.js';
+import './semantic-record-queries-CBlZqZNa.js';
+
+declare function toEditorFontError(error: unknown): EditorFontError;
+declare function createLayoutShaping(configuration: FontConfiguration, instrumentation?: LayoutShapingInstrumentation): Promise<LayoutShapingOptions>;
+
+/**
+ * What `snapshot()` reports before an editor exists: loading, not editable, nothing
+ * selected, nothing undoable — never invented state.
+ *
+ * @public
+ */
+declare const LOADING_SNAPSHOT: EditorSnapshot;
+
+/**
+ * True when the engine's PASTE lanes will land user-visible content from this payload, so
+ * a host's image-FILE lane must stand down or insert a duplicate.
+ *
+ * In order of cost: visible `text/plain` (the plain lane's unconditional fallback), visible
+ * HTML text (the projection and the plain lane's HTML fallback both land it), a
+ * zip-shaped embedded fragment, and finally the projection probe for text-free HTML.
+ *
+ * Deliberate asymmetries against the router's letter: text made only of invisible
+ * characters (zero-width wrappers, bidi marks, a bare newline) does not count — the router
+ * technically lands it, but standing down for it would drop a real image for characters
+ * nobody can see. And engine-state gates the adapter cannot observe (suggesting mode, cell
+ * selections, the force-plain window) are ignored; in those states the engine may land
+ * nothing where this predicate said it would.
+ *
+ * @internal
+ */
+declare function clipboardPasteLandsContent(transfer: DataTransfer | null | undefined): boolean;
+/**
+ * True when the engine's DROP lane will land text from this payload, so a host's
+ * image-FILE drop lane must stand down — by NOT preventing the default, which is what
+ * lets the browser fire `insertFromDrop`, the engine's only drop path.
+ *
+ * Only visible HTML text counts. The drop lane is plain text end to end, so fragments and
+ * `data:` images never land from a drop — and `text/plain` says nothing about intent here,
+ * because image-file drags routinely mirror the file's path or URL into it. A text drag
+ * that carries an image file beside it (Word's rendering PNG again) always carries the
+ * text in HTML too.
+ *
+ * @internal
+ */
+declare function clipboardDropLandsText(transfer: DataTransfer | null | undefined): boolean;
+
+/**
+ * Mount a paginated surface over DOCX bytes.
+ *
+ * Returns a typed rejection rather than throwing: a failure here is a property of the file,
+ * and a host must be able to tell "not a package" from "no body" without parsing an error
+ * message.
+ */
+declare function mountPaginatedSurface(container: HTMLElement, bytes: Uint8Array, options?: PaginatedSurfaceOptions): OpenPaginatedResult;
+
+/**
+ * The story a NODE lives in, which is what a write about that node must target.
+ *
+ * The open scope is a near-enough proxy most of the time and wrong exactly when it matters:
+ * nothing binds a node id to it, so a verb invoked on a control, a chip or a paragraph the
+ * reader is not currently standing in wrote against the wrong store — or, where the id came
+ * from a body-only index, against body content the reader could not see.
+ *
+ * Answered from the id's own PART NAME. Node ids are minted `${partName}#${path}`, so the
+ * question is constant-time and needs no store to be opened. That last part is load-bearing:
+ * asking each scope for its paragraph list instead OPENS a story store, the store cap is 64,
+ * and a store whose part is still in the package is never evicted — on a many-section
+ * document that left later headers unopenable for the rest of the session.
+ *
+ * Falls back to `fallback` for an id no story claims, so the store refuses it rather than this.
+ */
+/**
+ * The part a NODE lives in, WITHOUT opening a story store.
+ *
+ * `session.partFor(scope)` resolves a scope by opening that story's store, and an open store is
+ * retained for as long as its part is in the package. The cap is 64. So routing a pure READ —
+ * "is this control locked", "what is its tab index" — through `partFor` spent a permanent slot
+ * per part touched, and an id naming no node at all still spent one, because the part name is
+ * matched from the id's prefix before anything is looked up. Sixty-four such reads and no
+ * further header could be opened for the rest of the session, silently.
+ *
+ * Read straight from the live package instead. Ids carry the canonical part name, so this is a
+ * map lookup.
+ */
+declare function partOfNodeId(session: Pick<TreeDocxSessionView, 'currentPackage' | 'part'>, nodeId: string | undefined): OoxmlPart | null;
+
+/** The engine paints at 96 px per inch (twips / 15, 1440 twips per inch). */
+declare const PX_PER_INCH = 96;
+/** Painted pixels per centimetre, derived from {@link PX_PER_INCH}. */
+declare const PX_PER_CM: number;
+/** Which measurement system the ruler shows. Drives both tick cadence and drag snapping. */
+type RulerUnit = 'inch' | 'cm';
+/** One tick on the ruler: where it sits, how tall it is, and its label if it carries one. */
+interface RulerTick {
+    /** Offset along the ruler in content pixels. */
+    readonly position: number;
+    readonly height: number;
+    /** Whole-unit label, omitted at the origin and on minor ticks. */
+    readonly label?: string;
+}
+/**
+ * Ticks across one page dimension, matching the legacy cadence: eighth-inch
+ * minors with labelled inches, or millimetre minors with labelled centimetres.
+ */
+declare function generateRulerTicks(lengthPx: number, unit: RulerUnit): RulerTick[];
+/** The first page's box, which the rulers measure against. */
+declare function rulerPageBox(pages: readonly {
+    readonly index: number;
+    readonly box: {
+        width: number;
+        height: number;
+    };
+}[]): {
+    width: number;
+    height: number;
+} | null;
+
+/** Twips per inch, as OOXML defines them. */
+declare const TWIPS_PER_INCH = 1440;
+/** Twips per centimetre, as Word rounds them. */
+declare const TWIPS_PER_CM = 567;
+/** Word snaps ruler drags to the eighth-inch grid its ticks already draw. */
+declare const SNAP_TWIPS_INCH: number;
+/** The centimetre ruler's grid is the millimetre. */
+declare const SNAP_TWIPS_CM: number;
+
+/**
+ * The four handles Word's ruler carries.
+ *
+ * `hanging` and `left` sit at the SAME position and differ only in what a drag takes with
+ * them — the box moves the whole paragraph, the triangle leaves the first line where it is.
+ */
+type RulerIndentHandle = 'firstLine' | 'hanging' | 'left' | 'right';
+/** A paragraph's indent as the ruler works with it. Twips; `firstLine` signed. */
+interface RulerIndent {
+    readonly left: number;
+    readonly right: number;
+    readonly firstLine: number;
+    /**
+     * The paragraph reads right to left. Its `left` indent is then the LEADING one, on the
+     * right margin, and its first-line offset counts from there, so the ruler axis mirrors.
+     */
+    readonly rtl?: boolean;
+}
+/** The page the handles are placed against. Twips. */
+interface RulerPageMetrics {
+    readonly pageWidth: number;
+    readonly leftMargin: number;
+    readonly rightMargin: number;
+}
+/**
+ * How a ruler drag resolves: which grid it snaps to, and whether it snaps at all.
+ *
+ * @public
+ */
+interface RulerDragOptions {
+    /** Which snap grid applies. Defaults to inches. */
+    readonly unit?: RulerUnit;
+    /** Alt held: continuous, twip-precision drag, bypassing the snap grid — as in Word. */
+    readonly precise?: boolean;
+}
+/**
+ * Where a handle sits, in twips from the page's LEFT SHEET EDGE (not the margin).
+ *
+ * With `indent.rtl`, `indent.left` is the leading indent and sits on the right margin.
+ */
+declare function handlePosition(handle: RulerIndentHandle, indent: RulerIndent, page: RulerPageMetrics): number;
+/** Round to the ruler's grid, or to the twip when the drag is precise. */
+declare function snapTwips(value: number, unit: RulerUnit, precise: boolean): number;
+/**
+ * The indent a drag of `handle` to `positionTwips` produces.
+ *
+ * Clamps differ from the MARGIN drags this ruler also carries, and deliberately:
+ *
+ * - Indents may go NEGATIVE, pulling text into the margin, which Word allows. The floor is
+ *   the sheet edge, not the margin.
+ * - There is no minimum text width. The 720-twip floor the margin drags use mirrors an
+ *   engine refusal that does not exist for indents, and enforcing one here would make a
+ *   narrow pull-quote unreachable. Left and right markers may MEET; they may not cross.
+ * - The left box needs a first-line clamp of its own. It does not move `firstLine`, so on a
+ *   hanging paragraph dragging the box left can push the first-line marker off the sheet
+ *   while the box itself is still in range. The drag stops when the LEADING marker lands.
+ */
+declare function dragIndent(handle: RulerIndentHandle, positionTwips: number, indent: RulerIndent, page: RulerPageMetrics, options?: RulerDragOptions): RulerIndent;
+
+/**
+ * Stable value identity for a command, including nested payloads.
+ *
+ * @internal
+ */
+declare function editorCommandKey(command: EditorCommand): string;
+
+/**
+ * Collapse order: the first id here is the first group to leave the bar.
+ *
+ * Zoom goes first (a document you cannot format is worse than one you cannot scale), then
+ * the small standalone groups, then the paragraph controls, and text formatting and history
+ * last. A group the registry has but this list does not is collapsed before all of these,
+ * in reverse bar order — a host-added group has no declared standing, and the alternative
+ * is a new group that silently never collapses.
+ *
+ * @internal
+ */
+declare const TOOLBAR_COLLAPSE_ORDER: readonly string[];
+/**
+ * Groups that never move into the overflow menu.
+ *
+ * `review` holds the comments toggle and the editing-mode pill. The comments rail is
+ * reached through that toggle and nothing else, and a narrow window is exactly where a
+ * reader needs it, so burying it one menu deep is the wrong trade.
+ *
+ * @internal
+ */
+declare const TOOLBAR_PINNED_GROUPS: ReadonlySet<string>;
+/**
+ * Px of surplus a group must find before it comes back OUT of the overflow menu.
+ *
+ * Without it a value control that widens with its own value (font family going from
+ * "Arial" to "Times New Roman") pushes itself out, which frees the width that pulled it
+ * back in, forever. One-directional slack breaks the loop.
+ *
+ * @internal
+ */
+declare const TOOLBAR_OVERFLOW_HYSTERESIS = 24;
+/**
+ * What {@link toolbarOverflowGroups} measures against.
+ *
+ * @internal
+ */
+interface ToolbarFitInput {
+    /** Content width of the bar, in px. `0` or less means "not measured yet". */
+    readonly available: number;
+    /** Group id -> measured width, separator and gaps included. */
+    readonly widths: ReadonlyMap<string, number>;
+    /** Collapsible groups, in bar order. */
+    readonly groups: readonly string[];
+    /** Collapse order; ids missing from it collapse first, in reverse bar order. */
+    readonly order: readonly string[];
+    /** Width of everything that never collapses: pinned groups, appended children, padding. */
+    readonly fixed: number;
+    /** Width the "⋯" trigger takes once it is shown. */
+    readonly more: number;
+    /** The previous answer, for the one-directional slack. */
+    readonly previous?: ReadonlySet<string> | undefined;
+    readonly hysteresis?: number;
+}
+/**
+ * The priority of a declared group: its place in {@link TOOLBAR_COLLAPSE_ORDER}, in steps of
+ * 10, so zoom is 10 and history is 90. A host group with a `priority` sorts among these, and
+ * a LOWER number leaves the bar first. The steps leave room between two built-in groups.
+ *
+ * @internal
+ */
+declare function toolbarGroupPriority(id: string, order?: readonly string[]): number | undefined;
+/**
+ * The collapse order actually used: the declared one, with undeclared groups first.
+ *
+ * `priorities` gives a group an explicit place among the declared ones (see
+ * {@link toolbarGroupPriority}), and overrides a declared group's own priority. Groups with
+ * neither collapse first, in reverse bar order. Two groups with the same priority collapse
+ * in reverse bar order too: the one further along the bar leaves first.
+ *
+ * @internal
+ */
+declare function collapseOrder(groups: readonly string[], order?: readonly string[], priorities?: ReadonlyMap<string, number>): readonly string[];
+/**
+ * One host group's placement request.
+ *
+ * @internal
+ */
+interface ToolbarHostGroupPlacement {
+    readonly id: string;
+    /** The group this one follows. Absent, or unknown, places it after every group. */
+    readonly after?: string | undefined;
+}
+/**
+ * Bar order with the host's groups placed.
+ *
+ * A host group without `after` follows every built-in group, in order of appearance. A group
+ * with `after` follows the group it names, after any host groups already placed there, so
+ * several groups anchored to one place keep their order of appearance. An anchor may be
+ * another host group. An anchor that never resolves (an unknown id, or a cycle) places the
+ * group at the end.
+ *
+ * @internal
+ */
+declare function arrangeToolbarGroups(builtIn: readonly string[], hosts: readonly ToolbarHostGroupPlacement[]): readonly string[];
+/**
+ * The margin the "⋯" panel keeps from each viewport edge, in px.
+ *
+ * @internal
+ */
+declare const TOOLBAR_PANEL_EDGE_MARGIN = 8;
+/**
+ * Where the "⋯" panel opens, in viewport px.
+ *
+ * @internal
+ */
+interface ToolbarPanelPlacement {
+    /** The panel's left edge. */
+    readonly left: number;
+    /** The widest the panel may be: the viewport less both margins. */
+    readonly maxWidth: number;
+    /** Which trigger edge the panel lines up with, or `clamped` when neither fits. */
+    readonly anchor: 'start' | 'end' | 'clamped';
+}
+/**
+ * Keep the "⋯" panel inside the viewport.
+ *
+ * The panel lines up with the trigger's end edge first, which suits a trigger at the end of
+ * the bar. When that runs past the left edge (a centered or narrow bar), it lines up with
+ * the trigger's start edge instead. When neither fits, it is clamped to the margins.
+ *
+ * @internal
+ */
+declare function toolbarPanelPlacement(input: {
+    readonly triggerLeft: number;
+    readonly triggerRight: number;
+    readonly panelWidth: number;
+    readonly viewportWidth: number;
+    readonly margin?: number;
+}): ToolbarPanelPlacement;
+declare function sameIds(a: ReadonlySet<string>, b: ReadonlySet<string>): boolean;
+/**
+ * True when two answers describe the same bar, so a re-render can be skipped.
+ *
+ * @internal
+ */
+declare const sameOverflow: typeof sameIds;
+/**
+ * The groups that must leave the bar for the rest of it to fit in one row.
+ *
+ * An unmeasured bar (`available <= 0`, which is every server render and every jsdom test)
+ * overflows nothing: the full toolbar is the honest answer when nothing is known about the
+ * space, and it is also what a host that opted out of overflow renders.
+ *
+ * @internal
+ */
+declare function toolbarOverflowGroups(input: ToolbarFitInput): ReadonlySet<string>;
+/**
+ * The left edge, in viewport px, of a popup that opens under a bar control.
+ *
+ * The popup lines up with the control's start edge, and moves left or right only as far as
+ * it must to keep {@link TOOLBAR_PANEL_EDGE_MARGIN} from each viewport edge. A popup wider
+ * than the viewport keeps its left margin.
+ *
+ * @internal
+ */
+declare function toolbarPopupLeft(input: {
+    readonly anchorLeft: number;
+    readonly popupWidth: number;
+    readonly viewportWidth: number;
+    readonly margin?: number;
+}): number;
+
+/**
+ * Leading separator slot cost for one collapsible group (px).
+ *
+ * @internal
+ */
+declare function separatorLeadingCost(separatorWidth: number, marginInlineStart: number, marginInlineEnd: number, gap: number): number;
+/**
+ * Total width charged for one collapsible group on the bar.
+ *
+ * @internal
+ */
+declare function collapsibleGroupCost(groupWidth: number, separatorLeading: number): number;
+/**
+ * Flex gap charged after a fixed group or the More trigger.
+ *
+ * @internal
+ */
+declare function trailingGapCost(width: number, gap: number): number;
+/**
+ * Read inline margins from computed style (px).
+ *
+ * @internal
+ */
+declare function readInlineMargins(style: CSSStyleDeclaration): {
+    readonly start: number;
+    readonly end: number;
+};
+/**
+ * Parse column gap from toolbar computed style.
+ *
+ * @internal
+ */
+declare function readColumnGap(style: CSSStyleDeclaration): number;
+/**
+ * What {@link barRoomWidth} measures against, all in px.
+ *
+ * @internal
+ */
+interface BarRoomInput {
+    /** The bar's current content width: its client width less its inline padding. */
+    readonly own: number;
+    /** The parent's content-box width. `0` or less means it is unknown. */
+    readonly parentContent: number;
+    /** Width the bar's siblings take on the same line, gaps included. */
+    readonly siblings: number;
+    /** The bar's inline margins, auto margins excluded. */
+    readonly margins: number;
+    /** The bar's inline padding, border, and scrollbar. */
+    readonly chrome: number;
+    /** The bar's resolved `max-width` as a border-box width, or null for none. */
+    readonly maxWidth: number | null;
+}
+/**
+ * The content width the bar CAN take, which is what decides what fits.
+ *
+ * A bar that fills its container can take exactly the box it has. A bar as wide as its
+ * content (`width: max-content`, a floating pill) shrinks when a group leaves, so its own box
+ * never shows the room outside it, and a collapsed group would never come back. The room is
+ * the parent's content width, less the siblings on the same line and the bar's margins,
+ * capped by the bar's `max-width`. It is never less than the box the bar already has.
+ *
+ * @internal
+ */
+declare function barRoomWidth(input: BarRoomInput): number;
+/**
+ * True when one of the bar's controls runs past its content box, false when they all fit,
+ * and null when the bar has no layout to read (a zero-width box, as in a DOM without
+ * layout). Measured from the controls, not `scrollWidth`, so an open popup (the More panel,
+ * the table grid) that reaches past the bar's edge is not mistaken for an overflow.
+ *
+ * @internal
+ */
+declare function controlsOverflow(bar: HTMLElement, style: CSSStyleDeclaration): boolean | null;
+/**
+ * The bar's available content width.
+ *
+ * The bar's own box, except for a CONTENT-SIZED bar (specified width `auto`, `max-content`,
+ * `fit-content`, or `min-content`, and not growing as a flex item) in a layout this file
+ * understands: a block-level bar in a `block` or `flow-root` parent, or an item of a
+ * single-line flex row. That bar gets the room it can take, see {@link barRoomWidth}. A grid
+ * cell, a table cell, an inline bar, a floated bar, an explicit width, an out-of-flow bar, a
+ * `max-width` that does not resolve, a growing sibling with content, loose text in the row,
+ * and a browser without Typed OM all keep the bar's own box: the safe side, which collapses
+ * early rather than overflowing the next column.
+ *
+ * The parent-based room only ever brings groups BACK. A bar whose controls overflow its box
+ * measures its own box, so the fit collapses groups until they fit. When that overflow
+ * follows groups that came back from the room, the room was wrong: the bar's width becomes
+ * a cap until the parent's width changes, so the bar does not flicker.
+ *
+ * @internal
+ */
+declare function readAvailableWidth(bar: HTMLElement, style: CSSStyleDeclaration): number;
+
+/**
+ * Which LETTER a chord names, for the accelerators held with Alt.
+ *
+ * The CHARACTER first. A user reaching for Ctrl+Alt+F presses the key that types `f`,
+ * wherever their layout puts it, and Windows resolves accelerators the same way — so reading
+ * the physical position first sent Dvorak's footnote chord to the key that types `u`.
+ *
+ * `event.code` is the fallback, for the case that makes `key` unreadable: a modifier that
+ * COMPOSES. macOS turns Option+F into `ƒ`, Option+C into `ç` and Option+D into `∂`, none of
+ * them a letter — so falling through to the keycap is the only way those chords work there,
+ * and it costs nothing, because a `key` that IS a letter has already answered.
+ *
+ * Never both for one event: consulting `code` as well would claim a second chord wherever
+ * the two disagree, which is every remapped layout.
+ *
+ * Shared with the adapters, whose Find shortcut reads letters the same way.
+ *
+ * @internal
+ */
+declare function chordLetter(event: KeyboardEvent): string;
+
+/** Planner-backed can/plan pair — production gate for table commands. Task 9 maps chrome slots. */
+declare function tableCommandState(command: EditorCommand, surface: PaginatedSurface): {
+    readonly can: CanResult;
+    readonly plan: TableCommandPlan;
+};
+
+/**
+ * What a browser host can do.
+ *
+ * `selection`, `scrolling` and `layout` are true because a mounted editor genuinely has a
+ * caret, a scroll container and paginated layout — a consumer may branch on them. The
+ * DOCUMENT operations behave identically to the headless host regardless; the extra
+ * capabilities widen what may be asked later, never what an existing operation means.
+ */
+declare const BROWSER_AUTOMATION_CAPABILITIES: AutomationCapabilities;
+/**
+ * An automation host over a live editor.
+ *
+ * The editor keeps its own lifetime: `dispose()` on the returned host releases the change
+ * subscription this adapter took and leaves the editor mounted and editable.
+ *
+ * `save()` validates pending form input. Invalid values and saves during an active edit
+ * return `transaction-refused`. For autosaving from change callbacks, use the asynchronous
+ * `editor.save()`, which waits for the active edit to finish.
+ */
+declare function createBrowserAutomationHost(editor: DocxEditorInstance): AutomationHost;
+
+/** Clamp and validate an OOXML theme modifier fraction (0, 1]. */
+declare function validateThemeModifier(value: unknown): value is number;
+/** Blend toward white. `keep` is the fraction of the base colour retained (OOXML themeTint byte). */
+declare function applyThemeTint(hex: string, keep: number): string;
+/** Blend toward black. `keep` is the fraction of the base colour retained (OOXML themeShade byte). */
+declare function applyThemeShade(hex: string, keep: number): string;
+/** Resolve a theme colour to literal hex. When both tint and shade are present, ECMA-376
+ *  §17.3.2.6 / §17.3.4 / §17.3.5 require tint precedence — shade is ignored for paint. */
+declare function resolveThemeColorHex(color: Extract<ColorValue, {
+    kind: 'theme';
+}>, themeColors: readonly DocumentThemeColorEntry[]): {
+    ok: true;
+    hex: string;
+} | {
+    ok: false;
+    reason: string;
+};
+type ColorLowerRefusal = {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * A public colour lowered for a border or fill op, or the reason it could not be.
+ *
+ * Refusals happen because paint needs a literal: a theme colour the document's theme does not
+ * define has no hex to draw, and inventing one would show a border in a colour the file never
+ * named.
+ */
+type ColorLowerResult = {
+    readonly ok: true;
+    readonly color: TreeDocColorValue;
+} | ColorLowerRefusal;
+/**
+ * Lower a public colour for table border ops. Theme colours require a resolved literal for
+ * paint; `auto` preserves OOXML automatic semantics with a black render fallback.
+ */
+declare function lowerColorValueForBorder(color: ColorValue, themeColors: readonly DocumentThemeColorEntry[]): ColorLowerResult;
+/**
+ * Lower a public colour for cell fill. `auto` refuses because the cascade literal
+ * cannot be named honestly at commit time.
+ */
+declare function lowerColorValueForFill(color: ColorValue, themeColors: readonly DocumentThemeColorEntry[]): ColorLowerResult;
+/** Resolve any public colour to a CSS `#RRGGBB` string for chrome display. */
+declare function resolveColorValueToCss(color: ColorValue | undefined | null, themeColors: readonly DocumentThemeColorEntry[], defaultHex?: string): string;
+
+interface SurfaceExtent {
+    readonly width: number;
+    readonly height: number;
+    readonly pageOffsetX: ReadonlyMap<number, number>;
+}
+declare function surfaceExtent(layout: SemanticLayout, materialize: ReadonlySet<number> | undefined): SurfaceExtent;
+
+/**
+ * The review pane's marker strip on one page edge, in CSS px: the markers and the
+ * add-comment button. The adapters' review gutters and the zoom fit share this value.
+ *
+ * Shared adapter glue, not for hosts.
+ *
+ * @internal
+ */
+declare const REVIEW_MARKERS_GUTTER_PX = 44;
+/** The narrowest scale the editor contract accepts. One definition, every user. */
+declare const ZOOM_MIN = 0.1;
+/** The widest scale the editor contract accepts. */
+declare const ZOOM_MAX = 5;
+/**
+ * Fit the page width, but never magnify and never shrink past legibility: the default.
+ *
+ * A wide container keeps the 100% it has always had, and only one too narrow to hold the
+ * sheet shrinks. Uncapped fitting would render a Letter page at 183% on a 1600px monitor,
+ * which is a reader app, not Word; unfloored fitting would render it at 20% beside an open
+ * comments rail on a phone.
+ */
+declare const AUTO_ZOOM_MODE: ZoomMode;
+/**
+ * Fit the page width in BOTH directions — the uncapped fit, unlike `'auto'`.
+ *
+ * A shared constant rather than a literal per call site: modes are compared by value, but a
+ * control also has to render its own selected state, and two spellings of one mode in two
+ * files is how a menu ends up ticking a row the editor is not in.
+ */
+declare const FIT_WIDTH_ZOOM_MODE: ZoomMode;
+/**
+ * Normalize the `'auto'` shorthand a host may pass anywhere a {@link ZoomMode} is accepted.
+ *
+ * Returns `null` for a value that is neither, so callers refuse rather than silently
+ * substituting a mode the caller did not ask for.
+ */
+declare function resolveZoomMode(mode: ZoomMode | 'auto'): ZoomMode | null;
+/**
+ * Whether two modes say the same thing.
+ *
+ * `snapshotsEqual` compares `zoomMode` by IDENTITY, and a host's `zoomMode` prop is an object
+ * — `<DocxEditor zoomMode={{ type: 'fit', fit: 'pageWidth' }} />` is a fresh literal on every
+ * render, which is the spelling the docs show. Without a value comparison somewhere, each of
+ * those renders reinstalled the observer, refitted, bumped the tick, and re-rendered every
+ * `useEditorState` consumer in the tree — including the page selector that the slice
+ * memoization exists to keep asleep. The lane holds its object and compares by value here.
+ */
+declare function sameZoomMode(a: ZoomMode, b: ZoomMode): boolean;
+/**
+ * The scale the page is ENTITLED to when the review rail decides whether its full card
+ * column fits beside the page, or `null` when the page has no entitlement to measure.
+ *
+ * The rail must never measure the LIVE zoom under a fit: that zoom already includes the
+ * room the rail reserved last frame, so a threshold computed from it chases itself. The
+ * entitlement depends only on the mode (and on the held scale for a fixed mode), so the
+ * rail settles in one pass.
+ *
+ * - A fixed mode is entitled to the scale in force.
+ * - A fit with the review pane's `overflow: 'shrinkPage'` is entitled to its lower bound: the column stands
+ *   whenever ANY scale the fit may take leaves room for it, and the fit then paints at
+ *   the largest of those inside the padded box.
+ * - A capped fit is entitled to its cap.
+ * - An uncapped fit returns `null`: it fills whatever box it is given, so the full column
+ *   always stands.
+ *
+ * Shared adapter glue for the review gutter, not for hosts.
+ *
+ * @internal
+ */
+declare function reviewPaneEntitledZoom(mode: ZoomMode | undefined, zoom: number, overflow?: ReviewPaneOverflow): number | null;
+
+/** How {@link listenForPopupEscape} decides and acts. @internal */
+interface PopupEscapeOptions {
+    /** The popup's root. Its `ownerDocument` receives the listener. */
+    readonly popup: HTMLElement;
+    /** Whether a node belongs to the popup (its trigger, list, or a separate panel). */
+    readonly contains: (node: Node) => boolean;
+    /** Elements of this editor beyond its `.docx-editor` container, such as the viewport. */
+    readonly editorElements?: () => readonly (Element | null | undefined)[];
+    /**
+     * The chrome root that holds the popup, such as the toolbar or the menu bar. It scopes
+     * itself with its own `.docx-editor` class, and a key from it counts as this editor's.
+     */
+    readonly chromeRoot?: () => Element | null | undefined;
+    /** Return true to leave this Escape to someone else (an input that owns the key). */
+    readonly skip?: (event: KeyboardEvent) => boolean;
+    /** Close the popup. `fromInside` is true when the key came from inside the popup. */
+    readonly close: (fromInside: boolean) => void;
+}
+/**
+ * The nearest `.docx-editor` around `from` that holds the painted pages, or null.
+ *
+ * Chrome parts carry their own styling-only `docx-editor` class, so the first match from
+ * a toolbar is the toolbar. The instance container is the first one with pages inside.
+ *
+ * @internal
+ */
+declare function editorInstanceScope(from: Element | null): Element | null;
+/**
+ * Close an open toolbar popup on Escape, ahead of the surface. Returns the disposer.
+ *
+ * Shared adapter glue, not for hosts.
+ *
+ * @internal
+ */
+declare function listenForPopupEscape(options: PopupEscapeOptions): () => void;
+/**
+ * Whether a nested popup inside `panel` is open. Its own Escape listener closes it, and
+ * the panel stays open for the next Escape.
+ *
+ * @internal
+ */
+declare function hasOpenNestedPopup(panel: Element | null): boolean;
+/** How {@link listenForPopupFocusLeave} decides. @internal */
+interface PopupFocusLeaveOptions {
+    /** The popup's root. Its `ownerDocument` receives the listener. */
+    readonly popup: HTMLElement;
+    /** Whether a node belongs to the popup (its trigger, list, or a separate panel). */
+    readonly contains: (node: Node) => boolean;
+    /** Close the popup. */
+    readonly close: () => void;
+}
+/**
+ * Close an open popup when focus moves outside it, for example to the find field after
+ * Ctrl+F or to a host input. Two moves keep the popup open: focus that lands in the painted
+ * pages, because a toolbar click leaves the caret there while the popup is open, and focus
+ * that enters one of this editor's modal dialogs, because the popup may have opened it and
+ * the dialog returns focus to its opener when it closes. A host's own modal dialog closes
+ * the popup like any other control. Returns the disposer.
+ *
+ * @internal
+ */
+declare function listenForPopupFocusLeave(options: PopupFocusLeaveOptions): () => void;
+
+/** Validate a position input, refusing offsets or bases outside what OOXML allows. */
+declare function validateDrawingPositionInput(position: DrawingPositionInput): boolean;
+/** Legal `relativeFrom` bases for a horizontal offset (page, margin, column, character, …). */
+declare const DRAWING_REL_FROM_H: readonly string[];
+/** Legal `relativeFrom` bases for a vertical offset (page, margin, paragraph, line, …). */
+declare const DRAWING_REL_FROM_V: readonly string[];
+/** Whether an image-properties command carries any positioning fields at all. */
+declare function propertiesCommandHasPositionFields(command: {
+    readonly horizontalEmu?: number;
+    readonly verticalEmu?: number;
+    readonly relativeToH?: string;
+    readonly relativeToV?: string;
+}): boolean;
+/** Extract the position input from an image-properties command, or null when it carries none. */
+declare function positionInputFromPropertiesCommand(command: {
+    readonly horizontalEmu?: number;
+    readonly verticalEmu?: number;
+    readonly relativeToH?: string;
+    readonly relativeToV?: string;
+}, selected: {
+    readonly position?: DrawingPositionInput | null;
+} | null): DrawingPositionInput;
+/** Validate a set-position command before it reaches the store. */
+declare function validateSetImagePositionCommand(command: {
+    readonly horizontalEmu?: number;
+    readonly verticalEmu?: number;
+    readonly relativeToH?: string;
+    readonly relativeToV?: string;
+}, mode: 'frame' | 'simple'): boolean;
+
+/** One tri-state paragraph flag: on, off, or "the selection disagrees". @public */
+type ParagraphFlagState = boolean | null;
+/**
+ * What the Paragraph dialog reads: every field, as the selection currently stands.
+ *
+ * A `null` means the selection's paragraphs DISAGREE about that field, which a control
+ * shows as an indeterminate checkbox or an empty box rather than as a value. `indent` is
+ * the exception the engine already documents — it reports the first touched paragraph and
+ * flags disagreement per field, because a ruler has to draw its handles somewhere.
+ *
+ * @public
+ */
+interface ParagraphFormatRead {
+    /**
+     * `justify`, not OOXML's `both`. The engine speaks `w:jc` values; an adapter speaks the
+     * word its consumers write. Read and write use the SAME spelling here, so a value that
+     * comes out of `format` can go straight back into `apply`.
+     */
+    readonly alignment: 'left' | 'center' | 'right' | 'justify' | null;
+    /** Base direction (`w:bidi` through the cascade); null when the selection mixes them. */
+    readonly direction: 'ltr' | 'rtl' | null;
+    readonly spaceBeforePt: number | null;
+    readonly spaceAfterPt: number | null;
+    readonly lineSpacing: {
+        readonly rule: 'multiple' | 'exact' | 'atLeast';
+        readonly value: number;
+    } | null;
+    readonly indentLeftTwips: number | null;
+    readonly indentRightTwips: number | null;
+    /** ONE signed first-line offset: negative is a hanging indent. */
+    readonly indentFirstLineTwips: number | null;
+    readonly contextualSpacing: ParagraphFlagState;
+    readonly keepNext: ParagraphFlagState;
+    readonly keepLines: ParagraphFlagState;
+    readonly widowControl: ParagraphFlagState;
+    readonly pageBreakBefore: ParagraphFlagState;
+    /** Custom tab stops, cascade included. Null when the selection disagrees. */
+    readonly tabStops: readonly ParagraphTabStop[] | null;
+    /**
+     * Which fields are `null` because the selection DISAGREES, as opposed to because nothing
+     * states them.
+     *
+     * A `null` alone cannot tell those apart, and both readings shipped as bugs: a
+     * disagreement rendered as a concrete value is uncorrectable, because the value that
+     * would fix it is the one already on screen; an absent value rendered as "mixed" tells a
+     * single paragraph it disagrees with itself.
+     */
+    readonly disagrees: {
+        readonly alignment: boolean;
+        readonly direction: boolean;
+        readonly spaceBeforePt: boolean;
+        readonly spaceAfterPt: boolean;
+        readonly lineSpacing: boolean;
+        readonly tabStops: boolean;
+        readonly indentLeft: boolean;
+        readonly indentRight: boolean;
+        readonly indentFirstLine: boolean;
+    };
+    /**
+     * Whether the indent reads are UNKNOWN rather than disagreed.
+     *
+     * The engine reports no indent at all for a paragraph inside a table — correct, but not
+     * placeable on a ruler. A control must not call that "mixed": one paragraph cannot
+     * disagree with itself, and the commonest paragraph in a real document is in a cell.
+     */
+    readonly indentUnknown: boolean;
+}
+/**
+ * The fields `apply` accepts. Omitted fields are left as authored; `null` where allowed
+ * REMOVES the setting so the style supplies it again, which is not the same as a zero.
+ *
+ * @public
+ */
+interface ParagraphFormatUpdate {
+    readonly alignment?: 'left' | 'center' | 'right' | 'justify';
+    /** Word's Direction. `ltr` overrides a right-to-left style with `w:bidi w:val="0"`. */
+    readonly direction?: 'ltr' | 'rtl';
+    readonly spaceBeforePt?: number | null;
+    readonly spaceAfterPt?: number | null;
+    readonly lineSpacing?: {
+        readonly rule: 'multiple' | 'exact' | 'atLeast';
+        readonly value: number;
+    } | null;
+    readonly indentLeftTwips?: number | null;
+    readonly indentRightTwips?: number | null;
+    readonly indentFirstLineTwips?: number | null;
+    readonly contextualSpacing?: boolean;
+    readonly keepNext?: boolean;
+    readonly keepLines?: boolean;
+    readonly widowControl?: boolean;
+    readonly pageBreakBefore?: boolean;
+    /** Replace the custom tab stops. An EMPTY list clears them; omit to leave them alone. */
+    readonly tabStops?: readonly ParagraphTabStop[];
+}
+
+/** Shared draft conversion and mixed-value handling for Paragraph dialogs. */
+
+/** @public */
+declare const twipsToInches: (twips: number) => number;
+/**
+ * Inches for DISPLAY, in the BROWSER's number format.
+ *
+ * `0.5` and `0,5` are the same measurement, and roughly half the locales this ships with
+ * write the second one. Interpolating a raw `Number` into a string picks the first for
+ * everyone. The catalogue supplies the surrounding words; this supplies the number.
+ *
+ * Not the editor's locale: nothing in the i18n layer exposes one to read, so a German
+ * editor in an American browser still renders `0.5`. The browser's guess beats a hardcoded
+ * `.` for every reader whose browser matches their language, which is most of them.
+ * @public
+ */
+declare const formatInches: (twips: number) => string;
+/** @public */
+declare const inchesToTwips: (inches: number) => number;
+/** @public */
+type TabAlignment = 'left' | 'center' | 'right' | 'decimal' | 'bar';
+/** @public */
+type TabLeaderName = 'none' | 'dot' | 'hyphen' | 'underscore';
+/** One label key per alignment, so the rows read as words rather than as `w:val` values. * @public
+ */
+declare const TAB_ALIGNMENT_LABELS: {
+    readonly left: 'dialogs.paragraph.tabAlignLeft';
+    readonly center: 'dialogs.paragraph.tabAlignCenter';
+    readonly right: 'dialogs.paragraph.tabAlignRight';
+    readonly decimal: 'dialogs.paragraph.tabAlignDecimal';
+    readonly bar: 'dialogs.paragraph.tabAlignBar';
+};
+/** The "Special" pair: the signed first-line offset, split into a kind and a magnitude. * @public
+ */
+type SpecialIndent = 'none' | 'firstLine' | 'hanging';
+/** @public */
+declare const specialOf: (signedTwips: number | null) => SpecialIndent;
+/** Fold the "Special" pair back into the ONE signed value the engine takes. * @public
+ */
+declare const signedFirstLineOf: (kind: SpecialIndent, magnitudeTwips: number) => number;
+/**
+ * Every field of the form, in the shape the controls hold it.
+ *
+ * Deliberately flat and all-defined: this is what the dialog SHOWS, and a control cannot
+ * show "mixed" and a number at once. The disagreement itself is remembered by comparing
+ * against the seed, not by keeping a null in here.
+ * @public
+ */
+interface ParagraphDialogFields {
+    alignment: 'left' | 'center' | 'right' | 'justify';
+    direction: 'ltr' | 'rtl';
+    indentLeft: number;
+    indentRight: number;
+    special: SpecialIndent;
+    specialBy: number;
+    spaceBefore: number;
+    spaceAfter: number;
+    lineRule: 'multiple' | 'exact' | 'atLeast';
+    lineValue: number;
+    contextualSpacing: boolean;
+    keepNext: boolean;
+    keepLines: boolean;
+    widowControl: boolean;
+    pageBreakBefore: boolean;
+    tabStops: readonly ParagraphTabStop[];
+    /** The user pressed "Clear all", which is a decision even when the list already looked empty. */
+    clearedAllTabStops: boolean;
+}
+/**
+ * Open the form on the selection.
+ *
+ * A `null` field means the selection DISAGREES about that setting. There is no third
+ * checkbox state to show it with, so the control opens on the least surprising value and
+ * {@link changedFields} keeps the disagreement alive by not writing what the user did not
+ * touch. `widowControl` opens ON because that is the Word default a document inherits
+ * when nothing says otherwise.
+ * @public
+ */
+declare function seedFields(format: ParagraphFormatRead): ParagraphDialogFields;
+/**
+ * Which settings the selection DISAGREES about, so a control can show it.
+ *
+ * The value fields need this as much as the checkboxes do. A control that renders a
+ * disagreement as a plausible-looking number is not just unhelpful — it makes the
+ * disagreement uncorrectable, because the value that would fix it is the one already on
+ * screen, so `changedFields` sees nothing move and writes nothing. Four paragraphs at
+ * mixed alignments showed "Left" and could not be set to Left.
+ * @public
+ */
+interface ParagraphDialogMixed {
+    readonly contextualSpacing: boolean;
+    readonly keepNext: boolean;
+    readonly keepLines: boolean;
+    readonly widowControl: boolean;
+    readonly pageBreakBefore: boolean;
+    /** The selection's paragraphs carry DIFFERENT tab stops, so the list shows none of them. */
+    readonly tabStops: boolean;
+    readonly alignment: boolean;
+    readonly direction: boolean;
+    readonly indentLeft: boolean;
+    readonly indentRight: boolean;
+    readonly special: boolean;
+    readonly spaceBefore: boolean;
+    readonly spaceAfter: boolean;
+    readonly lineSpacing: boolean;
+}
+/** The five members that are checkboxes, and so share a label key with their control. * @public
+ */
+type ParagraphFlagKey = 'contextualSpacing' | 'keepNext' | 'keepLines' | 'widowControl' | 'pageBreakBefore';
+/** @public */
+declare const NO_MIXED_FIELDS: ParagraphDialogMixed;
+/**
+ * A checkbox over a setting the selection disagrees about is INDETERMINATE, not unchecked
+ * — unchecked would claim the paragraphs agree it is off. The read reports `null` for
+ * exactly this, and a control that collapses it to a boolean throws the distinction away.
+ * @public
+ */
+declare function mixedFieldsOf(format: ParagraphFormatRead): ParagraphDialogMixed;
+/** Whether two stop lists say the same thing. A list needs more than reference equality. * @public
+ */
+declare function sameTabStops(a: readonly ParagraphTabStop[], b: readonly ParagraphTabStop[]): boolean;
+/**
+ * The submission: ONLY the fields that moved since the dialog opened.
+ *
+ * Sending the whole form would flatten every setting the selection disagrees about. A
+ * mixed `keepNext` would become off on every paragraph, and a mixed left indent would
+ * become an explicit zero — which is worse than wrong, because a zero BLOCKS the style
+ * cascade where leaving the setting alone would let the style keep supplying it. An
+ * untouched field is not a decision, so it is not written.
+ *
+ * Returns null when nothing moved, which the caller treats as "just close": an empty
+ * write would still push an undo entry that restores nothing.
+ * @public
+ */
+declare function changedFields(seed: ParagraphDialogFields, current: ParagraphDialogFields, 
+/** What the selection disagreed about when the dialog opened. */
+seedMixed?: ParagraphDialogMixed, 
+/** What it still disagrees about now. A field that left this set was RESOLVED. */
+currentMixed?: ParagraphDialogMixed): ParagraphFormatUpdate | null;
+/**
+ * The physical alignment a paragraph shows after its direction flips, with its stored
+ * `w:jc` unchanged: leading and trailing edges trade sides. A dialog applies this to its
+ * Alignment field when Direction changes, so the field shows what OK will produce, the same
+ * result as the toolbar's direction buttons.
+ * @public
+ */
+declare function alignmentAfterDirectionChange(alignment: ParagraphDialogFields['alignment']): ParagraphDialogFields['alignment'];
+/** Add one stop, replacing any stop already at that position, and keep the list sorted. * @public
+ */
+declare function withTabStop(stops: readonly ParagraphTabStop[], stop: ParagraphTabStop): readonly ParagraphTabStop[];
+/**
+ * Keep Tab inside the dialog.
+ *
+ * `aria-modal` tells assistive tech the rest of the page is inert; it does not stop Tab,
+ * so without this the third Tab lands on the document behind the dialog — which is the
+ * editable surface, so the next keystroke types into the paragraph being formatted.
+ *
+ * Returns true when the event was handled, so a caller only has to call `preventDefault`.
+ * @public
+ */
+declare function trapTabWithin(panel: HTMLElement, event: KeyboardEvent): boolean;
+
+/** One cell of a month grid. @public */
+interface CalendarDay {
+    /** Local calendar date as `YYYY-MM-DD`. */
+    readonly iso: string;
+    /** Day of the month, 1-based. */
+    readonly day: number;
+    /** Accessible name, spelled out in the calendar locale. */
+    readonly label: string;
+    /** The cell pads the grid from the previous or next month. */
+    readonly otherMonth: boolean;
+    /** The cell is the control's current value. */
+    readonly selected: boolean;
+    /** The cell is the current local date. */
+    readonly today: boolean;
+}
+/** A six-week month grid plus its labels. @public */
+interface CalendarMonth {
+    readonly year: number;
+    /** Zero-based, like `Date#getMonth`. */
+    readonly month: number;
+    /** Month and year, formatted in the calendar locale. */
+    readonly title: string;
+    /** Seven weekday labels, starting on the locale's first day of the week. */
+    readonly weekdays: readonly string[];
+    /** Exactly 42 cells, so the pop-up keeps one height across months. */
+    readonly days: readonly CalendarDay[];
+}
+/** Inputs for {@link calendarMonth}. @public */
+interface CalendarMonthOptions {
+    /** BCP 47 tag; an unsupported tag falls back to `en-US`. */
+    readonly locale?: string;
+    /** The control's current value as `YYYY-MM-DD`, or empty. */
+    readonly selected?: string | null;
+    /** The reference "today"; defaults to the current local date. */
+    readonly today?: Date;
+}
+/** Format a local date as `YYYY-MM-DD`. @public */
+declare function isoDateOf(date: Date): string;
+/**
+ * Parse the leading `YYYY-MM-DD` of an ISO value as a LOCAL date, or null.
+ *
+ * A control's `w:fullDate` is `YYYY-MM-DDT00:00:00Z`; only its calendar date matters here,
+ * and reading it through `Date` in a western time zone would show the previous day.
+ * @public
+ */
+declare function parseIsoDate(value: string): Date | null;
+/**
+ * First day of the week for a locale, as `Date#getDay` counts it (0 = Sunday).
+ *
+ * Asks the runtime's week data when it has any, and otherwise falls back to a region table
+ * so a server without ICU week info still starts a US calendar on Sunday.
+ * @public
+ */
+declare function firstDayOfWeek(locale?: string): number;
+/** Month-and-year title for a grid, formatted in the calendar locale. @public */
+declare function calendarMonthTitle(year: number, month: number, locale?: string): string;
+/** Seven weekday labels starting on the locale's first weekday. @public */
+declare function calendarWeekdays(locale?: string): readonly string[];
+/**
+ * Build the six-week grid for one month.
+ *
+ * Bounded by construction: 42 cells whatever the month, and every value is derived from the
+ * year and month numbers, never from document text.
+ * @public
+ */
+declare function calendarMonth(year: number, month: number, options?: CalendarMonthOptions): CalendarMonth;
+/** The month after or before `(year, month)`, wrapping the year. @public */
+declare function shiftMonth(year: number, month: number, delta: 1 | -1): {
+    readonly year: number;
+    readonly month: number;
+};
+/** Calendar keyboard destination. Shift+PageUp/PageDown moves one year. @public */
+declare function calendarDateForKey(iso: string, key: string, locale?: string, shift?: boolean): string | null;
+/** Format an ISO date for numeric entry in the editor locale. @public */
+declare function calendarDateText(iso: string, locale?: string): string;
+/** Parse a complete ISO or regional numeric date; ambiguous two-digit years are refused. @public */
+declare function calendarDateFromText(text: string, locale?: string): string | null;
+/** The twelve Gregorian month names for a month selector. @public */
+declare function calendarMonthNames(locale?: string): readonly string[];
+
+/** Shared focus and placement for engine and host value pop-ups. */
+/** Place a popup against an anchor, within the viewport or its visible sheet. @public */
+declare function positionContentControlPopup(panel: HTMLElement, anchor: HTMLElement): void;
+/** Follow scrolling, zoom, and size changes. Call the returned cleanup when the popup closes. @public */
+declare function observeContentControlPopup(panel: HTMLElement, anchor: HTMLElement): () => void;
+/** Keep keyboard input inside a popup; Escape cancels and Tab wraps visible controls. @public */
+declare function contentControlPopupKeyDown(panel: HTMLElement, event: KeyboardEvent, cancel: () => void): void;
+/** Capture a popup's opener, with the editable pages as fallback when no control had focus. @public */
+declare function contentControlPopupOpener(anchor: HTMLElement | null): HTMLElement | null;
+
+/** The stateful keyboard behavior used by all value lists. @public */
+interface ContentControlListNavigation {
+    /** Handle list keys on a popup root. Input editing keys remain native. */
+    keyDown(event: KeyboardEvent, root: HTMLElement): void;
+    /** Reset typeahead when opening a different session. */
+    reset(): void;
+}
+/** Create bounded, locale-aware typeahead and roving focus for a popup's options. @public */
+declare function createContentControlListNavigation(locale?: string): ContentControlListNavigation;
+
+/** The `accept` list of the engine's picker: what `replaceImage` takes. */
+declare const CONTENT_CONTROL_PICTURE_ACCEPT = "image/png,image/jpeg,image/gif,image/bmp,image/webp";
+
+/** A processor location in the returned document's body, including table paragraphs. @public */
+interface RefreshLocation {
+    /** OOXML w14:paraId: eight hexadecimal digits, 00000001 through 7FFFFFFF. Case-insensitive. Use this or paragraphIndex, not both. */
+    readonly paragraphId?: string;
+    /** Zero-based body paragraph index in document order. */
+    readonly paragraphIndex?: number;
+    /** UTF-16 offsets in the returned paragraph. */
+    readonly start: number;
+    readonly end: number;
+    /** Exact returned text at these offsets. Required to reject mismatched metadata. */
+    readonly text: string;
+}
+/** One processor change. Keep its id stable across cumulative results. @public */
+interface RefreshChangeInput {
+    readonly id: string;
+    /** Processor-provided review summary, including changes without a body location. Maximum: 1000 characters. */
+    readonly description?: string;
+    readonly location?: RefreshLocation;
+    /** Deletions without a surviving range have no highlight. */
+    readonly unavailableReason?: 'deleted' | 'unavailable';
+}
+/** One validated change for an accepted result. @public */
+interface RefreshChange {
+    readonly id: string;
+    /** Processor-provided summary. The controller does not compute a document diff. */
+    readonly description?: string;
+    /** Identity of the accepted submission and processor sequence. */
+    readonly resultId: string;
+    /** True for a new change id, changed text, or changed description in an existing change id. */
+    readonly isNew: boolean;
+    readonly status: 'available' | 'deleted' | 'unavailable' | 'invalid' | 'unsupported-story';
+    readonly location?: RefreshLocation;
+    /** Why this change cannot receive a highlight. Includes the requested location when supplied. */
+    readonly diagnostic?: {
+        readonly code: 'missing-location' | 'deleted' | 'invalid-selector' | 'invalid-paragraph-id' | 'paragraph-not-found' | 'ambiguous-paragraph-id' | 'invalid-offsets' | 'text-mismatch' | 'not-rendered' | 'unsupported-story' | 'multiple-paragraphs';
+        readonly location?: RefreshLocation;
+    };
+}
+/** A document captured for external processing. Treat this object as an opaque token. @public */
+interface RefreshSubmission {
+    readonly id: string;
+    readonly bytes: ArrayBuffer;
+}
+/** Cumulative output for one submission. Assign sequence at the processor, before delivery. @public */
+interface RefreshUpdate {
+    readonly submission: RefreshSubmission;
+    readonly sequence: number;
+    readonly bytes: ArrayBuffer | Uint8Array;
+    /** Omit to derive changes from tracked revisions when a review module is registered. */
+    readonly changes?: readonly RefreshChangeInput[];
+    /** Stable failed operation ids. The controller reports these and never retries processor work. */
+    readonly failures?: readonly string[];
+}
+/** Stable refusal codes for external document replacement. @public */
+type RefreshFailureCode = 'unavailable' | 'collaboration' | 'busy' | 'cancelled' | 'superseded' | 'document-changed' | 'local-edits' | 'out-of-order' | 'invalid-result' | 'invalid-document' | 'input-failed' | 'load-failed' | 'recovery-failed';
+/** Completion belongs to one result, including refusals and recovery failures. @public */
+type RefreshResult = {
+    readonly ok: true;
+    readonly resultId: string;
+    readonly changes: readonly RefreshChange[];
+    readonly changeInformation: 'available' | 'unavailable';
+    readonly failures: readonly string[];
+} | {
+    readonly ok: false;
+    readonly resultId: string;
+    readonly code: RefreshFailureCode;
+    readonly recovered?: boolean;
+};
+/** Observable controller state. Document editing stays available during processing. @public */
+interface DocumentRefreshState {
+    readonly phase: 'idle' | 'capturing' | 'processing' | 'refreshing' | 'recovering' | 'complete' | 'failed';
+    readonly result: RefreshResult | null;
+    readonly changes: readonly RefreshChange[];
+    /** Whether highlights are requested for available locations. False when the whole set starts dismissal. */
+    readonly highlightsVisible: boolean;
+    /** Offer restore and download controls when true. */
+    readonly recoveryAvailable: boolean;
+}
+/** Opacity fade settings. Reduced motion caps fades at 125ms. @public */
+type RefreshHighlightAnimation = AnchorHighlightAnimation;
+/** Presentation for temporary paragraph highlights. Each call starts from these defaults. @public */
+interface RefreshHighlightOptions extends AnchorHighlightOptions {
+    /** Include earlier changes from the latest cumulative result. Default: false. */
+    readonly includePrevious?: boolean;
+    /** Select these change IDs instead of the recent/all filter. Unknown or unavailable IDs are skipped. Empty means none. */
+    readonly changeIds?: readonly string[];
+}
+/** Explicit highlight dismissal. Document edits always remove stale highlights immediately. @public */
+type ClearRefreshHighlightsOptions = ClearAnchorHighlightOptions;
+/** Explicit change navigation. Does not change the default scroll preservation during refresh. @public */
+interface NavigateToChangeOptions extends ScrollToAnchorOptions {
+    /** Move the caret and focus to the changed range start. Default: false. */
+    readonly focus?: boolean;
+    /** Target alignment. Default: center. centerIfNeeded preserves scroll for an already visible target. */
+    readonly block?: ScrollPlacement;
+}
+/** External file transport stays in your application. Reload resets selection and undo history. @public */
+interface DocumentRefresh {
+    /** Finish pending input and capture bytes with their document revision. Supersedes earlier submissions. */
+    capture(): Promise<RefreshSubmission>;
+    /** Accept cumulative output. Preserve a clamped scroll position without moving focus. */
+    applyUpdate(update: RefreshUpdate): Promise<RefreshResult>;
+    /** Cancel pending processing. An accepted result stays loaded. */
+    cancel(): void;
+    /** End processing when no further output will arrive. */
+    finish(submission: RefreshSubmission): void;
+    /** Cached state, suitable for framework external-store subscriptions. */
+    snapshot(): DocumentRefreshState;
+    /** Observe state changes. Returns an unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Completion notification for every `applyUpdate()` call, including a refused result. */
+    onResult(listener: (result: RefreshResult) => void): () => void;
+    /** Highlight available changes and return their count, including offscreen locations. Zero means none. Always validates options. */
+    highlightChanges(options?: RefreshHighlightOptions): number;
+    /** Remove temporary paragraph highlights without changing document content or history. */
+    clearHighlights(options?: ClearRefreshHighlightsOptions): void;
+    /** Explicit navigation. Does not focus unless requested. Returns false for unavailable locations. */
+    navigateToChange(id: string, options?: NavigateToChangeOptions): boolean;
+    /** Return a copy for download after recovery fails. */
+    recoveryBytes(): ArrayBuffer | null;
+    /** Retry recovery only while the failed document session is still active. */
+    recover(): Promise<boolean>;
+}
+/** A capture failure with a stable code. `applyUpdate()` failures use RefreshResult instead. @public */
+declare class DocumentRefreshError extends Error {
+    /** Machine-readable reason. */
+    readonly code: RefreshFailureCode;
+    constructor(code: RefreshFailureCode, cause?: unknown);
+}
+
+/**
+ * Get the engine-owned controller for updated DOCX files. React and Vue use the same controller.
+ * Transport and processor jobs belong to your application. This is a host API, not an Office.js document member.
+ * @public
+ */
+declare function createDocumentRefresh(editor: DocxEditorInstance): DocumentRefresh;
+
+/**
+ * Ranges for `watchHighlights` and `useHighlights`: an array, or a function of the editor
+ * that runs again after document changes. @public
+ */
+type HighlightSource = readonly HighlightRange[] | ((editor: Editor) => readonly HighlightRange[]);
+/** Milliseconds a function source waits after an edit before it runs again. @public */
+declare const HIGHLIGHT_REFRESH_MS = 150;
+/** Options for {@link watchHighlights}. @public */
+interface WatchHighlightsOptions extends HighlightOptions {
+    /** Called when the applied and unavailable counts change. */
+    readonly onResult?: (result: HighlightResult) => void;
+}
+/** A highlight set that {@link watchHighlights} keeps current. @public */
+interface HighlightWatch {
+    /** What the last application resolved. */
+    readonly result: HighlightResult;
+    /** Run the source again now. */
+    refresh(): void;
+    /** Replace the source or options. Applies at once and keeps the set's stacking position. */
+    update(source: HighlightSource, options?: HighlightOptions): void;
+    /** Remove the set and stop watching. */
+    stop(): void;
+}
+/**
+ * Highlight a named set and keep it current as the document changes.
+ *
+ * @example
+ * ```ts
+ * const glossary = watchHighlights(editor, 'glossary', (editor) =>
+ *   editor.findMatches(terms, { wholeWord: true }).flat()
+ * );
+ * // Later:
+ * glossary.stop();
+ * ```
+ * @public
+ */
+declare function watchHighlights(editor: Editor, name: string, source: HighlightSource, options?: WatchHighlightsOptions): HighlightWatch;
+
+/** Milliseconds of quiet before a typed query runs. @public */
+declare const SEARCH_DEBOUNCE_MS = 150;
+/** Most matches one search reports; a full result reads as "at least this many". @public */
+declare const SEARCH_MATCH_LIMIT = 2000;
+/** The highlight set name the search session owns. @public */
+declare const SEARCH_HIGHLIGHT_SET = "search";
+/** Stacking priority of search highlights, above host sets at the default `0`. @public */
+declare const SEARCH_HIGHLIGHT_PRIORITY = 10;
+/** Which matches a search interface highlights. @public */
+type DocumentSearchHighlight = 'all' | 'active' | 'none';
+/** Search options that narrow a query. @public */
+interface DocumentSearchOptions {
+    readonly matchCase?: boolean;
+    readonly wholeWord?: boolean;
+}
+/** How a search moves to a match. @public */
+interface DocumentSearchNavigateOptions {
+    /** Move focus to the document. Default: `false`. */
+    readonly focus?: boolean;
+}
+/** Options for {@link DocumentSearch.find}. @public */
+interface DocumentSearchFindOptions extends DocumentSearchOptions {
+    /**
+     * Highlight the results until `clear()` or the next `find()`: `'all'`, `'active'`, or
+     * `'none'`. Default: no request of its own, so highlights follow the Find pane and hooks.
+     */
+    readonly highlight?: DocumentSearchHighlight;
+    /** Select the first match and scroll to it. Default: `false`. */
+    readonly selectFirst?: boolean;
+}
+/** A snapshot of the shared search. The same object until something changes. @public */
+interface DocumentSearchState {
+    /** The query as typed. It can lead the searched query by one debounce. */
+    readonly query: string;
+    readonly matchCase: boolean;
+    readonly wholeWord: boolean;
+    /** Matches for the last searched query, in document order. */
+    readonly matches: readonly TextMatch[];
+    /** The search stopped at {@link SEARCH_MATCH_LIMIT} with matches still ahead. */
+    readonly truncated: boolean;
+    /** Index of the current match, or `-1` before any navigation. */
+    readonly activeIndex: number;
+    /** The current match, or `null` before any navigation. */
+    readonly activeMatch: TextMatch | null;
+    /** A typed query is waiting for its debounce. */
+    readonly isPending: boolean;
+}
+/**
+ * The shared search of one editor. Get it with {@link createDocumentSearch}.
+ * @public
+ */
+interface DocumentSearch {
+    /** The current state. Returns the same object until the state changes. */
+    getState(): DocumentSearchState;
+    /** Observe state changes. Returns an unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Search now, without a debounce, and return the matches. Clears the active match unless
+     * `selectFirst` selects one. `highlight` highlights the results until `clear()`.
+     */
+    find(query: string, options?: DocumentSearchFindOptions): readonly TextMatch[];
+    /** Update the typed query. The search runs after {@link SEARCH_DEBOUNCE_MS} of quiet. */
+    setQuery(query: string): void;
+    setMatchCase(value: boolean): void;
+    setWholeWord(value: boolean): void;
+    /**
+     * Select a match and scroll to it. Focus stays where it is, so a search box keeps it and
+     * Enter can move to the next match; pass `{ focus: true }` to move focus to the document.
+     * Returns false for an index without a match.
+     */
+    goTo(index: number, options?: DocumentSearchNavigateOptions): boolean;
+    /** Go to the next or previous match, wrapping at the ends. */
+    next(options?: DocumentSearchNavigateOptions): boolean;
+    previous(options?: DocumentSearchNavigateOptions): boolean;
+    /** Empty the query and drop the results, without changing the selection. */
+    clear(): void;
+    /**
+     * Highlight matches while the returned function is not called. With several requests,
+     * the widest wins: `'all'`, then `'active'`. Without a request, nothing is highlighted.
+     * The Find pane requests highlights while its Find tab is open.
+     */
+    showHighlights(mode: DocumentSearchHighlight): () => void;
+}
+/**
+ * The shared search session of an editor. Every call for the same editor returns the same
+ * session, so the Find pane and your code read and drive one search.
+ *
+ * @example
+ * ```ts
+ * const search = createDocumentSearch(editor);
+ * const stop = search.showHighlights('all');
+ * search.find('Supplier', { wholeWord: true });
+ * search.next();
+ * ```
+ * @public
+ */
+declare function createDocumentSearch(editor: Editor): DocumentSearch;
+
+export { AUTO_ZOOM_MODE, AnchorHighlightAnimation, AnchorHighlightOptions, BROWSER_AUTOMATION_CAPABILITIES, CONTENT_CONTROL_PICTURE_ACCEPT, ClearAnchorHighlightOptions, DRAWING_REL_FROM_H, DRAWING_REL_FROM_V, DocumentRefreshError, DocxEditorInstance, DrawingPositionInput, FIT_WIDTH_ZOOM_MODE, HIGHLIGHT_REFRESH_MS, HighlightOptions, HighlightRange, HighlightResult, LOADING_SNAPSHOT, NO_MIXED_FIELDS, OpenPaginatedResult, PX_PER_CM, PX_PER_INCH, PaginatedSurface, PaginatedSurfaceOptions, ParagraphTabStop, REVIEW_MARKERS_GUTTER_PX, ReviewPaneOverflow, SEARCH_DEBOUNCE_MS, SEARCH_HIGHLIGHT_PRIORITY, SEARCH_HIGHLIGHT_SET, SEARCH_MATCH_LIMIT, SNAP_TWIPS_CM, SNAP_TWIPS_INCH, ScrollPlacement, ScrollToAnchorOptions, TAB_ALIGNMENT_LABELS, TOOLBAR_COLLAPSE_ORDER, TOOLBAR_OVERFLOW_HYSTERESIS, TOOLBAR_PANEL_EDGE_MARGIN, TOOLBAR_PINNED_GROUPS, TWIPS_PER_CM, TWIPS_PER_INCH, TreeDocxSessionView, ZOOM_MAX, ZOOM_MIN, alignmentAfterDirectionChange, applyThemeShade, applyThemeTint, arrangeToolbarGroups, barRoomWidth, calendarDateForKey, calendarDateFromText, calendarDateText, calendarMonth, calendarMonthNames, calendarMonthTitle, calendarWeekdays, changedFields, chordLetter, clipboardDropLandsText, clipboardPasteLandsContent, collapseOrder, collapsibleGroupCost, contentControlPopupKeyDown, contentControlPopupOpener, controlsOverflow, createBrowserAutomationHost, createContentControlListNavigation, createDocumentRefresh, createDocumentSearch, createLayoutShaping, dragIndent, editorCommandKey, editorInstanceScope, firstDayOfWeek, formatInches, generateRulerTicks, handlePosition, hasOpenNestedPopup, inchesToTwips, isoDateOf, listenForPopupEscape, listenForPopupFocusLeave, lowerColorValueForBorder, lowerColorValueForFill, mixedFieldsOf, mountPaginatedSurface, observeContentControlPopup, parseIsoDate, partOfNodeId, positionContentControlPopup, positionInputFromPropertiesCommand, propertiesCommandHasPositionFields, readAvailableWidth, readColumnGap, readInlineMargins, resolveColorValueToCss, resolveThemeColorHex, resolveZoomMode, reviewPaneEntitledZoom, rulerPageBox, sameOverflow, sameTabStops, sameZoomMode, seedFields, separatorLeadingCost, shiftMonth, signedFirstLineOf, snapTwips, specialOf, surfaceExtent, tableCommandState, toEditorFontError, toolbarGroupPriority, toolbarOverflowGroups, toolbarPanelPlacement, toolbarPopupLeft, trailingGapCost, trapTabWithin, twipsToInches, validateDrawingPositionInput, validateSetImagePositionCommand, validateThemeModifier, watchHighlights, withTabStop };
+export type { BarRoomInput, CalendarDay, CalendarMonth, CalendarMonthOptions, ClearRefreshHighlightsOptions, ColorLowerResult, ContentControlListNavigation, DocumentRefresh, DocumentRefreshState, DocumentSearch, DocumentSearchFindOptions, DocumentSearchHighlight, DocumentSearchNavigateOptions, DocumentSearchOptions, DocumentSearchState, HighlightSource, HighlightWatch, NavigateToChangeOptions, ParagraphDialogFields, ParagraphDialogMixed, ParagraphFlagKey, ParagraphFlagState, ParagraphFormatRead, ParagraphFormatUpdate, PopupEscapeOptions, PopupFocusLeaveOptions, RefreshChange, RefreshChangeInput, RefreshFailureCode, RefreshHighlightAnimation, RefreshHighlightOptions, RefreshLocation, RefreshResult, RefreshSubmission, RefreshUpdate, RulerDragOptions, RulerIndent, RulerIndentHandle, RulerPageMetrics, RulerTick, RulerUnit, SpecialIndent, SurfaceExtent, TabAlignment, TabLeaderName, ToolbarFitInput, ToolbarHostGroupPlacement, ToolbarPanelPlacement, WatchHighlightsOptions };