@docx-editor.dev/pro/vue

Vue review rail — preset layout with [useReview](useReview) data wiring.

Compound part overrides (List, Card, Accept, …) match the React export names and mount when passed as slots; the preset arrangement is the default when no slot overrides are supplied. Full asChild merge semantics follow the React ladder and are typed on each part export for hosts that replace individual pieces.

Functions (17)

activatedCustomNodeOffunctionSource ↗

Resolves the host-facing custom-node activation payload.

declare function activatedCustomNodeOf(resolved: ResolvedCustomNodeActivation, editor: Editor | null | undefined): ActivatedCustomNode | null;

collaborationModulefunctionSource ↗

Build the collaboration module. Construction never validates the key and never touches the network.

declare function collaborationModule(options: CollaborationModuleOptions): EditorModule;

resolveCustomNodeActivationfunctionSource ↗

Resolves a painted pointer target to a registered custom-node definition.

declare function resolveCustomNodeActivation(target: EventTarget | null, nodes: readonly AnyCustomNodeDefinition[]): ResolvedCustomNodeActivation | null;

reviewModulefunctionSource ↗

Build the review module. Construction never validates the key and never touches the network. It installs the drawing renderers process-wide, so charts, SmartArt layout, drawing effects, WordArt, and metafile pictures render without a separate drawingModule().

declare function reviewModule(options?: ReviewModuleOptions): EditorModule;

useCollaborationParticipantsfunctionSource ↗

Subscribe to the participant roster of the collaboration session.

Omit session and it reads the one the editor above holds. The ref keeps its array reference until the roster actually changes, so unrelated awareness traffic does not retrigger watchers. No session yields a stable empty array.

declare function useCollaborationParticipants(session?: MaybeRefOrGetter$1<CollaborationSession | null>): UseCollaborationParticipantsReturn;

useCollaborationSessionfunctionSource ↗

The live collaboration session of the editor above this component, or null.

The editor already holds the session a collaborationModule contributed, so presence chrome reads it from here instead of being handed it: every part and composable in this package takes session as an OPTIONAL prop and falls back to this. A host with one Root and one room never passes it at all.

Pass it explicitly when a component sits outside the Root that owns the room, or when one page renders two.

declare function useCollaborationSession(): UseCollaborationSessionReturn;

useCollaborationStatusfunctionSource ↗

Reactive status for the collaboration session, with live and diverged derived.

Omit session and it reads the one the editor above holds. Pass it explicitly for a session this Root does not own.

declare function useCollaborationStatus(session?: MaybeRefOrGetter$1<CollaborationSession | null>): UseCollaborationStatusReturn;

useCustomNodeDefinitionsfunctionSource ↗

Returns custom-node definitions from a prop or the mounted editor.

declare function useCustomNodeDefinitions(nodes?: MaybeRefOrGetter$1<readonly AnyCustomNodeDefinition[] | undefined>): ComputedRef<readonly AnyCustomNodeDefinition[]>;

useDocumentCollaborationfunctionSource ↗

Own a provider-agnostic collaboration session for a Vue host.

The consumer creates the ydoc, the awareness, and whatever provider replicates them (WebSocket, WebRTC, offline persistence); this composable owns only the document session over them, with the same remount-safe lifecycle as useWebrtcCollaboration. It imports no network provider.

declare function useDocumentCollaboration(options?: MaybeRefOrGetter$1<UseDocumentCollaborationOptions | null>): UseDocumentCollaborationReturn;

useReviewfunctionSource ↗

declare function useReview(query?: MaybeRefOrGetter<ReviewItemQuery | undefined>): UseReviewReturn;

useReviewAuthorfunctionSource ↗

Returns the resolved color, slot, and declared style for one review author.

The result updates when the author or revision style declarations change. Outside the review rail it reads the editor's author roster.

declare function useReviewAuthor(author: MaybeRefOrGetter$1<string | undefined>): ComputedRef<ReviewAuthorInfo | undefined>;

useReviewCardHeightsfunctionSource ↗

Measure your own review cards for useStackedReviewPositions.

Each card is observed in its own window, so a rail in a pop-out window works too. A height is recorded only when it changes, and a zero height (an element without layout) is never recorded. Observation stops with the calling component's scope.

Pass the full item list, not only the cards on screen, so the heights of deleted items are dropped and off-screen cards keep theirs. Without items, every height stays until the scope stops. In a window without ResizeObserver, each card is measured once, when it mounts.

declare function useReviewCardHeights(items?: MaybeRefOrGetter$1<readonly {
    readonly key: string;
}[]>): UseReviewCardHeightsReturn;
```ts
const { items } = useReview();
const { metrics } = useReviewRailMetrics();
const { heights, cardRef } = useReviewCardHeights(items);
const positions = useStackedReviewPositions(items, heights, () => ({
  scale: metrics.value.scale,
}));
```

useReviewItemfunctionSource ↗

declare function useReviewItem(): ComputedRef<ReviewItemView | null>;

useReviewOffunctionSource ↗

declare function useReviewOf(editorRef: Ref<Editor | null>, query?: MaybeRefOrGetter<ReviewItemQuery | undefined>): UseReviewReturn;

useReviewRailMetricsfunctionSource ↗

The review column's geometry in CSS pixels: what converts review anchors and stacked positions, which are layout points from the top of the first page, into a card's top.

Call it without arguments inside DocxEditorReview, for example in a component placed in <DocxEditorReview :preset="false">, to read the packaged rail's own measurement. Those children render inside the rail element, which already sits at left.

Pass railRef, a template ref or a getter, to measure your own column instead. Give the element position: absolute and render it directly inside DocxEditor.Viewport with no positioned element in between: its offset parent must be the scroll container that holds the pages. Development builds warn once when it is not. The column reserves the review gutter unless reserveGutter is false.

While useReview().paneOpen is false the viewport reserves only a marker strip, so render no cards then. compact is true when the pane is open but too narrow for a column.

The value updates when the zoom, the window size, the page count, the document load, content above the pages, or the reserved review gutter changes. It works in a pop-out window or an iframe, because it observes the element's own window.

declare function useReviewRailMetrics(railRef?: MaybeRefOrGetter$1<HTMLElement | null> | null, options?: MaybeRefOrGetter$1<UseReviewRailMetricsOptions | undefined>): UseReviewRailMetricsReturn;
Position custom cards 


```vue
<script setup lang="ts">
import { ref } from 'vue';
import {
  useReview,
  useReviewRailMetrics,
  useStackedReviewPositions,
} from '@docx-editor.dev/pro/vue';

const props = defineProps<{ heights: ReadonlyMap<string, number> }>();
const railRef = ref<HTMLElement | null>(null);
const { metrics } = useReviewRailMetrics(railRef);
const { items } = useReview();
const positions = useStackedReviewPositions(items, () => props.heights, () => ({
  scale: metrics.value.scale,
}));
const topOf = (key: string) =>
  metrics.value.top + (positions.value.get(key) ?? 0) * metrics.value.scale;
</script>

<template>
  <div
    ref="railRef"
    :style="{
      position: 'absolute',
      top: '0px',
      left: `${metrics.left ?? 0}px`,
      width: '300px',
      visibility: metrics.left === null ? 'hidden' : 'visible',
    }"
  >
    <MyCard
      v-for="item in items"
      :key="item.key"
      :item="item"
      :style="{ position: 'absolute', top: `${topOf(item.key)}px` }"
    />
  </div>
</template>
```

useReviewRefusalMessagefunctionSource ↗

