@docx-editor.dev/pro 2.5.0 → 2.6.1

package/dist/vue/index.d.ts

@@ -0,0 +1,1088 @@
+import { EditorModule } from '@docx-editor.dev/core/editor';
+import * as vue_jsx_runtime from 'vue/jsx-runtime';
+import * as vue from 'vue';
+import { ComputedRef, Ref, VNode, MaybeRefOrGetter as MaybeRefOrGetter$1, PropType } from 'vue';
+import { ReviewItemPlacement, ReviewActivationOptions, ReviewItemQuery, Editor } from '@docx-editor.dev/core/contracts/editor';
+export { ReviewActivationOptions } from '@docx-editor.dev/core/contracts/editor';
+import { MaybeRefOrGetter, ReviewAuthorInfo } from '@docx-editor.dev/vue';
+
+/**
+ * Licensing, v1: honor system.
+ *
+ * The key is accepted and remembered so that adding offline (Ed25519)
+ * verification later is not a breaking change — but nothing validates it,
+ * nothing warns, nothing renders differently, and NOTHING EVER LEAVES THE
+ * PROCESS: no network request is made for licensing, ever. That last property
+ * is a spec requirement (`pro-licensing`), not an implementation detail.
+ */
+/** Accepted by every pro entry point. */
+interface ProLicenseOptions {
+    /**
+     * Your 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.
+     */
+    readonly licenseKey?: string;
+}
+
+/**
+ * The review module: comments, tracked changes, and markup rendering as an
+ * `EditorModule` for `createDocxEditor({ modules })`.
+ *
+ * Registering it is the whole enablement story: the review chrome slots light
+ * up through the same `toolbarCommandState` they were disabled by, suggesting
+ * mode becomes reachable, and the editor renders revisions in markup rather
+ * than the free tier's final-state projection.
+ */
+
+/**
+ * How {@link reviewModule} is configured. Carries only the licence key today, so
+ * `reviewModule()` with no argument is the ordinary call.
+ *
+ * @public
+ */
+interface ReviewModuleOptions extends ProLicenseOptions {
+}
+/** Build the review module. Construction never validates the key and never touches the network. */
+declare function reviewModule(options?: ReviewModuleOptions): EditorModule;
+
+/** @public */
+type ReviewItemView = ReviewItemPlacement;
+
+/** @public */
+interface UseReviewReturn {
+    readonly items: ComputedRef<readonly ReviewItemView[]>;
+    readonly activeKey: ComputedRef<string | null>;
+    readonly setActive: (key: string | null, options?: ReviewActivationOptions) => boolean;
+    readonly accept: (item: ReviewItemView) => boolean;
+    readonly reject: (item: ReviewItemView) => boolean;
+    readonly resolve: (item: ReviewItemView) => boolean;
+    readonly reopen: (item: ReviewItemView) => boolean;
+    readonly commentResolutionDisabledReason: ComputedRef<string | null>;
+    readonly remove: (item: ReviewItemView) => boolean;
+    readonly reply: (item: ReviewItemView, text: string, author?: string) => boolean;
+    readonly selectionAnchorY: ComputedRef<number | null>;
+    readonly comment: (text: string, author?: string) => boolean;
+    readonly paneOpen: ComputedRef<boolean>;
+    readonly setPaneOpen: (open: boolean) => void;
+    readonly ready: ComputedRef<boolean>;
+}
+/** @public */
+declare function useReview(query?: MaybeRefOrGetter<ReviewItemQuery | undefined>): UseReviewReturn;
+/** @public */
+declare function useReviewOf(editorRef: Ref<Editor | null>, query?: MaybeRefOrGetter<ReviewItemQuery | undefined>): UseReviewReturn;
+/** @public */
+declare function useStackedReviewPositions(items: MaybeRefOrGetter<readonly {
+    readonly key: string;
+    readonly anchorY: number | null;
+}[]>, heights: MaybeRefOrGetter<ReadonlyMap<string, number>>, options?: MaybeRefOrGetter<{
+    readonly gap?: number;
+    readonly scale?: number;
+    readonly defaultHeight?: number;
+}>): ComputedRef<ReadonlyMap<string, number>>;
+
+/** @public */
+interface ReviewPartProps {
+    className?: string;
+    asChild?: boolean;
+    hidden?: boolean;
+    children?: VNode | VNode[];
+}
+/** @public */
+interface ReviewActionProps extends ReviewPartProps {
+    icon?: VNode | string;
+}
+/** @public */
+interface ReviewMarkersProps extends ReviewPartProps {
+    scale?: number;
+    offset?: number;
+    window?: {
+        top: number;
+        bottom: number;
+    } | null;
+    icon?: VNode | ((item: ReviewItemView) => VNode | null | undefined);
+}
+/** @public */
+interface ReviewProps extends Omit<ReviewPartProps, 'children' | 'hidden'> {
+    t?: (key: string, params?: Record<string, string | number>) => string;
+    card?: {
+        className?: string;
+    };
+    furniture?: VNode | VNode[];
+    preset?: boolean;
+    stack?: boolean;
+    gap?: number;
+    filter?: (item: ReviewItemView) => boolean;
+    structural?: boolean;
+    formatting?: boolean;
+    hidden?: boolean;
+    /** Scoped slot for custom card render: `#default="{ item }"`. */
+    children?: VNode | VNode[];
+}
+
+/** @public */
+declare function useReviewItem(): ComputedRef<ReviewItemView | null>;
+/**
+ * Returns the resolved color, slot, and declared style for one review author.
+ *
+ * The result updates when the author or revision style declarations change.
+ *
+ * @public
+ */
+declare function useReviewAuthor(author: MaybeRefOrGetter$1<string | undefined>): ComputedRef<ReviewAuthorInfo | undefined>;
+
+declare const 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, {
+        filter: (item: ReviewItemView) => boolean;
+        hidden: boolean;
+        t: (key: string, params?: Record<string, string | number>) => string;
+        structural: boolean;
+        furniture: VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        formatting: boolean;
+        asChild: boolean;
+        gap: number;
+        preset: boolean;
+        card: {
+            className?: string;
+        };
+        stack: 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, {}, {}, {}, {
+        filter: (item: ReviewItemView) => boolean;
+        hidden: boolean;
+        t: (key: string, params?: Record<string, string | number>) => string;
+        structural: boolean;
+        furniture: VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        formatting: boolean;
+        asChild: boolean;
+        gap: number;
+        preset: boolean;
+        card: {
+            className?: string;
+        };
+        stack: 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, {
+    filter: (item: ReviewItemView) => boolean;
+    hidden: boolean;
+    t: (key: string, params?: Record<string, string | number>) => string;
+    structural: boolean;
+    furniture: VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    formatting: boolean;
+    asChild: boolean;
+    gap: number;
+    preset: boolean;
+    card: {
+        className?: string;
+    };
+    stack: 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;
+    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | 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<{}>, {
+        hidden: boolean;
+        offset: number;
+        window: {
+            top: number;
+            bottom: number;
+        } | null;
+        scale: number;
+        collapsed: ReadonlySet<string>;
+        stack: boolean;
+        positions: ReadonlyMap<string, number>;
+    }, {}, {}, {}, 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;
+    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | 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<{}>, {
+        hidden: boolean;
+        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>;
+        asChild: boolean;
+    }, {}, {}, {}, 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<{}>, {
+        hidden: boolean;
+        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>;
+        asChild: boolean;
+    }, {}, {}, {}, 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<{}>, {
+        hidden: boolean;
+        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>;
+        asChild: boolean;
+    }, {}, {}, {}, 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<{}>, {
+        hidden: boolean;
+        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>;
+        asChild: boolean;
+    }, {}, {}, {}, 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<{}>, {
+        hidden: boolean;
+        icon: string | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>;
+        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<{}>, {
+        hidden: boolean;
+        offset: number;
+        window: {
+            top: number;
+            bottom: number;
+        } | null;
+        icon: VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | ((item: ReviewItemView) => VNode | null | undefined);
+        scale: number;
+    }, {}, {}, {}, 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;
+        hidden: boolean;
+        drafting: boolean;
+    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+    Draft: vue.DefineComponent<vue.ExtractPropTypes<{
+        top: {
+            type: NumberConstructor;
+            default: number;
+        };
+        left: {
+            type: PropType<number | null>;
+            default: null;
+        };
+        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: NumberConstructor;
+            default: number;
+        };
+        left: {
+            type: PropType<number | null>;
+            default: null;
+        };
+        className: StringConstructor;
+        hidden: BooleanConstructor;
+    }>> & Readonly<{}>, {
+        left: number | null;
+        top: number;
+        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>;
+};
+/** @public */
+type DocxEditorReviewNamespace = typeof DocxEditorReview;
+
+/**
+ * The Standard Schema interface, vendored.
+ *
+ * Any zod, valibot or arktype schema satisfies it. See https://standardschema.dev.
+ *
+ * Reduced to the parts used here rather than copied: the spec's namespace, `Props`,
+ * `SuccessResult`/`FailureResult`, `PathSegment` and `InferInput` are all absent. Assignability
+ * with a real schema is what matters, and is checked against zod in the tests.
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+/** What a Standard Schema validation answers. */
+type StandardSchemaResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly StandardSchemaIssue[];
+};
+/** One validation failure. `path` is what tells a host WHICH field was wrong. */
+interface StandardSchemaIssue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | {
+        readonly key: PropertyKey;
+    })[] | undefined;
+}
+/**
+ * The type a schema produces, for a definition to hand back to its host.
+ *
+ * `unknown` for a definition with no schema, which is the honest description of an unchecked
+ * payload — not `never`, which would make the field unusable rather than merely unguaranteed.
+ */
+type InferSchemaOutput<Schema> = 0 extends 1 & Schema ? any : Schema extends StandardSchemaV1<unknown, infer Output> ? Output : unknown;
+
+/**
+ * One integrator-defined inline node, anchored on a run-level SDT whose `w:tag` carries its
+ * identity.
+ *
+ * A definition claims a tag PREFIX, so `acme` recognizes every `acme:*` tag. An SDT whose prefix
+ * no definition claims stays literal — which is also what the free tier and Word itself render,
+ * so an unrecognized node never loses content or locks editing.
+ *
+ * Build one with {@link defineCustomNode}, which validates the shape, then register it through
+ * {@link customNodesModule}.
+ *
+ * @example
+ * ```ts
+ * const citation = defineCustomNode({
+ *   name: 'citation',
+ *   tagPrefix: 'acme',
+ *   chrome: { color: '#2563eb' },
+ *   onClick: (node) => openCitation(node.attrs.key),
+ * });
+ * ```
+ *
+ * @public
+ */
+interface CustomNodeDefinition<Schema extends StandardSchemaV1 | undefined = any> {
+    /** Node type name — the second segment of the tag (`<prefix>:<name>?…`). */
+    readonly name: string;
+    /** Tag prefix this definition claims (`acme` claims `acme:*`). No colons. */
+    readonly tagPrefix: string;
+    /**
+     * What the document SHOWS for this node, from its payload.
+     *
+     * The one thing most definitions need beyond an identity and a schema:
+     *
+     * ```ts
+     * defineCustomNode({
+     *   name: 'citation',
+     *   tagPrefix: 'docx',
+     *   schema: CitationData,
+     *   text: (data) => `(${data.authors[0]} ${data.year})`,
+     * });
+     * ```
+     *
+     * With it, a write takes the payload alone — `insertCustomNode(editor, Citation, { data })` —
+     * and the words in the paragraph are computed, so they cannot drift from the data they
+     * describe. Without it, pass `text` on every call and keep the two in step yourself.
+     *
+     * Word paints a bound control's text from the payload and will not let a user type into it,
+     * so this is the only thing that decides what a reader sees.
+     */
+    readonly text?: (data: InferSchemaOutput<Schema>) => string;
+    /**
+     * Extra identity to put in the `w:tag`, from the payload. Rarely needed.
+     *
+     * The tag already carries `<prefix>:<name>`, which is what recognition matches on, so most
+     * nodes need nothing here. Add it when a reader that opens the document WITHOUT the payload
+     * store should still be able to tell which one this is — a `sourceId` on a citation, say.
+     *
+     * Word caps the encoded tag at 64 characters, prefix and name included.
+     */
+    readonly tagAttrs?: (data: InferSchemaOutput<Schema>) => Readonly<Record<string, string>>;
+    /**
+     * Recognition hook. Receives the decoded attrs and the SDT's literal text
+     * (so label drift from Word edits is visible) and returns the attrs the node
+     * should carry — or null to leave this SDT unrecognized and literal.
+     *
+     * Every input value originates in a file an attacker controls; treat it as
+     * untrusted and never build DOM or URLs from it without sanitizing.
+     */
+    readonly fromDocx?: (input: {
+        readonly attrs: Readonly<Record<string, string>>;
+        readonly text: string;
+        /**
+         * The bound payload, already through `schema` — so this is the type the definition
+         * declared, not `unknown`. Undefined when the node carries none or it did not match.
+         */
+        readonly data?: InferSchemaOutput<Schema>;
+    }) => Readonly<Record<string, string>> | null;
+    /**
+     * Chip appearance, HOST-authored (never file data). `color` tints the chip
+     * and its border; applied by `CustomNodeChrome` from the adapter-specific Pro entry.
+     */
+    readonly chrome?: {
+        readonly color?: string;
+    };
+    /** Click on the painted chip. UI state belongs in `CustomNodeChrome`'s `onNodeClick`. */
+    readonly onClick?: (node: ActivatedCustomNode) => void;
+    /** Pointer enters the painted chip. */
+    readonly onHover?: (node: ActivatedCustomNode) => void;
+    /**
+     * Contribute a card to the review sidebar for every recognized node of this
+     * definition, anchored at the node's range. Return null to skip one node.
+     *
+     * `attrs` and `text` originate in the file — untrusted; the returned strings
+     * are rendered as TEXT by the pane, never markup. The context-menu section
+     * reuses this hook for its info block and may invoke it with `text: ''` when
+     * no review module is registered (the DOM decode alone cannot see the text).
+     */
+    readonly reviewCard?: (node: {
+        readonly attrs: Readonly<Record<string, string>>;
+        readonly text: string;
+        /** The bound payload, already through `schema` — see {@link CustomNodeDefinition.fromDocx}. */
+        readonly data?: InferSchemaOutput<Schema>;
+    }) => {
+        readonly title: string;
+        readonly detail?: string;
+        /**
+         * Glyph for this node in the COLLAPSED rail, as an SVG path in a `0 -960 960 960`
+         * viewBox (a Material Symbol path is exactly this). Without one every marker in the
+         * gutter is the generic comment bubble, so a citation, a tracked deletion and a
+         * comment are indistinguishable until the pane is opened.
+         *
+         * HOST-AUTHORED. Unlike `title` and `detail`, this is not derived from `attrs` or
+         * `text`: it lands in an SVG `d` attribute, and a path out of a document would be
+         * attacker-controlled markup.
+         */
+        readonly icon?: string;
+    } | null;
+    /**
+     * The "Edit {label}" row the context menu shows at the top when the
+     * right-click lands on the node's chip. The HOST owns the dialog.
+     *
+     * Re-author with `updateCustomNode(editor, definition, node.nodeId, attrs, text, { data })`:
+     * one transaction, one undo step. The activation carries `nodeId`, the node's `text` and its
+     * `data`, which is everything a prefilled form needs.
+     */
+    readonly onEdit?: (node: ActivatedCustomNode) => void;
+    /**
+     * Display name for chrome — the "Edit {label}" context-menu row. Defaults to
+     * `name`. Host-authored, never file data; provide a localized string.
+     */
+    readonly label?: string;
+    /**
+     * The shape of this node's payload, as a zod (or valibot, or arktype) schema.
+     *
+     * A payload lives in a customXml data part, so it arrives from a file the sender controls.
+     * Declaring the shape means it is parsed and checked ONCE, at the read boundary, after which
+     * the `data` handed to the hooks is the type that was asked for rather than something every
+     * caller has to re-guard. Without one, `data` is whatever JSON the file held, typed
+     * `unknown`, which is the honest description of an unchecked payload.
+     *
+     * Any Standard Schema satisfies this, which is what zod produces:
+     *
+     * ```ts
+     * const Citation = z.object({ sourceId: z.string(), year: z.number() });
+     * defineCustomNode({ name: 'citation', tagPrefix: 'acme', schema: Citation });
+     * ```
+     *
+     * Validated on the way IN as well as on the way out, so a payload that does not match is
+     * refused at the insert rather than written and rejected on the next open.
+     */
+    readonly schema?: Schema;
+    /**
+     * The customXml store this definition's payloads live in.
+     *
+     * One store per namespace, per document, so this is what decides whether two definitions
+     * share a store or get one each. Defaults to a namespace derived from `tagPrefix`, which
+     * means a host that never thinks about it still gets one store per prefix and never collides
+     * with another integrator's.
+     *
+     * Set it to interoperate with something that already reads a namespace of its own. Whatever
+     * it is, it must be free of quotes and angle brackets: it is written into an XPath prefix
+     * declaration, where there is no escape for either.
+     */
+    readonly payloadNamespace?: string;
+    /**
+     * What happens to this node when a document is exported OUTSIDE the system that made it.
+     *
+     * A host may not want its own markup travelling in a file its users download: a `w:tag`
+     * naming the tool, or a payload with no meaning anywhere else. This declares the fate, and
+     * the save that applies it picks the pipeline — so one document can serialize one way at
+     * rest and another on the way out.
+     *
+     *  - `true` (default) — the node and its payload survive untouched.
+     *  - `'text'` — the control is unwrapped: a reader still sees the words, while the tag, the
+     *    binding and the payload are gone. Right for a citation, whose text is the point of it.
+     *  - `false` — the node goes, and takes its content with it.
+     *
+     * Applied by `prepareForExport`, which is a pipeline of its own rather than something
+     * `save()` does — that is what lets one document serialize one way at rest and another on the
+     * way out.
+     *
+     * IT DOES NOT MAKE A DOCUMENT ANONYMOUS. It removes this library's markup and nothing else. A
+     * `.docx` carries its origin in `docProps/app.xml`, `docProps/core.xml`, comment and revision
+     * authors, rsids and custom document properties.
+     */
+    readonly preserveOnExport?: boolean | 'text';
+}
+/**
+ * A definition of any payload shape, spelled out.
+ *
+ * The AUTHORED shape, which is what every collection and every internal helper takes: they read
+ * `name`, `schema`, `text` and `preserveOnExport` and never need `dataOf`. A {@link CustomNode}
+ * is assignable to it, so `defineCustomNode`'s result goes wherever this is asked for.
+ *
+ * The same thing bare `CustomNodeDefinition` already means — the interface defaults its
+ * parameter to `any` for exactly this reason. `CustomNodeDefinition<Schema>` is INVARIANT in
+ * `Schema`, because the schema's output type appears in the PARAMETER of `fromDocx` and
+ * `reviewCard`; that is what makes those hooks typed, and it also means two definitions with
+ * different schemas are not assignable to one another. Had the default been `undefined`, the
+ * obvious annotation — `const nodes: CustomNodeDefinition[] = [citation, figure]` — would fail
+ * with a message naming neither the cause nor this alias.
+ *
+ * The cost, stated plainly: `data` is unchecked wherever a definition is held under this type.
+ * Pull one out of a registry and `insertCustomNode(editor, def, attrs, text, { data })` accepts
+ * any shape at all. Payload typing lives where the definition is WRITTEN — `defineCustomNode`
+ * infers the schema, and its hooks are typed from it.
+ */
+type AnyCustomNodeDefinition = CustomNodeDefinition;
+/**
+ * A chip activation: identity + attrs, plus where it sits.
+ *
+ * `attrs` are the definition's OWN shape — the raw tag decode has already been
+ * through `fromDocx`, exactly as the review derivation runs it, so every
+ * surface (click, hover, edit, cards) sees one attrs vocabulary. `text` and
+ * `nodeId` are present when the surface could resolve them (a registered
+ * review module resolves both).
+ */
+interface ActivatedCustomNode {
+    readonly name: string;
+    readonly attrs: Readonly<Record<string, string>>;
+    readonly tag: string;
+    /** Viewport-relative rect of the chip's boundary, for anchoring host UI. */
+    readonly rect: DOMRect;
+    /** The SDT node's canonical id — the address `removeContentControl` takes. */
+    readonly nodeId?: string;
+    /** The node's literal content text, when resolvable. */
+    readonly text?: string;
+    /**
+     * The node's payload, when the surface could resolve one.
+     *
+     * Present only where the review derivation has already run — a chip's own click and hover
+     * resolve through the review item, which is what carries the payload. Undefined otherwise,
+     * and undefined for a node whose payload failed its schema.
+     */
+    readonly data?: unknown;
+}
+
+/** Props for custom-node chip colors and pointer activation. @public */
+interface CustomNodeChromeProps {
+    /** Definitions to style. Defaults to definitions registered on the editor. */
+    readonly nodes?: readonly CustomNodeDefinition[];
+    /** Receives primary-button activation after the definition's own hook. */
+    readonly onNodeClick?: (node: ActivatedCustomNode) => void;
+    /** Receives pointer-entry activation after the definition's own hook. */
+    readonly onNodeHover?: (node: ActivatedCustomNode) => void;
+}
+/**
+ * Applies custom-node chip colors and dispatches click and hover activation.
+ *
+ * Mount this component once inside `DocxEditorRoot`. It renders no element.
+ *
+ * @public
+ */
+declare const CustomNodeChrome: {
+    new (): {
+        $props: CustomNodeChromeProps;
+    };
+};
+
+/** Props for the custom-node context-menu section. @public */
+interface CustomNodeContextMenuProps {
+    /** Definitions to offer. Defaults to definitions registered on the editor. */
+    readonly nodes?: readonly CustomNodeDefinition[];
+    /** Runs after the definition's own edit hook. */
+    readonly onEditNode?: (node: ActivatedCustomNode, definition: CustomNodeDefinition) => void;
+    /** Adds the remove row. Defaults to `true`. */
+    readonly remove?: boolean;
+    /** Receives the engine reason when removal is refused. */
+    readonly onRemoveRefused?: (node: ActivatedCustomNode, reason: string) => void;
+}
+/**
+ * Adds custom-node information, edit, and remove rows to the context menu.
+ *
+ * Place this component inside `DocxEditorContextMenu`.
+ *
+ * @public
+ */
+declare const CustomNodeContextMenu: {
+    readonly docxRowPlacement: "start";
+    new (): {
+        $props: CustomNodeContextMenuProps;
+    };
+};
+
+/** Returns custom-node definitions from a prop or the mounted editor. @public */
+declare function useCustomNodeDefinitions(nodes?: MaybeRefOrGetter$1<readonly AnyCustomNodeDefinition[] | undefined>): ComputedRef<readonly AnyCustomNodeDefinition[]>;
+/** A custom-node definition and decoded node under a pointer target. @public */
+interface ResolvedCustomNodeActivation {
+    readonly node: ActivatedCustomNode;
+    readonly definition: AnyCustomNodeDefinition;
+    readonly controlId: string | null;
+}
+/** Resolves the host-facing custom-node activation payload. @public */
+declare function activatedCustomNodeOf(resolved: ResolvedCustomNodeActivation, editor: Editor | null | undefined): ActivatedCustomNode | null;
+/** Resolves a painted pointer target to a registered custom-node definition. @public */
+declare function resolveCustomNodeActivation(target: EventTarget | null, nodes: readonly AnyCustomNodeDefinition[]): ResolvedCustomNodeActivation | null;
+
+export { CustomNodeChrome, type CustomNodeChromeProps, CustomNodeContextMenu, type CustomNodeContextMenuProps, DocxEditorReview, type DocxEditorReviewNamespace, type ProLicenseOptions, type ResolvedCustomNodeActivation, type ReviewActionProps, type ReviewItemView, type ReviewMarkersProps, type ReviewModuleOptions, type ReviewPartProps, type ReviewProps, type UseReviewReturn, activatedCustomNodeOf, resolveCustomNodeActivation, reviewModule, useCustomNodeDefinitions, useReview, useReviewAuthor, useReviewItem, useReviewOf, useStackedReviewPositions };