@fileverse-dev/ddoc 3.1.7-linkCaption-0 → 3.1.7-sg-1

package/dist/package/components/inline-comment/use-floating-card-state.d.ts

@@ -0,0 +1,36 @@
+import { MutableRefObject } from 'react';
+import { FloatingLayoutInvalidationFlag, FloatingCardLayoutInput } from './comment-floating-layout';
+import { CommentFloatingCard } from './context/types';
+import { FloatingCardRuntimeState } from './floating-comment-layout-utils';
+
+interface SyncMountedFloatingCardIdsResult {
+    didChange: boolean;
+    previousMountedFloatingCardIds: Set<string>;
+}
+export interface UseFloatingCardStateResult {
+    floatingCardStateRef: MutableRefObject<Map<string, FloatingCardRuntimeState>>;
+    orderedFloatingCardIdsRef: MutableRefObject<string[]>;
+    orderDirtyRef: MutableRefObject<boolean>;
+    heightMeasurementQueueRef: MutableRefObject<Set<string>>;
+    layoutBoundaryRef: MutableRefObject<{
+        recomputeFromIndex: number;
+    }>;
+    mountedFloatingCardIdsRef: MutableRefObject<string[]>;
+    mountedFloatingCardIds: string[];
+    getFloatingCardRuntimeState: (floatingCardId: string) => FloatingCardRuntimeState;
+    getOrderedFloatingCardIndex: (floatingCardId: string) => number | null;
+    markRecomputeFromIndex: (recomputeFromIndex: number) => void;
+    markFloatingCardInvalidated: (floatingCardId: string, flag: FloatingLayoutInvalidationFlag) => void;
+    markFloatingCardOrderDirty: () => void;
+    reconcileFloatingCardOrder: (nextFloatingCards: CommentFloatingCard[]) => {
+        orderedFloatingCardIds: string[];
+        firstChangedIndex: number | null;
+    };
+    pruneFloatingCardRuntimeState: (activeFloatingCardIds: Set<string>) => void;
+    syncMountedFloatingCardIds: (nextMountedFloatingCardIds: string[]) => SyncMountedFloatingCardIdsResult;
+    clearInvalidationFlagsThroughIndex: (stopIndex: number) => void;
+    getFloatingCardLayoutInputs: () => FloatingCardLayoutInput[];
+    resetFloatingCardState: () => void;
+}
+export declare const useFloatingCardState: () => UseFloatingCardStateResult;
+export {};

package/dist/package/components/inline-comment/use-floating-comment-card-layout.d.ts

@@ -0,0 +1,23 @@
+import { RefObject } from 'react';
+import { Editor } from '@tiptap/react';
+import { CommentFloatingCard } from './context/types';
+
+interface UseFloatingCommentCardLayoutProps {
+    blurFloatingCard: (floatingCardId: string) => void;
+    closeFloatingCard: (floatingCardId: string) => void;
+    editor: Editor;
+    editorWrapperRef: RefObject<HTMLDivElement>;
+    floatingCardIdsKey: string;
+    floatingCards: CommentFloatingCard[];
+    focusedFloatingCardId: string | null;
+    isDesktopFloatingEnabled: boolean;
+    isHidden: boolean;
+    scrollContainerRef: RefObject<HTMLDivElement>;
+}
+interface UseFloatingCommentCardLayoutResult {
+    floatingCardListContainerRef: RefObject<HTMLDivElement>;
+    mountedFloatingCardIds: string[];
+    registerCardNode: (floatingCardId: string, node: HTMLDivElement | null) => void;
+}
+export declare const useFloatingCommentCardLayout: ({ blurFloatingCard, closeFloatingCard, editor, editorWrapperRef, floatingCardIdsKey, floatingCards, focusedFloatingCardId, isDesktopFloatingEnabled, isHidden, scrollContainerRef, }: UseFloatingCommentCardLayoutProps) => UseFloatingCommentCardLayoutResult;
+export {};

package/dist/package/components/inline-comment/use-floating-comment-card-state.d.ts

@@ -0,0 +1,13 @@
+import { CommentFloatingCard } from './context/types';
+
+interface UseFloatingCommentCardStateResult {
+    blurFloatingCard: (floatingCardId: string) => void;
+    closeFloatingCard: (floatingCardId: string) => void;
+    floatingCardIdsKey: string;
+    floatingCardMap: Map<string, CommentFloatingCard>;
+    floatingCards: CommentFloatingCard[];
+    focusedFloatingCardId: string | null;
+    isDesktopFloatingEnabled: boolean;
+}
+export declare const useFloatingCommentCardState: () => UseFloatingCommentCardStateResult;
+export {};