The packaged sentence for a refused review write, in the reader's language, for a host's own card or balloon. It honors the review pane's t overrides, as the packaged cards do. Call it in setup.

declare function useReviewRefusalMessage(): UseReviewRefusalMessageReturn;
```ts
const { lastRefusal } = useReview();
const refusalMessage = useReviewRefusalMessage();
const notice = computed(() => (lastRefusal.value ? refusalMessage(lastRefusal.value) : ''));
```

useStackedReviewPositionsfunctionSource ↗

Non-overlapping Y positions for cards you have measured. Measure them with [useReviewCardHeights](useReviewCardHeights).

Pass entries in document order, each with a key and an anchor, and the measured card heights. An entry with isActive: true stays at its own anchor, and the entries before it move up. Anchors are in layout points. Measured heights are in CSS pixels, so pass scale to add them.

Returns each card's top in layout points. useReviewRailMetrics supplies scale and the pixel offset of the first page: a card's CSS top is metrics.top + position * metrics.scale.

declare function useStackedReviewPositions(items: MaybeRefOrGetter<readonly {
    readonly key: string;
    readonly anchorY: number | null;
    readonly isActive?: boolean;
}[]>, heights: MaybeRefOrGetter<ReadonlyMap<string, number>>, options?: MaybeRefOrGetter<{
    readonly gap?: number;
    readonly scale?: number;
    readonly defaultHeight?: number;
}>): ComputedRef<ReadonlyMap<string, number>>;

Interfaces (47)

CollaborationAvatarPropsinterfaceSource ↗

Props for [DocxEditorCollaboration](DocxEditorCollaboration).Avatar.

interface CollaborationAvatarProps
MemberTypeSummary
children?VNode | VNode[]Default slot: replaces the initials inside the disc; the accent background stays.
className?stringClasses added to the part's root element.
participantCollaborationParticipantThe participant to show.

CollaborationAvatarRenderPropsinterfaceSource ↗

Render props for [DocxEditorCollaboration](DocxEditorCollaboration).Avatars' per-participant override.

interface CollaborationAvatarRenderProps
MemberTypeSummary
avatarUrl?stringThe image declared for this participant with `DocxEditorAuthorStyle`, or `undefined`.
colorstringThe resolved accent — published colour, or the review roster's colour for the name.
initialsstringThe first letter of up to two name words, uppercased.
participantCollaborationParticipantThe participant this avatar shows.

CollaborationAvatarsPropsinterfaceSource ↗

Props for [DocxEditorCollaboration](DocxEditorCollaboration).Avatars.

interface CollaborationAvatarsProps
MemberTypeSummary
children?(props: CollaborationAvatarRenderProps) => VNode | VNode[]Scoped slot: `#default="{ participant, color, initials, avatarUrl }"` replaces the disc.
className?stringClasses added to the part's root element.
max?numberAvatars shown before the rest collapse into one "+N" chip. Omit to show everyone.
session?CollaborationSession | nullThe session whose participants the stack shows. Omit it and the part uses the one the editor above holds; `null` renders nothing.

CollaborationCaretLabelRenderPropsinterfaceSource ↗

What a custom remote-caret label renders with.

The renderer mounts inside the adapter's provider tree, so every composable works in it — useDocxEditor, useEditorState, the review composables. It has the opened document, not only the collaborator.

interface CollaborationCaretLabelRenderProps
MemberTypeSummary
avatarUrl?stringThe image declared for this collaborator with `DocxEditorAuthorStyle`, or `undefined`.
colorstringThe resolved accent: the published colour when the engine can paint it, otherwise the review roster's colour for the name — the same resolution the painted label uses.
participantCollaborationParticipant | nullThe session roster entry for the selection's actor, or null while presence catches up.
selectionCollaborationRemoteSelectionThe remote selection this label marks, resolved into this replica's addresses.

CollaborationCaretLabelsPropsinterfaceSource ↗

Props for [DocxEditorCollaboration](DocxEditorCollaboration).CaretLabels.

The rendered content lands in the engine's label layer, which is furniture: the layer is aria-hidden and takes no pointer events. Assistive technology does not read a label, and nothing inside one is clickable or focusable. Keep interactive or announced presence UI in your own chrome, such as the avatar stack.

interface CollaborationCaretLabelsProps
MemberTypeSummary
children?(props: CollaborationCaretLabelRenderProps) => VNode | VNode[]Scoped slot: `#default="{ selection, participant, color }"`. Without it the label shows the collaborator's name, matching the engine default.
session?CollaborationSession | nullThe session whose collaborators label the carets. Omit it and the part uses the one the editor above holds; `null` renders nothing.

CollaborationFailureinterface

One collaboration failure: a typed code plus optional free-form detail.

interface CollaborationFailure
MemberTypeSummary
codeCollaborationFailureCodeStable code for application logic.
detail?stringBounded diagnostic text for logs. Not a parsing contract.

CollaborationIdentityinterface

Human or automation identity attached to authored collaboration transactions.

interface CollaborationIdentity
MemberTypeSummary
actorIdstringStable author id, 1 to 256 characters after trimming. Recorded on authored changes.
color?stringPresence color, at most 64 characters. An unsafe CSS color falls back to the accent.
namestringDisplay name, 1 to 256 characters after trimming.
role?'human' | 'agent'`agent` for automation. Defaults to `human`.

CollaborationIdentityUpdateinterfaceSource ↗

Display-identity fields a live session can update.

actorId and role are attribution and stay immutable for the session lifetime, so this type cannot name them.

interface CollaborationIdentityUpdate
MemberTypeSummary
color?stringNew presence color, at most 64 characters.
name?stringNew display name, 1 to 256 characters after trimming.

CollaborationModuleOptionsinterfaceSource ↗

How [collaborationModule](collaborationModule) is configured. The session is required; the licence key is optional and never validated.

interface CollaborationModuleOptions extends ProLicenseOptions
MemberTypeSummary
sessionEditorCollaborationSessionThe session from a collaboration factory. The editor attaches its document port to it.

CollaborationParticipantinterface

One validated identity visible through ephemeral collaboration presence.

interface CollaborationParticipant extends CollaborationIdentity
MemberTypeSummary
isLocalbooleanTrue for this replica's own participant.

CollaborationRemoteSelectioninterface

Stable remote selection resolved into this replica's canonical paragraph addresses.

Anchor and head may name different paragraphs. A collapsed caret is the same address twice.

interface CollaborationRemoteSelection
MemberTypeSummary
actorIdstringThe participant's `actorId`.
anchorCollaborationRemoteSelectionAddressWhere the selection starts.
color?stringThe participant's presence color, when it published a safe one.
headCollaborationRemoteSelectionAddressWhere the selection ends: the remote caret.
kind?CollaborationSelectionKind`cells` for a table cell rectangle; absent for a character range.
namestringThe participant's display name.

CollaborationRemoteSelectionAddressinterface

One endpoint of a remote selection resolved into this replica's canonical addresses.

paragraphId is the stable w14:paraId. nodeId is replica-local and is used to paint.

interface CollaborationRemoteSelectionAddress
MemberTypeSummary
nodeIdstringThe paragraph's node id in this replica's editor tree.
offsetnumberA UTF-16 offset in the paragraph's text.
paragraphIdstringThe stable `w14:paraId` of the paragraph.

CollaborationRootSourceinterfaceSource ↗

What this component needs from a room, which every collaboration composable already returns.

Structural on purpose: useHocuspocusCollaboration, useWebrtcCollaboration and useDocumentCollaboration all satisfy it, and so does a host that owns its own resources.

