superdoc 2.2.1 → 2.4.0-next.1

package/dist/superdoc/src/stores/superdoc-store.d.ts

@@ -0,0 +1,2254 @@
+export const useSuperdocStore: import('pinia').StoreDefinition<"superdoc", Pick<{
+    commentsStore: import('pinia').Store<"comments", Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "suppressInternalExternal" | "activeComment" | "activeFloatingCommentInstanceId" | "floatingCommentsOffset" | "pendingComment" | "currentCommentText" | "isDebugging" | "editingCommentId" | "editorCommentPositions" | "isCommentHighlighted" | "v2CommentsAdapter" | "COMMENT_EVENTS" | "hasInitializedComments" | "hasSyncedCollaborationComments" | "commentDialogs" | "overlappingComments" | "overlappedIds" | "commentsList" | "isCommentsListVisible" | "generalCommentIds" | "editorCommentIds" | "commentsParentElement" | "hasInitializedLocations" | "sortedConversations" | "visibleConversations" | "skipSelectionUpdate" | "isFloatingCommentsReady" | "instantSidebarAlignmentTargetY" | "instantSidebarAlignmentThreadId" | "instantSidebarAlignmentInstanceId" | "viewingVisibility" | "v2TrackedChangesAdapter">, Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "getConfig" | "documentsWithConverations" | "getGroupedComments" | "hasOpenTrackedChanges" | "getCommentsByPosition" | "getFloatingComments" | "getFloatingCommentInstances" | "isViewingMode" | "shouldRenderReviewInViewing">, Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "getCommentAliasIds" | "getTrackedChangeThread" | "getCommentPositionKey" | "getCommentPosition" | "getCommentAnchoredText" | "getCommentAnchorData" | "resolveCommentPositionEntry" | "getCommentDocumentId" | "belongsToDocument" | "init" | "setViewingVisibility" | "getComment" | "setActiveComment" | "getCommentLocation" | "hasOverlapId" | "getPendingComment" | "showAddComment" | "addComment" | "addHydratedComment" | "cancelComment" | "deleteComment" | "removePendingComment" | "cancelImportedTrackedChangeBootstrap" | "removeCommentsForDocument" | "processLoadedDocxComments" | "translateCommentsForExport" | "handleEditorLocationsUpdate" | "clearEditorCommentPositions" | "handleTrackedChangeUpdate" | "refreshTrackedChangeCommentsByIds" | "syncResolvedCommentsWithDocument" | "syncTrackedChangePositionsWithDocument" | "setActiveFloatingCommentInstance" | "requestInstantSidebarAlignment" | "peekInstantSidebarAlignment" | "clearInstantSidebarAlignment" | "syncTrackedChangeComments" | "decideTrackedChangeFromSidebar" | "setV2CommentsAdapter" | "getV2CommentsAdapter" | "hydrateCommentsFromV2" | "applyReviewSnapshotFromV2" | "reconcileCommentsFromV2" | "isV2EditorActive" | "replyCommentV2" | "editCommentV2" | "resolveCommentV2" | "reopenCommentV2" | "setV2TrackedChangesAdapter" | "getV2TrackedChangesAdapter" | "hydrateTrackedChangesFromV2" | "reconcileTrackedChangeMutationFromV2" | "reconcileTrackedChangesFromV2" | "remapTrackedChangeIdentities">>;
+    documents: import('vue').Ref<any[], any[]>;
+    documentBounds: import('vue').Ref<never[], never[]>;
+    pages: {};
+    documentUsers: import('vue').Ref<never[], never[]>;
+    users: import('vue').Ref<never[], never[]>;
+    activeZoom: import('vue').Ref<number, number>;
+    zoomMode: import('vue').Ref<any, any>;
+    measurementUnit: import('vue').Ref<any, any>;
+    viewportMetrics: import('vue').Ref<any, any>;
+    documentScroll: {
+        scrollTop: number;
+        scrollLeft: number;
+    };
+    isInternal: import('vue').Ref<boolean, boolean>;
+    selectionPosition: import('vue').Ref<{
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    }, {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    } | {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    }>;
+    activeSelection: import('vue').Ref<null, null>;
+    isReady: import('vue').Ref<boolean, boolean>;
+    user: {
+        name: null;
+        email: null;
+    };
+    modules: {};
+    areDocumentsReady: import('vue').ComputedRef<boolean>;
+    init: (config: any) => Promise<void>;
+    setExceptionHandler: (handler: any) => void;
+    reset: () => void;
+    handlePageReady: (documentId: any, index: any, containerBounds: any) => void;
+    getDocument: (documentId: any) => any;
+    removeDocument: (documentId: string) => any | null;
+    getPageBounds: (documentId: any, page: any) => {
+        top: number;
+    } | undefined;
+}, "user" | "users" | "isReady" | "activeZoom" | "zoomMode" | "viewportMetrics" | "documents" | "pages" | "isInternal" | "commentsStore" | "documentBounds" | "documentUsers" | "measurementUnit" | "documentScroll" | "selectionPosition" | "activeSelection" | "modules">, Pick<{
+    commentsStore: import('pinia').Store<"comments", Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "suppressInternalExternal" | "activeComment" | "activeFloatingCommentInstanceId" | "floatingCommentsOffset" | "pendingComment" | "currentCommentText" | "isDebugging" | "editingCommentId" | "editorCommentPositions" | "isCommentHighlighted" | "v2CommentsAdapter" | "COMMENT_EVENTS" | "hasInitializedComments" | "hasSyncedCollaborationComments" | "commentDialogs" | "overlappingComments" | "overlappedIds" | "commentsList" | "isCommentsListVisible" | "generalCommentIds" | "editorCommentIds" | "commentsParentElement" | "hasInitializedLocations" | "sortedConversations" | "visibleConversations" | "skipSelectionUpdate" | "isFloatingCommentsReady" | "instantSidebarAlignmentTargetY" | "instantSidebarAlignmentThreadId" | "instantSidebarAlignmentInstanceId" | "viewingVisibility" | "v2TrackedChangesAdapter">, Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "getConfig" | "documentsWithConverations" | "getGroupedComments" | "hasOpenTrackedChanges" | "getCommentsByPosition" | "getFloatingComments" | "getFloatingCommentInstances" | "isViewingMode" | "shouldRenderReviewInViewing">, Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "getCommentAliasIds" | "getTrackedChangeThread" | "getCommentPositionKey" | "getCommentPosition" | "getCommentAnchoredText" | "getCommentAnchorData" | "resolveCommentPositionEntry" | "getCommentDocumentId" | "belongsToDocument" | "init" | "setViewingVisibility" | "getComment" | "setActiveComment" | "getCommentLocation" | "hasOverlapId" | "getPendingComment" | "showAddComment" | "addComment" | "addHydratedComment" | "cancelComment" | "deleteComment" | "removePendingComment" | "cancelImportedTrackedChangeBootstrap" | "removeCommentsForDocument" | "processLoadedDocxComments" | "translateCommentsForExport" | "handleEditorLocationsUpdate" | "clearEditorCommentPositions" | "handleTrackedChangeUpdate" | "refreshTrackedChangeCommentsByIds" | "syncResolvedCommentsWithDocument" | "syncTrackedChangePositionsWithDocument" | "setActiveFloatingCommentInstance" | "requestInstantSidebarAlignment" | "peekInstantSidebarAlignment" | "clearInstantSidebarAlignment" | "syncTrackedChangeComments" | "decideTrackedChangeFromSidebar" | "setV2CommentsAdapter" | "getV2CommentsAdapter" | "hydrateCommentsFromV2" | "applyReviewSnapshotFromV2" | "reconcileCommentsFromV2" | "isV2EditorActive" | "replyCommentV2" | "editCommentV2" | "resolveCommentV2" | "reopenCommentV2" | "setV2TrackedChangesAdapter" | "getV2TrackedChangesAdapter" | "hydrateTrackedChangesFromV2" | "reconcileTrackedChangeMutationFromV2" | "reconcileTrackedChangesFromV2" | "remapTrackedChangeIdentities">>;
+    documents: import('vue').Ref<any[], any[]>;
+    documentBounds: import('vue').Ref<never[], never[]>;
+    pages: {};
+    documentUsers: import('vue').Ref<never[], never[]>;
+    users: import('vue').Ref<never[], never[]>;
+    activeZoom: import('vue').Ref<number, number>;
+    zoomMode: import('vue').Ref<any, any>;
+    measurementUnit: import('vue').Ref<any, any>;
+    viewportMetrics: import('vue').Ref<any, any>;
+    documentScroll: {
+        scrollTop: number;
+        scrollLeft: number;
+    };
+    isInternal: import('vue').Ref<boolean, boolean>;
+    selectionPosition: import('vue').Ref<{
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    }, {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    } | {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    }>;
+    activeSelection: import('vue').Ref<null, null>;
+    isReady: import('vue').Ref<boolean, boolean>;
+    user: {
+        name: null;
+        email: null;
+    };
+    modules: {};
+    areDocumentsReady: import('vue').ComputedRef<boolean>;
+    init: (config: any) => Promise<void>;
+    setExceptionHandler: (handler: any) => void;
+    reset: () => void;
+    handlePageReady: (documentId: any, index: any, containerBounds: any) => void;
+    getDocument: (documentId: any) => any;
+    removeDocument: (documentId: string) => any | null;
+    getPageBounds: (documentId: any, page: any) => {
+        top: number;
+    } | undefined;
+}, "areDocumentsReady">, Pick<{
+    commentsStore: import('pinia').Store<"comments", Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "suppressInternalExternal" | "activeComment" | "activeFloatingCommentInstanceId" | "floatingCommentsOffset" | "pendingComment" | "currentCommentText" | "isDebugging" | "editingCommentId" | "editorCommentPositions" | "isCommentHighlighted" | "v2CommentsAdapter" | "COMMENT_EVENTS" | "hasInitializedComments" | "hasSyncedCollaborationComments" | "commentDialogs" | "overlappingComments" | "overlappedIds" | "commentsList" | "isCommentsListVisible" | "generalCommentIds" | "editorCommentIds" | "commentsParentElement" | "hasInitializedLocations" | "sortedConversations" | "visibleConversations" | "skipSelectionUpdate" | "isFloatingCommentsReady" | "instantSidebarAlignmentTargetY" | "instantSidebarAlignmentThreadId" | "instantSidebarAlignmentInstanceId" | "viewingVisibility" | "v2TrackedChangesAdapter">, Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "getConfig" | "documentsWithConverations" | "getGroupedComments" | "hasOpenTrackedChanges" | "getCommentsByPosition" | "getFloatingComments" | "getFloatingCommentInstances" | "isViewingMode" | "shouldRenderReviewInViewing">, Pick<{
+        COMMENT_EVENTS: {
+            readonly RESOLVED: "resolved";
+            readonly NEW: "new";
+            readonly ADD: "add";
+            readonly UPDATE: "update";
+            readonly DELETED: "deleted";
+            readonly PENDING: "pending";
+            readonly SELECTED: "selected";
+            readonly COMMENTS_LIST: "comments-list";
+            readonly CHANGE_ACCEPTED: "change-accepted";
+            readonly CHANGE_REJECTED: "change-rejected";
+        };
+        isDebugging: boolean;
+        hasInitializedComments: import('vue').Ref<boolean, boolean>;
+        hasSyncedCollaborationComments: import('vue').Ref<boolean, boolean>;
+        editingCommentId: import('vue').Ref<null, null>;
+        activeComment: import('vue').Ref<null, null>;
+        activeFloatingCommentInstanceId: import('vue').Ref<null, null>;
+        commentDialogs: import('vue').Ref<never[], never[]>;
+        overlappingComments: import('vue').Ref<never[], never[]>;
+        overlappedIds: Set<never>;
+        suppressInternalExternal: import('vue').Ref<boolean, boolean>;
+        pendingComment: import('vue').Ref<null, null>;
+        currentCommentText: import('vue').Ref<string, string>;
+        commentsList: import('vue').Ref<never[], never[]>;
+        isCommentsListVisible: import('vue').Ref<boolean, boolean>;
+        generalCommentIds: import('vue').Ref<never[], never[]>;
+        editorCommentIds: import('vue').Ref<never[], never[]>;
+        commentsParentElement: import('vue').Ref<null, null>;
+        editorCommentPositions: import('vue').Ref<{}, {}>;
+        hasInitializedLocations: import('vue').Ref<boolean, boolean>;
+        isCommentHighlighted: import('vue').Ref<boolean, boolean>;
+        floatingCommentsOffset: import('vue').Ref<number, number>;
+        sortedConversations: import('vue').Ref<never[], never[]>;
+        visibleConversations: import('vue').Ref<never[], never[]>;
+        skipSelectionUpdate: import('vue').Ref<boolean, boolean>;
+        isFloatingCommentsReady: import('vue').Ref<boolean, boolean>;
+        instantSidebarAlignmentTargetY: import('vue').Ref<null, null>;
+        instantSidebarAlignmentThreadId: import('vue').Ref<null, null>;
+        instantSidebarAlignmentInstanceId: import('vue').Ref<null, null>;
+        getConfig: import('vue').ComputedRef<{
+            name: string;
+            readOnly: boolean;
+            allowResolve: boolean;
+            showResolved: boolean;
+        }>;
+        documentsWithConverations: import('vue').ComputedRef<any>;
+        getGroupedComments: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        hasOpenTrackedChanges: import('vue').ComputedRef<boolean>;
+        getCommentsByPosition: import('vue').ComputedRef<{
+            parentComments: any[];
+            resolvedComments: any[];
+        }>;
+        getFloatingComments: import('vue').ComputedRef<any[]>;
+        getFloatingCommentInstances: import('vue').ComputedRef<{
+            id: any;
+            threadId: any;
+            comment: any;
+            positionKey: any;
+            pageIndex: any;
+            isPrimary: boolean;
+            positionEntry: any;
+        }[]>;
+        getCommentAliasIds: (commentOrId: any) => (string | null)[];
+        getTrackedChangeThread: (parentComment: any) => any[] | readonly never[];
+        getCommentPositionKey: (commentOrId: Object | string | null | undefined) => string | null;
+        getCommentPosition: (commentOrId: Object | string) => Object | null;
+        getCommentAnchoredText: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => string | null;
+        getCommentAnchorData: (commentOrId: Object | string, options?: {
+            separator?: string | undefined;
+            trim?: boolean | undefined;
+        }) => {
+            position: Object;
+            anchoredText: string | null;
+        } | null;
+        resolveCommentPositionEntry: (commentOrId: any, preferredId: any) => {
+            key: string | null;
+            entry: any;
+        };
+        getCommentDocumentId: (comment: any) => string | null;
+        belongsToDocument: (comment: any, activeDocumentId: any, options?: {}) => any;
+        viewingVisibility: {
+            documentMode: string;
+            commentsVisible: boolean;
+            trackChangesVisible: boolean;
+        };
+        isViewingMode: import('vue').ComputedRef<boolean>;
+        shouldRenderReviewInViewing: import('vue').ComputedRef<boolean>;
+        init: (config?: Object) => void;
+        setViewingVisibility: ({ documentMode, commentsVisible, trackChangesVisible }?: {}) => void;
+        getComment: (id: string) => Record<string, unknown> | null | undefined;
+        setActiveComment: (superdoc: Object | undefined | null, id: string | undefined | null) => void;
+        getCommentLocation: (selection: any, parent: any) => {
+            top: any;
+            left: any;
+        };
+        hasOverlapId: (id: any) => any;
+        getPendingComment: ({ selection, documentId, parentCommentId, ...options }: {
+            selection: Object;
+            documentId: string;
+            parentCommentId: string;
+        }) => Object;
+        showAddComment: (superdoc: any, targetClientY?: null) => Promise<{
+            ok: boolean;
+            reason: any;
+            detail: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+            detail?: undefined;
+        } | {
+            ok: boolean;
+            reason: string;
+            detail: any;
+        }> | {
+            ok: boolean;
+            reason: any;
+        } | {
+            ok: boolean;
+            reason?: undefined;
+        };
+        addComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        addHydratedComment: ({ superdoc, comment, skipEditorUpdate, broadcastChanges }: {
+            superdoc: any;
+            comment: any;
+            skipEditorUpdate?: boolean | undefined;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        cancelComment: (superdoc: any) => void;
+        deleteComment: ({ commentId: commentIdToDelete, superdoc }: {
+            commentId: any;
+            superdoc: any;
+        }) => Promise<any>;
+        removePendingComment: (superdoc: any) => void;
+        cancelImportedTrackedChangeBootstrap: (documentId: string | null | undefined) => number;
+        removeCommentsForDocument: (documentId: string | null | undefined) => void;
+        processLoadedDocxComments: ({ superdoc, editor, comments, documentId, replacedFile }: {
+            comments: any[];
+            documentId: string;
+            replacedFile?: boolean | undefined;
+        }) => void;
+        translateCommentsForExport: () => any[];
+        handleEditorLocationsUpdate: (allCommentPositions: Object, options?: {
+            retainMissingTrackedChangeGeometry?: boolean;
+            retainedTrackedChangeIds?: Iterable<string>;
+        }) => void;
+        clearEditorCommentPositions: () => void;
+        handleTrackedChangeUpdate: ({ superdoc, params, broadcastChanges, documentState }: {
+            superdoc: Object;
+            params: Object;
+        }) => void;
+        refreshTrackedChangeCommentsByIds: ({ superdoc, editor, changeIds, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            changeIds: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        syncResolvedCommentsWithDocument: ({ editor }?: {}) => number;
+        syncTrackedChangePositionsWithDocument: ({ documentId, editor }?: {}) => number;
+        setActiveFloatingCommentInstance: (instanceId?: null) => void;
+        requestInstantSidebarAlignment: (targetY?: null, threadId?: null, instanceId?: null) => void;
+        peekInstantSidebarAlignment: () => null;
+        clearInstantSidebarAlignment: () => void;
+        syncTrackedChangeComments: ({ superdoc, editor, broadcastChanges }: {
+            superdoc: any;
+            editor: any;
+            broadcastChanges?: boolean | undefined;
+        }) => void;
+        decideTrackedChangeFromSidebar: ({ superdoc, comment, decision }: {
+            superdoc: Object;
+            editor: Object;
+        }) => void;
+        v2CommentsAdapter: import('vue').ShallowRef<null, null>;
+        setV2CommentsAdapter: (adapter: any) => void;
+        getV2CommentsAdapter: (superdoc: any) => any;
+        hydrateCommentsFromV2: ({ superdoc, adapter, documentId }?: {}) => Promise<any>;
+        applyReviewSnapshotFromV2: ({ superdoc, commentsAdapter, trackedChangesAdapter, documentId, commentItems, trackedChangeItems, trackedList, patch, }?: {}) => any;
+        reconcileCommentsFromV2: ({ superdoc, adapter, documentId, items, preparedInputs }?: {
+            preparedInputs?: null | undefined;
+        }) => any;
+        isV2EditorActive: (superdoc: any) => boolean;
+        replyCommentV2: ({ superdoc, parentCommentId, text }?: {}) => Promise<any>;
+        editCommentV2: ({ superdoc, commentId, text }?: {}) => Promise<any>;
+        resolveCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        reopenCommentV2: ({ superdoc, commentId }?: {}) => Promise<any>;
+        v2TrackedChangesAdapter: import('vue').ShallowRef<null, null>;
+        setV2TrackedChangesAdapter: (adapter: any) => void;
+        getV2TrackedChangesAdapter: (superdoc: any) => any;
+        hydrateTrackedChangesFromV2: ({ superdoc, adapter, documentId, trackedChangesListMode, refreshReason, blocking, }?: {
+            trackedChangesListMode?: string | undefined;
+        }) => Promise<any>;
+        reconcileTrackedChangeMutationFromV2: ({ superdoc, adapter, documentId, upsertIds, removedIds, }?: {
+            upsertIds?: never[] | undefined;
+            removedIds?: never[] | undefined;
+        }) => Promise<{
+            ok: boolean;
+            reason: string;
+            items?: undefined;
+            resolvedIds?: undefined;
+            unresolvedIds?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: never[];
+            resolvedIds: never[];
+            unresolvedIds: never[];
+            reason?: undefined;
+            failures?: undefined;
+        } | {
+            ok: boolean;
+            items: any[];
+            resolvedIds: (string | null)[];
+            unresolvedIds: (string | null)[];
+            failures: any[];
+            reason?: undefined;
+        }>;
+        reconcileTrackedChangesFromV2: ({ superdoc, adapter, documentId, items, pruneStale, preparedParams, }?: {
+            pruneStale?: boolean | undefined;
+            preparedParams?: null | undefined;
+        }) => any;
+        remapTrackedChangeIdentities: (pairs?: any[], { documentId }?: {}) => void;
+    }, "getCommentAliasIds" | "getTrackedChangeThread" | "getCommentPositionKey" | "getCommentPosition" | "getCommentAnchoredText" | "getCommentAnchorData" | "resolveCommentPositionEntry" | "getCommentDocumentId" | "belongsToDocument" | "init" | "setViewingVisibility" | "getComment" | "setActiveComment" | "getCommentLocation" | "hasOverlapId" | "getPendingComment" | "showAddComment" | "addComment" | "addHydratedComment" | "cancelComment" | "deleteComment" | "removePendingComment" | "cancelImportedTrackedChangeBootstrap" | "removeCommentsForDocument" | "processLoadedDocxComments" | "translateCommentsForExport" | "handleEditorLocationsUpdate" | "clearEditorCommentPositions" | "handleTrackedChangeUpdate" | "refreshTrackedChangeCommentsByIds" | "syncResolvedCommentsWithDocument" | "syncTrackedChangePositionsWithDocument" | "setActiveFloatingCommentInstance" | "requestInstantSidebarAlignment" | "peekInstantSidebarAlignment" | "clearInstantSidebarAlignment" | "syncTrackedChangeComments" | "decideTrackedChangeFromSidebar" | "setV2CommentsAdapter" | "getV2CommentsAdapter" | "hydrateCommentsFromV2" | "applyReviewSnapshotFromV2" | "reconcileCommentsFromV2" | "isV2EditorActive" | "replyCommentV2" | "editCommentV2" | "resolveCommentV2" | "reopenCommentV2" | "setV2TrackedChangesAdapter" | "getV2TrackedChangesAdapter" | "hydrateTrackedChangesFromV2" | "reconcileTrackedChangeMutationFromV2" | "reconcileTrackedChangesFromV2" | "remapTrackedChangeIdentities">>;
+    documents: import('vue').Ref<any[], any[]>;
+    documentBounds: import('vue').Ref<never[], never[]>;
+    pages: {};
+    documentUsers: import('vue').Ref<never[], never[]>;
+    users: import('vue').Ref<never[], never[]>;
+    activeZoom: import('vue').Ref<number, number>;
+    zoomMode: import('vue').Ref<any, any>;
+    measurementUnit: import('vue').Ref<any, any>;
+    viewportMetrics: import('vue').Ref<any, any>;
+    documentScroll: {
+        scrollTop: number;
+        scrollLeft: number;
+    };
+    isInternal: import('vue').Ref<boolean, boolean>;
+    selectionPosition: import('vue').Ref<{
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    }, {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    } | {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        source: null;
+    }>;
+    activeSelection: import('vue').Ref<null, null>;
+    isReady: import('vue').Ref<boolean, boolean>;
+    user: {
+        name: null;
+        email: null;
+    };
+    modules: {};
+    areDocumentsReady: import('vue').ComputedRef<boolean>;
+    init: (config: any) => Promise<void>;
+    setExceptionHandler: (handler: any) => void;
+    reset: () => void;
+    handlePageReady: (documentId: any, index: any, containerBounds: any) => void;
+    getDocument: (documentId: any) => any;
+    removeDocument: (documentId: string) => any | null;
+    getPageBounds: (documentId: any, page: any) => {
+        top: number;
+    } | undefined;
+}, "reset" | "init" | "setExceptionHandler" | "handlePageReady" | "getDocument" | "removeDocument" | "getPageBounds">>;