package/dist/package/components/inline-comment/use-floating-layout-engine.d.ts

@@ -0,0 +1,26 @@
+import { RefObject } from 'react';
+import { Editor } from '@tiptap/react';
+import { CommentFloatingCard } from './context/types';
+import { UseAnchorRegistryResult } from './use-anchor-registry';
+import { UseFloatingCardStateResult } from './use-floating-card-state';
+
+interface UseFloatingLayoutEngineProps {
+    blurFloatingCard: (floatingCardId: string) => void;
+    closeFloatingCard: (floatingCardId: string) => void;
+    editor: Editor;
+    editorWrapperRef: RefObject<HTMLDivElement>;
+    floatingCardIdsKey: string;
+    floatingCards: CommentFloatingCard[];
+    focusedFloatingCardId: string | null;
+    isDesktopFloatingEnabled: boolean;
+    isHidden: boolean;
+    scrollContainerRef: RefObject<HTMLDivElement>;
+    anchorRegistry: UseAnchorRegistryResult;
+    floatingCardState: UseFloatingCardStateResult;
+}
+export interface UseFloatingLayoutEngineResult {
+    floatingCardListContainerRef: RefObject<HTMLDivElement>;
+    registerCardNode: (floatingCardId: string, node: HTMLDivElement | null) => void;
+}
+export declare const useFloatingLayoutEngine: ({ blurFloatingCard, closeFloatingCard, editor, editorWrapperRef, floatingCardIdsKey, floatingCards, focusedFloatingCardId, isDesktopFloatingEnabled, isHidden, scrollContainerRef, anchorRegistry, floatingCardState, }: UseFloatingLayoutEngineProps) => UseFloatingLayoutEngineResult;
+export {};

package/dist/package/components/inline-comment/use-is-selected-content-deleted.d.ts

@@ -0,0 +1 @@
+export declare function useIsSelectedContentDeleted(commentId: string | undefined, selectedContent: string | undefined, commentTabId: string | undefined): boolean;

package/dist/package/components/tabs/document-tabs-sidebar.d.ts