interface CollaborationRootSource
MemberTypeSummary
documentUint8Array | nullThe document bytes to mount, or null while none is ready.
modulesreadonly EditorModule[]The editor modules to register, the collaboration module among them.
sessionCollaborationSession | nullThe collaboration session, or null while none is connected.

CollaborationSessioninterfaceSource ↗

Host-facing collaboration session.

A host reads identity, status, presence, and undo. The editor attaches [EditorCollaborationSession](EditorCollaborationSession) internally and never through this type.

interface CollaborationSession
MemberTypeSummary
canRedoWhether the shared undo history holds a local step to redo.
canUndoWhether the shared undo history holds a local step to undo.
documentIdstringThe room's document id.
identityCollaborationIdentityThe validated local identity.
offlineEditing?booleanWhether edits continue while the transport is down (`disconnected`). Set by the `offlineEditing` option; absent means true.
participantsParticipants in presence, this replica included. Capped at 256.
redoRedo this participant's last undone step. Returns false when refused.
remoteSelectionsOther participants' selections, resolved into this replica's addresses.
sessionIdstringUnique identity for this attachment lifetime.
setIdentityUpdate the display name and color mid-session, when the replica supports it.
statusCurrent lifecycle state.
statusSnapshotCached status, current reason, and last failure.
subscribeParticipantsCall `listener` when the participant list changes. Returns the unsubscribe function.
subscribeRemoteSelectionsCall `listener` when a remote selection changes. Returns the unsubscribe function.
subscribeStatusCall `listener` on each status or reason change. Returns the unsubscribe function.
undoUndo this participant's last step; others' edits stay. Returns false when refused.

CollaborationStatusNoticePropsinterfaceSource ↗

Props for [DocxEditorCollaboration](DocxEditorCollaboration).Status. The default slot, #default="{ kind, message, rejoin }", replaces the packaged notice.

interface CollaborationStatusNoticeProps
MemberTypeSummary
className?stringClasses added to the notice region.
onRejoin?() => voidThe `rejoin` event: the part's "Rejoin" button when this copy is out of sync, or when edits have waited too long for the room. Listen with `@rejoin`, save the editor, and pass the bytes to your provider composable's `rejoin`. Without a listener the part shows the message only.
session?CollaborationSession | nullThe session to report on. Omit it and the part uses the one the editor above holds; `null` renders nothing.

CollaborationStatusNoticeRenderPropsinterfaceSource ↗

What the [DocxEditorCollaboration](DocxEditorCollaboration).Status default slot renders with.

interface CollaborationStatusNoticeRenderProps
MemberTypeSummary
kindCollaborationNoticeKindWhich notice to show.
messagestringThe packaged message for `kind`, in the editor's language.
rejoin?() => voidEmits `rejoin`; present for `outOfSync` and `stalled` when the part has a listener.

CollaborationStatusSnapshotinterface

Cached status read. Same reference until one of its fields changes.

interface CollaborationStatusSnapshot
MemberTypeSummary
failureCount?numberHow many failures this session has recorded. It changes with each new failure, also when its code and detail repeat the last one, as a refused edit refused again does. Absent from a session that does not count.
lastFailureCollaborationFailure | undefinedThe most recent `error` reason. Kept after the replica recovers.
reasonCollaborationFailure | undefinedWhy the replica holds `status`, or `undefined` when nothing is wrong.
recovering?booleanThe session is in `error` but heals by itself: it realigns on the next clean update and returns to its previous status. A host shows a passing notice, not a rejoin action. Absent means false.
statusCollaborationStatusCurrent lifecycle state.
waiting?booleanEdits wait: the room sent an update that depends on one still on its way, and an edit made now could touch the text it changes. The editor refuses edits meanwhile, with `collaboration-session-not-ready`, and accepts them again when the update arrives or the wait times out. Absent means false.

CreateDocumentCollaborationOptionsinterfaceSource ↗

Options for one full-document collaboration replica.

The caller owns ydoc.

interface CreateDocumentCollaborationOptions
MemberTypeSummary
awarenessAwarenessPresence channel for participants and remote selections, from `y-protocols/awareness`.
bootstrapCollaborationBootstrapWhether to seed the room, join it, or let the peers decide.
documentIdstringThe room's document id, 1 to 256 characters. A room seeded with another id refuses.
identityCollaborationIdentityThe local participant. Recorded as the author of this replica's changes.
offlineEditing?booleanAdmit local edits while the transport is `disconnected`.
sessionId?stringUnique attachment identity. Omit it to generate a new identity for this session.
ydocY.DocThe room's Yjs document. Connect its provider before a `join` bootstrap.

CustomNodeChromePropsinterfaceSource ↗

Props for custom-node chip colors and pointer activation.

interface CustomNodeChromeProps
MemberTypeSummary
nodes?readonly CustomNodeDefinition[]Definitions to style. Defaults to definitions registered on the editor.
onNodeClick?(node: ActivatedCustomNode) => voidReceives primary-button activation after the definition's own hook.
onNodeHover?(node: ActivatedCustomNode) => voidReceives pointer-entry activation after the definition's own hook.

CustomNodeContextMenuPropsinterfaceSource ↗

Props for the custom-node context-menu section.

interface CustomNodeContextMenuProps
MemberTypeSummary
nodes?readonly CustomNodeDefinition[]Definitions to offer. Defaults to definitions registered on the editor.
onEditNode?(node: ActivatedCustomNode, definition: CustomNodeDefinition) => voidRuns after the definition's own edit hook.
onRemoveRefused?(node: ActivatedCustomNode, reason: string) => voidReceives the engine reason when removal is refused.
remove?booleanAdds the remove row. Defaults to `true`.

DocxEditorCollaborationRootPropsinterfaceSource ↗

Props for [DocxEditorCollaborationRoot](DocxEditorCollaborationRoot).

Everything DocxEditorRoot takes except the three this component owns, which arrive as fallthrough attributes.

interface DocxEditorCollaborationRootProps
MemberTypeSummary
collaborationCollaborationRootSourceThe room, straight from a collaboration composable.
fallback?VNode | VNode[]Rendered before the room has a document — while connecting, or after a failure.

ProLicenseOptionsinterfaceSource ↗

Accepted by every pro entry point.

interface ProLicenseOptions
MemberTypeSummary
licenseKey?stringYour license key from docx-editor.dev. Optional in v1: unlicensed use in development and evaluation is permitted, production use requires a license (see LICENSE.md) — the package trusts you either way.

ResolvedCustomNodeActivationinterfaceSource ↗

A custom-node definition and decoded node under a pointer target.

interface ResolvedCustomNodeActivation
MemberTypeSummary
controlIdstring | null
definitionAnyCustomNodeDefinition
nodeActivatedCustomNode

ResolvedReviewPaneinterface

The review pane settings in force, with every field resolved.

interface ResolvedReviewPane
MemberTypeSummary
commentMarkersCommentMarkerStyleHow a collapsed comment marker looks.
openingReviewPaneOpeningWhen the pane opens by itself.
overflowReviewPaneOverflowWhat the open pane does when its card column does not fit beside the page.
revisionsInRevisionDisplayWhere tracked changes open.

ReviewActionPropsinterfaceSource ↗

interface ReviewActionProps extends ReviewPartProps
MemberTypeSummary
icon?VNode | string

ReviewActivationOptionsinterface

How activating a review item places it in the viewport, and whether it announces the reveal.

interface ReviewActivationOptions
MemberTypeSummary
announce?booleanWhether a successful activation fires the `reviewItemReveal` event. Default `false`.
reveal?ScrollPlacement | falseWhere the item lands, or `false` to open it without scrolling at all.

ReviewAdoptOptionsinterfaceSource ↗

Who and when an adopted change records.

interface ReviewAdoptOptions
MemberTypeSummary
author?stringThe author to record. Defaults to the editor's `author`, the person reviewing.
date?DateThe date to record. Omit it to keep each change's own date.

ReviewBalloonPropsinterfaceSource ↗

Props for DocxEditorReview.Balloon, the balloon that opens a review item at its text: each tracked change under revisionsIn: 'balloons', and format and structural changes in every mode.

interface ReviewBalloonProps
MemberTypeSummary
className?stringA class added to the balloon element.
hidden?booleanRemove the built-in balloon, for example to render your own. Format and structural change balloons go with it.

ReviewDraftPropsinterfaceSource ↗

Props of DocxEditorReview.Draft.

interface ReviewDraftProps extends ReviewPartProps
MemberTypeSummary
left?number | nullRail-local `left` for the compact rail. Omit it to use the compact card's position in the compact rail and the rail's own column otherwise. Null keeps the box in the rail's column.
top?numberRail-local `top` in CSS pixels. Omit it to use the packaged card stack's position. Pass your own when you render your own cards, so the box stacks with them.

ReviewItemRevealEventinterface

The payload of the reviewItemReveal event.

interface ReviewItemRevealEvent
MemberTypeSummary
keystringThe key of the review item to open, as `getReviewItems({ pairReplacements: false })` lists it, so for a replacement this is the key of its deletion or its insertion. Next Change and Previous Change stop once on a replacement and report its deletion's key, with the pair's key in [ReviewItemRevealEvent.pairKey](ReviewItemRevealEvent.pairKey). `setActiveReviewItem` reports the key it was given, so a call with a pair's key reports that key here and in [ReviewItemRevealEvent.pairKey](ReviewItemRevealEvent.pairKey).
pairKey?stringThe key that `getReviewItems()` gives the replacement this item belongs to, since it pairs replacements by default. Present only when the item is a paired replacement or one half of one. A host that reads the default list opens `pairKey ?? key`.
sourceReviewItemRevealSourceWhat asked for the item. `'navigate'` is Next Change or Previous Change, from the menu, the toolbar, a shortcut, or `exec({ type: 'navigateReviewChange' })`. `'host'` is a call to `setActiveReviewItem` (and so `useReview().setActive`) with `announce: true`.

ReviewMarkersPropsinterfaceSource ↗

interface ReviewMarkersProps extends ReviewPartProps
MemberTypeSummary
icon?VNode | ((item: ReviewItemView) => VNode | null | undefined)
offset?number
scale?number
window?{ top: number; bottom: number; } | null

ReviewModuleOptionsinterfaceSource ↗

How [reviewModule](reviewModule) is configured. Every field is optional, so reviewModule() with no argument is the ordinary call.

interface ReviewModuleOptions extends ProLicenseOptions
MemberTypeSummary
compareWorker?(() => Worker) | falseThe worker that runs the Compare documents dialog's compares off the page's main thread, so the page stays responsive, the dialog shows progress, and Cancel stops a running compare. By default, the editor starts the packaged worker, `@docx-editor.dev/pro/compare-worker`, one for each compare.
pane?ReviewPaneOptionsThe review pane settings the editor starts with. Change them later with `editor.setReviewPaneOptions()`, and read them from `snapshot.reviewPane`. Pass `{ opening: 'manual' }` when the host shows review items its own way, for example in balloons or margin markers, and opens the pane only on demand. An unknown field or value throws a `TypeError`.

ReviewPaneOptionsinterface

Review pane settings to change. Every field is optional, and an omitted field keeps its current value.

interface ReviewPaneOptions
MemberTypeSummary
commentMarkers?CommentMarkerStyleDefault `'icon'`.
opening?ReviewPaneOpeningDefault `'auto'`.
overflow?ReviewPaneOverflowDefault `'float'`.
revisionsIn?RevisionDisplayDefault `'pane'`.

ReviewPartPropsinterfaceSource ↗

interface ReviewPartProps
MemberTypeSummary
asChild?boolean
children?VNode | VNode[]
className?string
hidden?boolean

ReviewPropsinterfaceSource ↗

interface ReviewProps extends Omit<ReviewPartProps, 'children' | 'hidden'>
MemberTypeSummary
card?{ className?: string; }
children?VNode | VNode[]Scoped slot for custom card render: `#default="{ item }"`.
filter?(item: ReviewItemView) => boolean
formatting?boolean
furniture?VNode | VNode[]
gap?number
hidden?boolean
preset?boolean
stack?boolean
structural?boolean
t?(key: string, params?: Record<string, string | number>) => string

ReviewRailMetricsinterfaceSource ↗

Where a review column sits, in the coordinates of the editor's scroll container.

Review anchors (item.anchorY) and stacked positions (useStackedReviewPositions) are in layout points from the top of the first page. These values convert them to CSS pixels.

interface ReviewRailMetrics
Position a card at its stacked anchor 


```ts
const top = metrics.top + positions.get(item.key)! * metrics.scale;
```
MemberTypeSummary
compactbooleanThe review pane is open, but the viewport is too narrow for a full column beside the page. The packaged rail then shows markers and one floating card, the active item's, at `compactCardLeft`.
compactCardLeftnumber | nullThe `left` value, relative to [ReviewRailMetrics.left](ReviewRailMetrics.left), that puts a 300px card fully inside the visible area with a 12px inset from its edge on the column's side. Use it while [ReviewRailMetrics.compact](ReviewRailMetrics.compact) is true. `null` until there is a page to measure.
leftnumber | nullCSS pixels from the scroll container's left padding edge, in its scrolled content, to the column's left edge: one 16px gutter right of the page, or, in a right-to-left interface, one 16px gutter and the column's own width left of it. `null` until there is a page to measure. Keep the column hidden while it is `null`.
scalenumberCSS pixels per layout point, zoom included.
side'left' | 'right'The page side the column stands on: `'left'` in a right-to-left interface, otherwise `'right'`. On the left, give the column its width (300px for the packaged cards), because `left` keeps the column's RIGHT edge one gutter off the page; and keep each card's air on its left, away from the page.
topnumberCSS pixels from the scroll container's top padding edge, in its scrolled content, to the top of the first page. Content above the pages, such as a host banner inside the viewport, is included. Scrolling does not change it.

ReviewWriteRefusalinterfaceSource ↗

A review write the editor refused.

interface ReviewWriteRefusal
MemberTypeSummary
actionReviewWriteActionWhich write was refused. A discarded tracked change reports `'reject'`.
codeEditDiagnosticCode | ReviewDiagnosticCodeThe public diagnostic code, the same one `onDiagnostic` reports for the refusal. A tracked change the engine could not decide names its review code, such as `review.retained-structure` for a row that stays to keep a nested table.
finalbooleanTrue when retrying cannot help: the collaboration session ended, so the document must be opened again before it takes another review write.
keystring | nullThe card the write addressed, or null for a new comment on the selection.
sequencenumberRises with every refusal of this editor, so the same refusal twice still differs. Key a live announcement on it to announce a repeat.

UseCollaborationParticipantsReturninterfaceSource ↗

Reactive participant roster for Vue hosts.

interface UseCollaborationParticipantsReturn
MemberTypeSummary
participantsReadonly<Ref<readonly CollaborationParticipant[]>>Everyone in the room, this participant included, in a stable order.

UseCollaborationSessionReturninterfaceSource ↗