@@ -31,9 +31,10 @@ export interface DocumentTabsSidebarProps {
     tabConfig?: DocumentOutlineProps['tabConfig'];
     deleteTab?: (tabId: string) => void;
     isConnected?: boolean;
+    isFocusMode?: boolean;
 }
 export declare const DocumentTabsSidebar: ({ tabSectionContainer, ...rest }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element | null;
-export declare const TabSidebar: ({ tabs, activeTabId, setActiveTabId, showTOC, setShowTOC, hasToC, isPreviewMode, editor, items, setItems, orientation, createTab, renameTab, duplicateTab, orderTab, tabCommentCounts, isVersionHistoryMode, tabConfig, deleteTab, isConnected, }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TabSidebar: ({ tabs, activeTabId, setActiveTabId, showTOC, setShowTOC, hasToC, isPreviewMode, editor, items, setItems, orientation, createTab, renameTab, duplicateTab, orderTab, tabCommentCounts, isVersionHistoryMode, tabConfig, deleteTab, isConnected, isFocusMode, }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element;
 export declare const DdocTab: ({ tab, tabIndex, tabCount, handleEmojiChange, handleNameChange, onClick, editor, tocItem, setTocItems, orientation, activeTabId, duplicateTab, commentCount, moveTabUp, moveTabDown, isPreviewMode, isVersionHistoryMode, tabConfig, onDelete, showOutline, onShowOutlineChange, isConnected, }: {
     tab: Tab;
     tabIndex: number;

package/dist/package/extensions/comment/comment-decoration-plugin.d.ts

@@ -0,0 +1,95 @@
+import { Extension, Editor } from '@tiptap/core';
+import { EditorState, PluginKey } from '@tiptap/pm/state';
+import { Transform } from '@tiptap/pm/transform';
+import { DecorationSet } from '@tiptap/pm/view';
+import { SuggestionType } from '../../types';
+
+import * as Y from 'yjs';
+export interface CommentAnchor {
+    id: string;
+    anchorFrom: Y.RelativePosition;
+    anchorTo: Y.RelativePosition;
+    resolved: boolean;
+    deleted: boolean;
+    isSuggestion?: boolean;
+    suggestionType?: SuggestionType;
+    originalContent?: string;
+    suggestedContent?: string;
+}
+interface CommentDecorationPluginState {
+    decorations: DecorationSet;
+}
+type CommentAnchorRange = {
+    from: number;
+    to: number;
+};
+type CommentAnchorRelativeRange = {
+    anchorFrom: Y.RelativePosition;
+    anchorTo: Y.RelativePosition;
+};
+export type CommentAnchorTransactionChange = {
+    id: string;
+    type: 'unchanged';
+} | {
+    id: string;
+    type: 'deleted';
+} | ({
+    id: string;
+    type: 'edited';
+} & CommentAnchorRange & CommentAnchorRelativeRange);
+export declare const commentDecorationPluginKey: PluginKey<CommentDecorationPluginState>;
+export declare function resolveCommentAnchorRangeInState(anchor: Pick<CommentAnchor, 'anchorFrom' | 'anchorTo'>, state: EditorState): CommentAnchorRange | null;
+/**
+ * Resolve anchorFrom to a single absolute position.
+ * Used for 'add' suggestion anchors where anchorFrom === anchorTo (cursor,
+ * no initial selection) — resolveCommentAnchorRangeInState rejects from >= to,
+ * so we need a separate path that allows a point position.
+ */
+export declare function resolveCommentAnchorPointInState(anchor: Pick<CommentAnchor, 'anchorFrom'>, state: EditorState): number | null;
+export declare function resolveCommentAnchorRangeForAnalysis(anchor: Pick<CommentAnchor, 'id' | 'anchorFrom' | 'anchorTo'>, state: EditorState): CommentAnchorRange | null;
+/**
+ * Analyze transaction changes to classify each active anchor's mutation status.
+ *
+ * This is the core transaction analysis function that determines
+ * whether each anchor remains unchanged, gets edited, or is deleted.
+ *
+ * Classification rules (in order):
+ * 1. Skip deleted or resolved anchors → 'unchanged'
+ * 2. If anchor has no old position → 'unchanged'
+ * 3. If no changed ranges touch the anchor → 'unchanged'
+ * 4. If any changed range fully covers the anchor → 'deleted' (full-span replacement)
+ * 5. If combined changed ranges fully cover the anchor → 'deleted' (multi-step removal)
+ * 6. If anchor maps through transform → check if position or content changed:
+ *    a. If both unchanged → 'unchanged'
+ *    b. Otherwise → 'edited' (return new position and relative anchor)
+ * 7. If mapping fails → 'deleted'
+ */
+export declare function analyzeCommentAnchorTransactionChanges(anchors: CommentAnchor[], oldState: EditorState, newState: EditorState, transform: Transform): CommentAnchorTransactionChange[];
+export interface CommentDecorationOptions {
+    getAnchors: () => CommentAnchor[];
+    getActiveCommentId: () => string | null;
+}
+export declare const CommentDecorationExtension: Extension<CommentDecorationOptions, any>;
+/**
+ * Public helper functions for comment anchor creation and inspection.
+ * These are consumed by the draft-creation flow and transaction-analysis layer.
+ */
+export declare function createCommentAnchorFromEditor(editor: Editor, from: number, to: number): CommentAnchorRelativeRange | null;
+/**
+ * Create a point anchor (anchorFrom === anchorTo) at a single doc position.
+ * Used by the suggestion-mode draft flow when the viewer places a cursor
+ * without selecting text — createCommentAnchorFromEditor rejects from >= to
+ * since an empty range is invalid for regular comments.
+ */
+export declare function createCommentAnchorPointFromEditor(editor: Editor, pos: number): CommentAnchorRelativeRange | null;
+export declare function createCommentAnchorFromSelection(editor: Editor): CommentAnchorRelativeRange | null;
+export declare function triggerDecorationRebuild(editor: Editor): void;
+export declare function getCommentAtPosition(editor: Editor, pos: number, getAnchors: () => CommentAnchor[]): CommentAnchor | null;
+export declare function getCommentAnchorRange(editor: Editor, commentId: string, getAnchors: () => CommentAnchor[]): CommentAnchorRange | null;
+/**
+ * Apply the accepted suggestion's change to the document.
+ * Called by the store's acceptSuggestion action before resolving on-chain.
+ * Returns false if the anchor can't be resolved or the suggestion type is unknown.
+ */
+export declare function applyAcceptedSuggestion(editor: Editor, anchor: CommentAnchor): boolean;
+export {};

package/dist/package/extensions/comment/comment.d.ts

@@ -1,5 +1,8 @@
 import { Mark, Range } from '@tiptap/core';
 import { Mark as PMMark } from '@tiptap/pm/model';
+import { PluginKey, EditorState } from '@tiptap/pm/state';
+import { DecorationSet } from '@tiptap/pm/view';
+import { SuggestionType } from '../../types';
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -28,6 +31,18 @@ declare module '@tiptap/core' {
              * Unset comment active
              */
             unsetCommentActive: () => ReturnType;
+            /**
+             * Add a local draft anchor that tracks through transactions.
+             */
+            setDraftComment: (draftId: string) => ReturnType;
+            /**
+             * Remove a local draft anchor.
+             */
+            unsetDraftComment: (draftId: string) => ReturnType;
+            /**
+             * Replace a draft anchor with a persisted comment mark.
+             */
+            promoteDraftComment: (draftId: string, commentId: string) => ReturnType;
         };
     }
 }
@@ -35,6 +50,10 @@ export interface MarkWithRange {
     mark: PMMark;
     range: Range;
 }
+export interface CommentMarkMatch {
+    commentId: string;
+    resolved: boolean;
+}
 export interface CommentOptions {
     HTMLAttributes: Record<string, any>;
     onCommentActivated: (commentId: string) => void;
@@ -45,6 +64,20 @@ export interface CommentOptions {
 export interface CommentStorage {
     activeCommentId: string | null;
 }
+export interface DraftCommentRange {
+    draftId: string;
+    from: number;
+    to: number;
+}
+interface DraftCommentPluginState {
+    decorations: DecorationSet;
+    drafts: Map<string, DraftCommentRange>;
+}
+export declare const draftCommentPluginKey: PluginKey<DraftCommentPluginState>;
+export declare const getDraftCommentState: (state: EditorState) => DraftCommentPluginState | undefined;
+export declare const getDraftCommentRange: (state: EditorState, draftId: string) => DraftCommentRange | null;
+export declare const getCommentMarkAtPosition: (state: EditorState, pos: number) => CommentMarkMatch | null;
+export declare const getCommentMarkRange: (state: EditorState, commentId: string) => Range | null;
 export interface IComment {
     id?: string;
     tabId?: string;
@@ -61,5 +94,10 @@ export interface IComment {
     deleted?: boolean;
     commentIndex?: number;
     version?: string;
+    isSuggestion?: boolean;
+    suggestionType?: SuggestionType;
+    originalContent?: string;
+    suggestedContent?: string;
 }
 export declare const CommentExtension: Mark<CommentOptions, CommentStorage>;
+export {};

package/dist/package/extensions/resizable-media/resizable-media-menu-util.d.ts

@@ -1,17 +1,18 @@
-import { Attrs, Node as ProseMirrorNode } from '@tiptap/pm/model';
-import { Editor } from '@tiptap/core';
+import { Attrs } from '@tiptap/pm/model';
 
 interface ResizableMediaAttributes {
     dataAlign: string;
     dataFloat: null | string;
+    showCaptionInput?: boolean;
+    caption?: string;
 }
 type UpdateAttributes = (attrs: Partial<ResizableMediaAttributes>) => void;
-type Action = (updateAttributes: UpdateAttributes, editor?: Editor, getPos?: (() => number | undefined) | boolean) => void;
+type Action = (updateAttributes: UpdateAttributes) => void;
 interface ResizableMediaAction {
     tooltip: string;
     icon?: string;
     action?: Action;
-    isActive?: (attrs: Attrs, node?: ProseMirrorNode) => boolean;
+    isActive?: (attrs: Attrs) => boolean;
     delete?: (d: () => void) => void;
 }
 export declare const resizableMediaActions: ResizableMediaAction[];

package/dist/package/extensions/resizable-media/resizable-media-node-view.d.ts

@@ -4,4 +4,4 @@ import { IpfsImageFetchPayload } from '../../types.ts';
 export declare const getResizableMediaNodeView: (ipfsImageFetchFn: (_data: IpfsImageFetchPayload) => Promise<{
     url: string;
     file: File;
-}>, fetchV1ImageFn: (url: string) => Promise<ArrayBuffer | undefined>) => ({ node, updateAttributes, deleteNode, selected, editor, getPos, }: NodeViewProps) => import("react/jsx-runtime").JSX.Element;
+}>, fetchV1ImageFn: (url: string) => Promise<ArrayBuffer | undefined>) => ({ node, updateAttributes, deleteNode, selected }: NodeViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/extensions/suggestion/suggestion-tracking-extension.d.ts

@@ -0,0 +1,30 @@
+import { Extension } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+import { SuggestionType } from '../../types';
+import { CommentAnchor } from '../comment/comment-decoration-plugin';
+
+import * as Y from 'yjs';
+export interface SuggestionReadyData {
+    suggestionId: string;
+    anchorFrom: Y.RelativePosition;
+    anchorTo: Y.RelativePosition;
+    suggestionType: SuggestionType;
+    originalContent: string;
+    suggestedContent: string;
+}
+export interface SuggestionTrackingOptions {
+    /** Returns true when the editor is in suggestion mode. */
+    getIsSuggestionMode: () => boolean;
+    /** Viewer types text with a collapsed cursor (Add gesture). */
+    onTextInput: (text: string) => void;
+    /** Viewer types text over a non-empty selection (Replace gesture). */
+    onReplaceTyping: (from: number, to: number, text: string) => void;
+    /** Viewer presses Backspace/Delete with a non-empty selection. */
+    onDeleteSelection: (from: number, to: number) => void;
+    /** Viewer presses Cmd+Z (or Ctrl+Z). Shrinks the active draft by one keystroke. */
+    onUndo: () => void;
+    onLiveSuggestion?: ((anchor: CommentAnchor) => void) | null;
+    onSuggestionReady?: ((data: SuggestionReadyData) => void) | null;
+}
+export declare const suggestionTrackingPluginKey: PluginKey<null>;
+export declare const SuggestionTrackingExtension: Extension<SuggestionTrackingOptions, any>;

package/dist/package/hooks/use-editing-context.d.ts

@@ -4,6 +4,7 @@ type EditingContextType = {
     isPreviewMode: boolean;
     isPresentationMode?: boolean;
     isCollaboratorsDoc?: boolean;
+    isSuggestionMode?: boolean;
 };
 export declare const useEditingContext: () => EditingContextType;
 type EditingProviderProps = {
@@ -12,6 +13,7 @@ type EditingProviderProps = {
     isPresentationMode?: boolean;
     isCollaboratorsDoc?: boolean;
     isPreviewEditor?: boolean;
+    isSuggestionMode?: boolean;
 };
 export declare const EditingProvider: React.FC<EditingProviderProps>;
 export {};

package/dist/package/hooks/use-tab-editor.d.ts

@@ -1,6 +1,7 @@
 import { Dispatch, MutableRefObject, SetStateAction } from 'react';
-import { DdocProps, ThemeKey } from '../types';
+import { DdocProps, SerializedCommentAnchor, ThemeKey } from '../types';
 import { AnyExtension, Editor } from '@tiptap/react';
+import { CommentAnchor } from '../extensions/comment/comment-decoration-plugin';
 import { ToCItemType } from '../components/toc/types';
 import { CollabConnectionConfig, CollaborationProps } from '../sync-local/types';
 
@@ -11,12 +12,14 @@ interface UseTabEditorArgs {
     hasTabState?: boolean;
     versionId?: string;
     isPreviewMode?: boolean;
+    viewerMode?: DdocProps['viewerMode'];
     initialContent: DdocProps['initialContent'];
     collaboration?: CollaborationProps;
     isReady?: boolean;
     isSyncing?: boolean;
     awareness?: any;
     disableInlineComment?: boolean;
+    isFocusMode?: boolean;
     onCommentInteraction?: DdocProps['onCommentInteraction'];
     onError?: DdocProps['onError'];
     ipfsImageUploadFn?: DdocProps['ipfsImageUploadFn'];
@@ -47,8 +50,9 @@ interface UseTabEditorArgs {
     activeTabId: string;
     theme?: ThemeKey;
     editorRef?: MutableRefObject<Editor | null>;
+    initialCommentAnchors?: SerializedCommentAnchor[];
 }
-export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, initialContent, collaboration, isReady, isSyncing, awareness, disableInlineComment, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setPageCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, }: UseTabEditorArgs) => {
+export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, viewerMode, initialContent, collaboration, isReady, isSyncing, awareness, disableInlineComment, isFocusMode, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setPageCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, initialCommentAnchors, }: UseTabEditorArgs) => {
     editor: Editor | null;
     ref: import('react').RefObject<HTMLDivElement>;
     slides: string[];
@@ -59,5 +63,8 @@ export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionI
     setActiveCommentId: Dispatch<SetStateAction<string | null>>;
     focusCommentWithActiveId: (id: string) => void;
     isContentLoading: boolean | undefined;
+    commentAnchorsRef: MutableRefObject<CommentAnchor[]>;
+    draftAnchorsRef: MutableRefObject<CommentAnchor[]>;
+    storeApiRef: MutableRefObject<import('zustand').StoreApi<import('../stores/comment-store').CommentStoreState> | null>;
 };
 export {};

package/dist/package/stores/comment-store-provider.d.ts

@@ -0,0 +1,64 @@
+import { default as React } from 'react';
+import { Editor } from '@tiptap/core';
+import { IComment } from '../extensions/comment';
+import { CommentAnchor } from '../extensions/comment/comment-decoration-plugin';
+import { CommentMutationMeta, SerializedCommentAnchor } from '../types';
+import { createCommentStore } from './comment-store';
+
+import * as Y from 'yjs';
+export interface CommentStoreProviderProps {
+    children: React.ReactNode;
+    editor: Editor | null;
+    ydoc: Y.Doc;
+    isFocusMode?: boolean;
+    setActiveCommentId: (id: string | null) => void;
+    focusCommentWithActiveId: (id: string) => void;
+    setInitialComments?: React.Dispatch<React.SetStateAction<IComment[]>>;
+    onNewComment?: (comment: IComment, meta?: CommentMutationMeta) => void;
+    onEditComment?: (commentId: string, meta?: CommentMutationMeta) => void;
+    onEditReply?: (commentId: string, replyId: string, meta?: CommentMutationMeta) => void;
+    onCommentReply?: (activeCommentId: string, reply: IComment) => void;
+    onResolveComment?: (commentId: string, meta?: CommentMutationMeta) => void;
+    onUnresolveComment?: (commentId: string, meta?: CommentMutationMeta) => void;
+    onDeleteComment?: (commentId: string, meta?: CommentMutationMeta) => void;
+    onInlineComment?: () => void;
+    onComment?: () => void;
+    setCommentDrawerOpen?: (open: boolean) => void;
+    connectViaWallet?: () => Promise<void>;
+    connectViaUsername?: (username: string) => Promise<void>;
+    ensResolutionUrl: string;
+    commentAnchorsRef?: React.MutableRefObject<CommentAnchor[]>;
+    draftAnchorsRef?: React.MutableRefObject<CommentAnchor[]>;
+    /**
+     * Ref populated by the provider with the Zustand store instance.
+     * SuggestionTrackingExtension reads this inside event handlers to route
+     * keystrokes into draft actions without rebuilding the editor.
+     */
+    storeApiRef?: React.MutableRefObject<ReturnType<typeof createCommentStore> | null>;
+    initialCommentAnchors?: SerializedCommentAnchor[];
+    initialComments: IComment[];
+    username: string | null;
+    activeCommentId: string | null;
+    activeTabId: string;
+    isConnected?: boolean;
+    isLoading?: boolean;
+    isDDocOwner?: boolean;
+    setUsername?: React.Dispatch<React.SetStateAction<string>>;
+}
+export declare const CommentStoreProvider: ({ children, editor, ydoc, isFocusMode, setActiveCommentId, focusCommentWithActiveId, setInitialComments, onNewComment, onEditComment, onEditReply, onCommentReply, onResolveComment, onUnresolveComment, onDeleteComment, onInlineComment, onComment, setCommentDrawerOpen, connectViaWallet, connectViaUsername, ensResolutionUrl, commentAnchorsRef, draftAnchorsRef, storeApiRef, initialCommentAnchors, setUsername: setUsernameProp, initialComments, username, activeCommentId, activeTabId, isConnected, isLoading, isDDocOwner, }: CommentStoreProviderProps) => import("react/jsx-runtime").JSX.Element;
+interface CommentRefsContextType {
+    commentsSectionRef: React.RefObject<HTMLDivElement>;
+    replySectionRef: React.RefObject<HTMLDivElement>;
+    portalRef: React.RefObject<HTMLDivElement>;
+    buttonRef: React.RefObject<HTMLDivElement>;
+    dropdownRef: React.RefObject<HTMLDivElement>;
+    mobileDraftRef: React.RefObject<HTMLDivElement>;
+}
+export declare const useCommentRefs: () => CommentRefsContextType;
+interface CommentAnchorsContextType {
+    activeCommentAnchorIds: Set<string>;
+    activeCommentAnchorIdsTabId: string | null;
+    hasRenderedCommentAnchor: (commentId: string) => boolean;
+}
+export declare const useCommentAnchors: () => CommentAnchorsContextType;
+export {};