Values [useCollaborationSession](useCollaborationSession) returns.

interface UseCollaborationSessionReturn
MemberTypeSummary
sessionComputedRef<CollaborationSession | null>The live collaboration session of the editor above, or null.

UseCollaborationStatusReturninterfaceSource ↗

Reactive collaboration status for Vue hosts.

interface UseCollaborationStatusReturn
MemberTypeSummary
attachedReadonly<Ref<boolean>>An editor has attached its document port to this replica.
divergedComputedRef<boolean>This replica no longer agrees with the room, and waiting will not fix it.
failureCountReadonly<Ref<number>>How many failures the session has recorded. It changes with each new failure, also when `lastFailure` repeats the same code, so a host can tell a user each time an edit is refused.
lastFailureReadonly<Ref<CollaborationFailure | undefined>>The most recent `error` reason. Kept after the session recovers.
liveComputedRef<boolean>Edits made now reach the room.
reasonReadonly<Ref<CollaborationFailure | undefined>>Why the session holds `status`, or `undefined` when nothing is wrong.
recoveringReadonly<Ref<boolean>>The session is in `error` but heals by itself on the next clean update: show a passing notice, not a rejoin action.
statusReadonly<Ref<CollaborationStatus | 'inactive'>>Current lifecycle state, or `inactive` when no session is attached.
waitingReadonly<Ref<boolean>>Edits wait for the room: an update arrived that depends on one still on its way. The editor refuses edits until it arrives or the wait times out.

UseDocumentCollaborationOptionsinterfaceSource ↗

Input for [useDocumentCollaboration](useDocumentCollaboration).

interface UseDocumentCollaborationOptions
MemberTypeSummary
modules?readonly EditorModule[]Host modules. The composable adds `collaborationModule` when a room is ready. A host collaboration contribution is a configuration error and throws.
room?UseDocumentCollaborationConnectOptions | nullConnect this room when the composable starts. Omit it and call [UseDocumentCollaborationReturn.connect](UseDocumentCollaborationReturn.connect) after the host has a `ydoc` and a room. A different room, server, bootstrap kind, or `actorId` leaves the old room and connects the new one, and `null` leaves. A room opened with `connect` stays.

UseDocumentCollaborationReturninterfaceSource ↗

Values [useDocumentCollaboration](useDocumentCollaboration) returns.

interface UseDocumentCollaborationReturn
MemberTypeSummary
connect(options: UseDocumentCollaborationConnectOptions) => Promise<CollaborationFailure | null>Connect a room. RESOLVES with the failure, or null on success — it does not reject.
documentReadonly<Ref<Uint8Array | null>>The room's document as `.docx` bytes to mount. Null until the room is ready.
errorReadonly<Ref<CollaborationFailure | null>>The connect failure or session failure, or null. Check it before `document`.
leave(nextDocument: Uint8Array) => voidDestroy the session and carry on editing locally.
modulesReadonly<Ref<readonly EditorModule[]>>Modules to pass to the editor. They include the collaboration module once ready.
pendingReadonly<Ref<boolean>>True while a connect is in progress.
sessionReadonly<Ref<CollaborationSession | null>>The live session for status and presence. Null while no room is connected.

UseReviewCardHeightsReturninterfaceSource ↗

What [useReviewCardHeights](useReviewCardHeights) returns.

interface UseReviewCardHeightsReturn
MemberTypeSummary
cardRef(key: string) => (el: unknown) => voidThe function ref for a card, by item key. It returns the same function for a key while the card stays mounted. Use it as `:ref="cardRef(item.key)"` on an element, or on a component with one root element that does not change.
heightsReadonly<ShallowRef<ReadonlyMap<string, number>>>Measured card heights in CSS pixels, by item key. Pass it to `useStackedReviewPositions`. The map is replaced only when it changes. A key keeps its last height after its card unmounts, so a card that scrolls out of view and back does not move the cards around it. The height goes when its key leaves `items`.

UseReviewRailMetricsOptionsinterfaceSource ↗

Options for [useReviewRailMetrics](useReviewRailMetrics).

interface UseReviewRailMetricsOptions
MemberTypeSummary
reserveGutter?booleanWith a `railRef`, reserve the review gutter beside the page while the column element is mounted, as `DocxEditorReview` does. The viewport then shifts the page away from the column while the pane is open. The reservation does not show the comment controls in the toolbar and the context menu; see `ReviewRailContext` to serve them from your column. Set `false` when a mounted `DocxEditorReview` already reserves the gutter, or when your column overlays the page. Default: `true`.
trackScroll?booleanRe-measure while the scroll container scrolls. Only `compactCardLeft` changes with scrolling, and only when the page is wider than the viewport. Default: `false`.

UseReviewRailMetricsReturninterfaceSource ↗

The review column's geometry for Vue hosts.

interface UseReviewRailMetricsReturn
MemberTypeSummary
metricsReadonly<Ref<ReviewRailMetrics>>The current measurement. See `ReviewRailMetrics` for each value's meaning.

UseReviewRefusalMessageReturninterfaceSource ↗

The function [useReviewRefusalMessage](useReviewRefusalMessage) returns: the packaged sentence for a refusal.

interface UseReviewRefusalMessageReturn
MemberTypeSummary
(member-0)

UseReviewReturninterfaceSource ↗

interface UseReviewReturn
MemberTypeSummary
accept(item: ReviewItemView) => booleanAccept a revision. Reports whether it landed. For headless or server use, see `Revision.accept()` in `@docx-editor.dev/editor-api`.
activatedKeyComputedRef<string | null>The key of the ACTIVATED item: the one `setActive`, Next Change, or Previous Change made active, while the caret stays in it. `null` when only a caret move made an item active. `activeKey` is the caret-active item instead: the one the caret is in, however it got there. The key follows this hook's query, so a paired replacement reports the pair's key under `pairReplacements: true`. The same value as the editor's `getActivatedReviewItemKey(query)`, read on every selection change.
activeKeyComputedRef<string | null>The CARET-ACTIVE item: the one the caret is in, or null.
adopt(items: ReviewItemView | readonly ReviewItemView[], options?: ReviewAdoptOptions) => booleanAdopt tracked changes as the reviewer's own; they stay pending. Takes one item or a list, and ignores comment items. The default author is `DocxEditorConfig.author`. One undo step. Reports whether it landed: false when no revision was passed, when no author is known, or when the editor refuses the write.
comment(text: string, author?: string) => booleanComment on the current selection. Reports whether it landed, like `reply`. To comment on found text, select it first with `editor.findMatches` and `editor.selectMatch`. For headless or server use, see `Range.insertComment` in `@docx-editor.dev/editor-api`.
commentResolutionDisabledReasonComputedRef<string | null>
edit(item: ReviewItemView, text: string, expectedText?: string) => booleanEdit your own comment or reply. Pass its displayed text to reject stale edits.
itemsComputedRef<readonly ReviewItemView[]>
lastRefusalComputedRef<ReviewWriteRefusal | null>Why the last accept, reject, resolve, reopen, remove, reply or comment did not land, or null.
paneOpenComputedRef<boolean>
readyComputedRef<boolean>
reject(item: ReviewItemView) => booleanReject a revision. Reports whether it landed. For headless or server use, see `Revision.reject()` in `@docx-editor.dev/editor-api`.
remove(item: ReviewItemView) => boolean
reopen(item: ReviewItemView) => boolean
reply(item: ReviewItemView, text: string, author?: string) => booleanReply to a comment or a revision. The author is `DocxEditorConfig.author` unless you pass one. Reports whether the reply landed. For headless or server use, see `Comment.reply` in `@docx-editor.dev/editor-api`.
resolve(item: ReviewItemView) => boolean
selectionAnchorYComputedRef<number | null>Where a comment on the current selection would sit, in layout points, or null.
setActive(key: string | null, options?: ReviewActivationOptions) => booleanCard to document: puts the caret at the start of the item and scrolls to it. Reports whether it landed.
setPaneOpen(open: boolean) => void

Type aliases (17)

CollaborationBootstraptypeSource ↗

Create or join bootstrap for one collaboration replica.

The document and WebRTC factories share this union.

create-or-join removes the out-of-band decision about which peer creates a room. The replica probes for an initialized room and joins it when one appears. Otherwise it runs a short awareness election and only the winning candidate seeds from document. A room that two peers seeded concurrently reports the terminal failure code concurrent-seed on every replica.

type CollaborationBootstrap = {
    readonly kind: 'create';
    readonly document: Uint8Array;
} | {
    readonly kind: 'join';
    readonly timeoutMs?: number;
    readonly signal?: AbortSignal;
} | {
    readonly kind: 'create-or-join';
    readonly document: Uint8Array;
    readonly probeTimeoutMs?: number;
    readonly electionWindowMs?: number;
    readonly timeoutMs?: number;
    readonly signal?: AbortSignal;
};

CollaborationFailureCodetype

Why a replica refused work, left ready, or failed a schema check.

Free-form extras (a transport phrase, a blob key, a store refusal) travel in [CollaborationFailure.detail](CollaborationFailure.detail), not here. Branch on the code; log the detail.

Codes are grouped by cause, and each group comment names the host action. In error, only a remote update that is not applied yet, or one refused local edit, heals on its own. The failure codes table in the collaboration reference lists every code. transport-disconnected and authentication-failed need opposite answers: wait for the first; refresh the credential and rejoin for the second. room-generation-changed means the server compacted the room while this replica was away: save a copy if it holds unsent changes, then rejoin.

type CollaborationFailureCode = 
/** Edit refused by the session gate. The status does not change. Wait for `ready`. */
'collaboration-session-destroyed' | 'collaboration-session-not-attached' | 'collaboration-session-not-ready' | 'collaboration-text-limit' | 'experimental-collaboration-body-text-only'
/** Factory input rejected before joining. Fix the value the host passed. */
 | 'invalid-document-id' | 'invalid-identity' | 'invalid-identity-color' | 'invalid-session-id'
/** Join or seed did not complete. Connect the provider, check the room id, and retry. */
 | 'already-initialized' | 'document-id-mismatch' | 'initialization-aborted' | 'initialization-timeout' | 'not-initialized'
/** The seed document cannot seed a room. Fix the file. */
 | 'baseline-too-large' | 'blob-read' | 'invalid-baseline' | 'missing-local-blob' | 'no-main-document-part'
/** This client and the room have different formats. Terminal. Save local work. */
 | 'collaboration-format-mismatch' | 'protocol-version-mismatch' | 'schema-version-mismatch'
/** The room is unusable. Terminal. Create a new room from saved bytes. */
 | 'blob-digest-mismatch' | 'concurrent-seed' | 'port-already-attached'
/** A remote update is not applied yet. Heals when a later update arrives. Wait. */
 | 'duplicate-paragraph-id' | 'invalid-relationships' | 'materialize-dropped-content' | 'missing-blob' | 'missing-root' | 'remote-apply-failed' | 'unknown-paragraph-id'
/** Over a resource limit. A local edit realigns; shared state over a limit is terminal. */
 | 'blob-store-full' | 'blob-too-large' | 'invalid-blob-descriptor' | 'invalid-bound' | 'invalid-logical-id' | 'invalid-string' | 'prototype-key' | 'text-too-long' | 'too-many-attributes' | 'too-many-children' | 'too-many-nodes' | 'too-many-parts' | 'too-many-relationships' | 'tree-too-deep' | 'unknown-logical-id' | 'unsafe-part-name'
/** Transport state. Only `transport-disconnected` recovers on its own. */
 | 'authentication-failed' | 'room-generation-changed' | 'transport' | 'transport-disconnected'
/** Reserved for a room server that refuses a saved room. Passed through, never emitted. */
 | 'invalid-saved-room' | 'saved-room-unavailable'
/** @deprecated Emitted by nothing. Kept for compatibility; do not branch on these. */
 | 'baseline-digest-mismatch' | 'experimental-collaboration-existing-paragraphs-only' | 'experimental-collaboration-text-only' | 'experimental-collaboration-untracked-text-only' | 'immutable-baseline-changed' | 'immutable-metadata-changed' | 'invalid-shared-metadata' | 'local-mirror-failed' | 'paragraph-set-mismatch' | 'shared-schema-invalid' | 'unsupported-root-key';

CollaborationNoticeKindtypeSource ↗

The notice the status part shows, or none while everything is in order.

- connecting: the session is joining the room. - offline: the transport is down and edits continue; they sync on reconnect. - offlinePaused: the transport is down and the session refuses edits until reconnect (offlineEditing: false). - syncing: the session hit an update it could not apply yet and heals on the next one. - waiting: edits wait until an update the room sent can apply. - stalled: edits have waited longer than STALLED_AFTER_MS; rejoining loads the room. - editRefused: the room refused the last edit, and the editor undid it. - outOfSync: this copy no longer agrees with the room; rejoining loads the room's copy. - upgradeRequired: this client and the room use different collaboration formats, and either side can be the older one. A rejoin cannot fix it; an upgrade of the older side can. - newRoomRequired: the room itself cannot continue (two seeds merged, a damaged blob, or a resource limit); a rejoin cannot fix it. Save a copy and share it in a new room.

type CollaborationNoticeKind = 'connecting' | 'offline' | 'offlinePaused' | 'syncing' | 'waiting' | 'stalled' | 'editRefused' | 'outOfSync' | 'upgradeRequired' | 'newRoomRequired';

CollaborationSelectionKindtype

How a published selection covers the document.

Absent or omitted means a character range. cells means the table rectangle whose corner cells contain the two endpoints. The payload still carries only those endpoints, so a large table selection does not grow with the number of selected cells.

type CollaborationSelectionKind = 'cells';

CollaborationStatustype

Lifecycle state of one collaboration replica.

One axis, because the only question a host has to answer is whether to tell the reader to wait or to reload:

- initializing — joining. Edits are refused. Recovers on its own. - ready — replicating. Accepts edits. - disconnected — the transport dropped. The replica is intact and recovers on its own, so wait rather than reload. Edits continue by default, and the buffered updates merge on reconnect. A session created with offlineEditing: false refuses them until reconnect. - error — this replica does not agree with the room. Edits are refused. [CollaborationStatusSnapshot.reason](CollaborationStatusSnapshot.reason) says why. A remote update the replica could not apply yet heals when a later update completes shared state ([CollaborationStatusSnapshot.recovering](CollaborationStatusSnapshot.recovering)). A format or version mismatch needs an upgrade of this client or the room; every other cause needs a rejoin. - destroyed — torn down. Terminal.

type CollaborationStatus = 'initializing' | 'ready' | 'disconnected' | 'error' | 'destroyed';

CommentMarkerStyletype

How a collapsed comment marker looks.

- 'initials': a badge with the thread author's initials in the author's color, a reply count, and a check mark when the thread is resolved. - 'icon': the comment icon.

type CommentMarkerStyle = 'initials' | 'icon';

DocxEditorCollaborationNamespacetypeSource ↗

The collaboration presence compound: its parts, by name.

type DocxEditorCollaborationNamespace = typeof DocxEditorCollaboration;

DocxEditorReviewNamespacetypeSource ↗

type DocxEditorReviewNamespace = typeof DocxEditorReview;

ReviewDiagnosticCodetype

Why accepting, rejecting or re-authoring a tracked change skipped an item.

type ReviewDiagnosticCode = 'review.revision-unsupported' | 'review.incomplete-group' | 'review.retained-structure' | 'review.locked-content' | 'review.bound-content' | 'review.stale-revision';

ReviewItemRevealSourcetype

What asked to reveal a review item. See [ReviewItemRevealEvent.source](ReviewItemRevealEvent.source).

type ReviewItemRevealSource = 'navigate' | 'host';

ReviewItemViewtypeSource ↗

type ReviewItemView = ReviewItemPlacement;

ReviewPaneOpeningtype

When the review pane opens by itself.

- 'auto': the pane opens when a document with review items loads, and when a tracked change is made while it is closed, in both cases when the pane has items to list. With revisionsIn: 'balloons' the pane lists no tracked change and no reply to one, so tracked changes and their replies alone do not open it. - 'manual': the pane stays closed until the host or the user opens it. Use it when the host shows review items its own way, such as in balloons or margin markers.

type ReviewPaneOpening = 'auto' | 'manual';

ReviewPaneOverflowtype

What the open review pane does when its full card column does not fit beside the page at the page's zoom.

- 'float': the pane shrinks to a strip of markers, and the open card floats over the page. - 'shrinkPage': under a fit zoom mode, the page may shrink down to the mode's minZoom (or 10%) so that the full column fits. The pane changes to the marker strip only when the column does not fit at that floor either. A fixed zoom behaves as 'float'. - 'scroll': the page keeps the size it has beside the closed pane's marker strip, and the full column stands beside it. The document and the column scroll together: the viewport scrolls sideways to reach the cards.

The setting applies to the review pane only. The navigation pane stays docked at its side in every mode: it never scrolls with the document, and it takes its room beside the page exactly as it does with no review pane.

type ReviewPaneOverflow = 'float' | 'shrinkPage' | 'scroll';

ReviewWriteActiontypeSource ↗

The review write a refusal answered.

type ReviewWriteAction = 'accept' | 'reject' | 'resolve' | 'reopen' | 'remove' | 'reply' | 'comment' | 'edit';

RevisionDisplaytype

Where tracked changes open.

- 'pane': the review pane lists tracked changes as cards beside the comments. - 'balloons': the pane lists comments only, except comments that reply to a tracked change: the change's balloon shows those. A tracked change opens in a balloon at its text when the reader clicks it, or when Next Change, Previous Change, or setActiveReviewItem(key, { announce: true }) reaches it. A replacement is one balloon. In both settings, Next Change and Previous Change stop on a replacement once.

type RevisionDisplay = 'pane' | 'balloons';

ScrollPlacementtype

Where a scroll places its target in the viewport.

- 'start': near the top, like a jump to a heading. - 'center': centred. - 'centerIfNeeded': still while the target is on screen, centred when it has to move. - 'nearest': the minimum scroll, which leaves the target at the edge it came in from.

Each method that takes a placement states its own default.

type ScrollPlacement = 'start' | 'center' | 'centerIfNeeded' | 'nearest';

UseDocumentCollaborationConnectOptionstypeSource ↗

Arguments for [UseDocumentCollaborationReturn.connect](UseDocumentCollaborationReturn.connect): the createDocumentCollaboration options. The consumer owns ydoc, awareness, and whatever provider replicates them.

type UseDocumentCollaborationConnectOptions = CreateDocumentCollaborationOptions;

Variables (5)

CustomNodeChromeconstSource ↗

Applies custom-node chip colors and dispatches click and hover activation.

Mount this component once inside DocxEditorRoot. It renders no element.

CustomNodeChrome: {
    new (): {
        $props: CustomNodeChromeProps;
    };
}

CustomNodeContextMenuconstSource ↗

Adds custom-node information, edit, and remove rows to the context menu.

Place this component inside DocxEditorContextMenu.

CustomNodeContextMenu: {
    readonly docxRowPlacement: 'start';
    new (): {
        $props: CustomNodeContextMenuProps;
    };
}

DocxEditorCollaborationconstSource ↗

Presence chrome over a live collaboration session.

Compose the parts inside DocxEditorRoot with the collaboration module registered:

DocxEditorCollaboration: {
    CaretLabels: vue.DefineComponent<vue.ExtractPropTypes<{
        session: {
            type: PropType<CollaborationSession | null>;
            default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        session: {
            type: PropType<CollaborationSession | null>;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        session: CollaborationSession | null;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Avatars: vue.DefineComponent<vue.ExtractPropTypes<{
        session: {
            type: PropType<CollaborationSession | null>;
            default: undefined;
        };
        max: {
            type: NumberConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        session: {
            type: PropType<CollaborationSession | null>;
            default: undefined;
        };
        max: {
            type: NumberConstructor;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        session: CollaborationSession | null;
        max: number;
        className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Avatar: vue.DefineComponent<vue.ExtractPropTypes<{
        participant: {
            type: PropType<CollaborationParticipant>;
            required: true;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        participant: {
            type: PropType<CollaborationParticipant>;
            required: true;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Status: vue.DefineComponent<vue.ExtractPropTypes<{
        session: {
            type: PropType<CollaborationSession | null>;
            default: undefined;
        };
        onRejoin: {
            type: PropType<() => void>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        session: {
            type: PropType<CollaborationSession | null>;
            default: undefined;
        };
        onRejoin: {
            type: PropType<() => void>;
            default: undefined;
        };
        className: {
            type: StringConstructor;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        session: CollaborationSession | null;
        onRejoin: () => void;
        className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}
```html
<DocxEditorCollaboration.Avatars :session="session" :max="4" />
<DocxEditorCollaboration.Status :session="session" :on-rejoin="rejoin" />
<DocxEditorCollaboration.CaretLabels :session="session" v-slot="{ selection, color }">
  <MyLabel :name="selection.name" :color="color" />
</DocxEditorCollaboration.CaretLabels>
```

DocxEditorCollaborationRootconstSource ↗

A DocxEditorRoot wired to a collaboration room.

html <DocxEditorCollaborationRoot :collaboration="collaboration"> <DocxEditorToolbar /> <DocxEditorViewport> <DocxEditorContent /> <DocxEditorCollaboration.CaretLabels /> </DocxEditorViewport> <template #fallback><p>Connecting…</p></template> </DocxEditorCollaborationRoot>

The presence parts take no session: they read it from the editor this mounts.

DocxEditorCollaborationRoot: vue.DefineComponent<vue.ExtractPropTypes<{
    collaboration: {
        type: PropType<CollaborationRootSource>;
        required: true;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    collaboration: {
        type: PropType<CollaborationRootSource>;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

DocxEditorReviewconstSource ↗

The review rail: comments and tracked changes as a compound component. Requires reviewModule() in the editor's modules.

PARTS AND SCOPES. The rail reads its parts from its own children, by element type. There are two scopes:

- Root parts: List, Markers, AddComment, Draft, and Balloon. Put them as DIRECT children of DocxEditorReview (fragments are transparent). The rail gives them the geometry only it can compute: the comment button's and the compose box's top, and the markers' scale and window. A root part inside a wrapper component is not seen as a part. It renders as ordinary content, without that wiring. - Card parts: Card, Empty, and the parts inside a card (Author, Summary, Accept, Reject, Reply, and the others). Put them inside DocxEditorReview.List, or as other direct children, which become the card template.

:preset="false" drops the packaged defaults. Root parts you pass still get their wiring, and every other child renders as is inside the rail, where useReviewRailMetrics() reads the rail's own measurement. To render your own cards, use useReview().items, useStackedReviewPositions, and useReviewRailMetrics. Draft without top sits where the packaged card stack puts it, so pass top from your own stack.

In a browser host, this rail and useReview() are the way to build a review UI. For headless, server, or agent pipelines, use @docx-editor.dev/editor-api.

DocxEditorReview: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        t: {
            type: PropType<(key: string, params?: Record<string, string | number>) => string>;
            default: undefined;
        };
        card: {
            type: PropType<{
                className?: string;
            }>;
            default: undefined;
        };
        furniture: {
            type: PropType<VNode | VNode[]>;
            default: undefined;
        };
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        stack: {
            type: BooleanConstructor;
            default: boolean;
        };
        gap: {
            type: NumberConstructor;
            default: number;
        };
        filter: {
            type: PropType<(item: ReviewItemView) => boolean>;
            default: undefined;
        };
        structural: {
            type: BooleanConstructor;
            default: boolean;
        };
        formatting: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        asChild: boolean;
        hidden: boolean;
        t: (key: string, params?: Record<string, string | number>) => string;
        card: {
            className?: string;
        };
        furniture: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>[] | VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        preset: boolean;
        stack: boolean;
        gap: number;
        filter: (item: ReviewItemView) => boolean;
        structural: boolean;
        formatting: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        t: {
            type: PropType<(key: string, params?: Record<string, string | number>) => string>;
            default: undefined;
        };
        card: {
            type: PropType<{
                className?: string;
            }>;
            default: undefined;
        };
        furniture: {
            type: PropType<VNode | VNode[]>;
            default: undefined;
        };
        preset: {
            type: BooleanConstructor;
            default: boolean;
        };
        stack: {
            type: BooleanConstructor;
            default: boolean;
        };
        gap: {
            type: NumberConstructor;
            default: number;
        };
        filter: {
            type: PropType<(item: ReviewItemView) => boolean>;
            default: undefined;
        };
        structural: {
            type: BooleanConstructor;
            default: boolean;
        };
        formatting: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        asChild: boolean;
        hidden: boolean;
        t: (key: string, params?: Record<string, string | number>) => string;
        card: {
            className?: string;
        };
        furniture: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>[] | VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        preset: boolean;
        stack: boolean;
        gap: number;
        filter: (item: ReviewItemView) => boolean;
        structural: boolean;
        formatting: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    className: StringConstructor;
    asChild: BooleanConstructor;
    hidden: BooleanConstructor;
    t: {
        type: PropType<(key: string, params?: Record<string, string | number>) => string>;
        default: undefined;
    };
    card: {
        type: PropType<{
            className?: string;
        }>;
        default: undefined;
    };
    furniture: {
        type: PropType<VNode | VNode[]>;
        default: undefined;
    };
    preset: {
        type: BooleanConstructor;
        default: boolean;
    };
    stack: {
        type: BooleanConstructor;
        default: boolean;
    };
    gap: {
        type: NumberConstructor;
        default: number;
    };
    filter: {
        type: PropType<(item: ReviewItemView) => boolean>;
        default: undefined;
    };
    structural: {
        type: BooleanConstructor;
        default: boolean;
    };
    formatting: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    asChild: boolean;
    hidden: boolean;
    t: (key: string, params?: Record<string, string | number>) => string;
    card: {
        className?: string;
    };
    furniture: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    preset: boolean;
    stack: boolean;
    gap: number;
    filter: (item: ReviewItemView) => boolean;
    structural: boolean;
    formatting: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    List: vue.DefineComponent<vue.ExtractPropTypes<{
        stack: {
            type: BooleanConstructor;
            default: boolean;
        };
        positions: {
            type: PropType<ReadonlyMap<string, number>>;
            default: undefined;
        };
        collapsed: {
            type: PropType<ReadonlySet<string>>;
            default: undefined;
        };
        scale: {
            type: NumberConstructor;
            default: number;
        };
        offset: {
            type: NumberConstructor;
            default: number;
        };
        window: {
            type: PropType<{
                top: number;
                bottom: number;
            } | null>;
            default: null;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        stack: {
            type: BooleanConstructor;
            default: boolean;
        };
        positions: {
            type: PropType<ReadonlyMap<string, number>>;
            default: undefined;
        };
        collapsed: {
            type: PropType<ReadonlySet<string>>;
            default: undefined;
        };
        scale: {
            type: NumberConstructor;
            default: number;
        };
        offset: {
            type: NumberConstructor;
            default: number;
        };
        window: {
            type: PropType<{
                top: number;
                bottom: number;
            } | null>;
            default: null;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>> & Readonly<{}>, {
        stack: boolean;
        positions: ReadonlyMap<string, number>;
        collapsed: ReadonlySet<string>;
        scale: number;
        offset: number;
        window: {
            top: number;
            bottom: number;
        } | null;
        hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Empty: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Card: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Avatar: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Author: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Time: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Summary: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Accept: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        asChild: boolean;
        hidden: boolean;
        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Reject: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        asChild: boolean;
        hidden: boolean;
        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Resolve: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        asChild: boolean;
        hidden: boolean;
        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Reopen: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        asChild: boolean;
        hidden: boolean;
        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Delete: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        asChild: BooleanConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | string>;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        asChild: boolean;
        hidden: boolean;
        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Refusal: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
        asChild: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
        asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Replies: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Reply: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Markers: vue.DefineComponent<vue.ExtractPropTypes<{
        scale: {
            type: NumberConstructor;
            default: number;
        };
        offset: {
            type: NumberConstructor;
            default: number;
        };
        window: {
            type: PropType<{
                top: number;
                bottom: number;
            } | null>;
            default: null;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | ((item: ReviewItemView) => VNode | null | undefined)>;
            default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        scale: {
            type: NumberConstructor;
            default: number;
        };
        offset: {
            type: NumberConstructor;
            default: number;
        };
        window: {
            type: PropType<{
                top: number;
                bottom: number;
            } | null>;
            default: null;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
        icon: {
            type: PropType<VNode | ((item: ReviewItemView) => VNode | null | undefined)>;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        scale: number;
        offset: number;
        window: {
            top: number;
            bottom: number;
        } | null;
        hidden: boolean;
        icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | ((item: ReviewItemView) => VNode | null | undefined);
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    AddComment: vue.DefineComponent<vue.ExtractPropTypes<{
        top: {
            type: PropType<number | null>;
            default: null;
        };
        drafting: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        top: {
            type: PropType<number | null>;
            default: null;
        };
        drafting: {
            type: BooleanConstructor;
            default: boolean;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>> & Readonly<{}>, {
        top: number | null;
        drafting: boolean;
        hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Draft: vue.DefineComponent<vue.ExtractPropTypes<{
        top: {
            type: PropType<number | undefined>;
            default: undefined;
        };
        left: {
            type: PropType<number | null | undefined>;
            default: undefined;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        top: {
            type: PropType<number | undefined>;
            default: undefined;
        };
        left: {
            type: PropType<number | null | undefined>;
            default: undefined;
        };
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>> & Readonly<{}>, {
        top: number | undefined;
        left: number | null | undefined;
        hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Balloon: vue.DefineComponent<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        className: StringConstructor;
        hidden: BooleanConstructor;
    }>> & Readonly<{}>, {
        hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}