superdoc 2.28.0 → 2.29.0-next.13

package/dist/superdoc/src/components/CommentsLayer/CommentHeader.vue.d.ts

@@ -1,26 +1,110 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "reject" | "resolve" | "reopen" | "overflow-select", ...args: any[]) => void;
-    config: Record<string, any>;
-    isPendingInput: boolean;
+import { PropType } from 'vue';
+import { CommentModel } from './use-comment.js';
+type HeaderConfig = {
+    readOnly?: boolean;
+    allowResolve?: boolean;
+};
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    timestamp: {
+        type: NumberConstructor;
+        required: false;
+    };
+    config: {
+        type: PropType<HeaderConfig>;
+        required: true;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+    isPendingInput: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    isActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    resolveDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    rejectDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenSupported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    writeDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reject: (...args: any[]) => void;
+    resolve: (...args: any[]) => void;
+    reopen: (...args: any[]) => void;
+    "overflow-select": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    timestamp: {
+        type: NumberConstructor;
+        required: false;
+    };
+    config: {
+        type: PropType<HeaderConfig>;
+        required: true;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+    isPendingInput: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    isActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    resolveDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    rejectDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenSupported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    writeDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    onReject?: ((...args: any[]) => any) | undefined;
+    onResolve?: ((...args: any[]) => any) | undefined;
+    onReopen?: ((...args: any[]) => any) | undefined;
+    "onOverflow-select"?: ((...args: any[]) => any) | undefined;
+}>, {
     isActive: boolean;
-    resolveDisabledReason: string;
-    rejectDisabledReason: string;
-    reopenDisabledReason: string;
+    isPendingInput: boolean;
+    resolveDisabledReason: string | null;
+    rejectDisabledReason: string | null;
+    reopenDisabledReason: string | null;
     reopenSupported: boolean;
-    writeDisabledReason: string;
-    comment?: Record<string, any> | undefined;
-    timestamp?: number | undefined;
-    $props: {
-        readonly config?: Record<string, any> | undefined;
-        readonly isPendingInput?: boolean | undefined;
-        readonly isActive?: boolean | undefined;
-        readonly resolveDisabledReason?: string | undefined;
-        readonly rejectDisabledReason?: string | undefined;
-        readonly reopenDisabledReason?: string | undefined;
-        readonly reopenSupported?: boolean | undefined;
-        readonly writeDisabledReason?: string | undefined;
-        readonly comment?: Record<string, any> | undefined;
-        readonly timestamp?: number | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    writeDisabledReason: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/CommentInput.vue.d.ts

@@ -1,19 +1,79 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    focus: (options: any) => void;
-    $emit: (event: "focus", ...args: any[]) => void;
-    config: Record<string, any>;
-    users: unknown[];
+import { PropType } from 'vue';
+import { User } from '../../core/types/index.js';
+import { CommentModel } from './use-comment.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    users: {
+        type: PropType<readonly (User & {
+            access?: string | {
+                role?: string;
+            } | null;
+        })[]>;
+        required: false;
+        default: () => never[];
+    };
+    config: {
+        type: PropType<{
+            readOnly?: boolean;
+            allowResolve?: boolean;
+        }>;
+        required: true;
+    };
+    isFocused: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    includeHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+}>, {
+    focus: (options?: FocusOptions) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    users: {
+        type: PropType<readonly (User & {
+            access?: string | {
+                role?: string;
+            } | null;
+        })[]>;
+        required: false;
+        default: () => never[];
+    };
+    config: {
+        type: PropType<{
+            readOnly?: boolean;
+            allowResolve?: boolean;
+        }>;
+        required: true;
+    };
+    isFocused: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    includeHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+}>> & Readonly<{
+    onFocus?: ((...args: any[]) => any) | undefined;
+}>, {
     isFocused: boolean;
+    users: readonly (User & {
+        access?: string | {
+            role?: string;
+        } | null;
+    })[];
     includeHeader: boolean;
-    comment?: Record<string, any> | undefined;
-    $props: {
-        readonly config?: Record<string, any> | undefined;
-        readonly users?: unknown[] | undefined;
-        readonly isFocused?: boolean | undefined;
-        readonly includeHeader?: boolean | undefined;
-        readonly comment?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     inputRef: HTMLTextAreaElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/CommentsDropdown.vue.d.ts

@@ -1,23 +1,12 @@
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
-export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & (new () => {
-    $slots: S;
-});
-declare const __VLS_component: import('vue').DefineComponent<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-    options: unknown[];
-    disabled: boolean;
-    contentStyle: Record<string, any>;
-    $props: {
-        readonly options?: unknown[] | undefined;
-        readonly disabled?: boolean | undefined;
-        readonly contentStyle?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    triggerRef: HTMLDivElement;
-    menuRef: HTMLDivElement;
-}, HTMLDivElement>;
-type __VLS_TemplateResult = {
+import { CSSProperties, PropType, VNodeChild } from 'vue';
+type CommentsDropdownOption = {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    iconString?: string;
+    icon?: VNodeChild | ((option: CommentsDropdownOption) => VNodeChild);
+};
+declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
@@ -28,3 +17,49 @@ type __VLS_TemplateResult = {
     };
     rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<readonly CommentsDropdownOption[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<readonly CommentsDropdownOption[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    options: readonly CommentsDropdownOption[];
+    disabled: boolean;
+    contentStyle: CSSProperties;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    triggerRef: HTMLDivElement;
+    menuRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/superdoc/src/components/CommentsLayer/FloatingComments.vue.d.ts

@@ -1,11 +1,24 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    parent: Record<string, any>;
-    currentDocument: Record<string, any>;
-    $props: {
-        readonly parent?: Record<string, any> | undefined;
-        readonly currentDocument?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+import { PropType } from 'vue';
+import { Document as SuperDocDocument } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    currentDocument: {
+        type: PropType<SuperDocDocument>;
+        required: true;
+    };
+    parent: {
+        type: PropType<HTMLElement>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    currentDocument: {
+        type: PropType<SuperDocDocument>;
+        required: true;
+    };
+    parent: {
+        type: PropType<HTMLElement>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     floatingCommentsContainer: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/InternalDropdown.vue.d.ts

@@ -1,10 +1,26 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-    isDisabled: boolean;
-    state?: string | undefined;
-    $props: {
-        readonly isDisabled?: boolean | undefined;
-        readonly state?: string | undefined;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    state: {
+        type: StringConstructor;
+        required: false;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    state: {
+        type: StringConstructor;
+        required: false;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/PdfCommentsLayer.vue.d.ts

@@ -1,4 +1,6 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "anchor-activate", ...args: any[]) => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "anchor-activate": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    "onAnchor-activate"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/commentsList/ReviewDirectoryListItem.vue.d.ts

@@ -1,16 +1,64 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "navigate" | "focus-item", ...args: any[]) => void;
-    index: number;
-    total: number;
-    item: Record<string, any>;
-    tabIndex: number;
-    $props: {
-        readonly index?: number | undefined;
-        readonly total?: number | undefined;
-        readonly item?: Record<string, any> | undefined;
-        readonly tabIndex?: number | undefined;
+import { PropType } from 'vue';
+import { CommentModel } from '../use-comment.js';
+export type PositionEntry = {
+    pageIndex?: number | null;
+    bounds?: {
+        top?: number;
+        bottom?: number;
+    } | null;
+};
+export type ReviewDirectoryItem = {
+    id: string | undefined;
+    comment: CommentModel;
+    floatingInstanceId: string | null;
+    floatingPageIndex: number | null | undefined;
+    floatingPositionEntry: PositionEntry | null;
+    isFloatingInstanceActive: boolean | undefined;
+    threadComments: CommentModel[];
+};
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ReviewDirectoryItem>;
+        required: true;
+    };
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    navigate: (...args: any[]) => void;
+    "focus-item": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ReviewDirectoryItem>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onNavigate?: ((...args: any[]) => any) | undefined;
+    "onFocus-item"?: ((...args: any[]) => any) | undefined;
+}>, {
+    tabIndex: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     shell: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/commentsList/commentsList.vue.d.ts

@@ -1,11 +1,25 @@
-declare const _default: import('vue').DefineComponent<{}, {
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    showMainComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showResolvedComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    showMainComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showResolvedComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
     showMainComments: boolean;
     showResolvedComments: boolean;
-    $props: {
-        readonly showMainComments?: boolean | undefined;
-        readonly showResolvedComments?: boolean | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     listRoot: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/floating-comment-positioning.d.ts

@@ -1,25 +1,26 @@
-export function normalizeFloatingAnchorTop(top: any): any;
-export function isAnchorOutsideFloatingViewport(anchorTop: any, viewportTop: any, viewportBottom: any, anchorBottom?: any): boolean;
-export function shouldKeepFloatingCardAtAnchor({ anchorTop, anchorBottom, viewportTop, viewportBottom }: {
-    anchorTop: any;
-    anchorBottom: any;
-    viewportTop: any;
-    viewportBottom: any;
-}): boolean;
-export function resolveOffscreenFloatingCardTop({ anchorTop, anchorBottom, cardHeight, viewportTop, viewportBottom, }: {
-    anchorTop: any;
-    anchorBottom: any;
-    cardHeight: any;
-    viewportTop: any;
-    viewportBottom: any;
-}): any;
-export function shouldMountFloatingCommentDialog({ id, visibleIds, activeCommentInstanceId }: {
-    id: any;
-    visibleIds: any;
-    activeCommentInstanceId: any;
-}): boolean;
-export function resolveRemovedReviewCardContinuityTarget({ previousIds, currentIds, removedId }: {
+type OptionalNumber = number | null | undefined;
+type FloatingAnchorGeometry = {
+    anchorTop: OptionalNumber;
+    anchorBottom?: OptionalNumber;
+    viewportTop: OptionalNumber;
+    viewportBottom: OptionalNumber;
+};
+type OffscreenFloatingCardInput = FloatingAnchorGeometry & {
+    cardHeight: OptionalNumber;
+};
+type FloatingCommentDialogMountInput = {
+    id: string | null | undefined;
+    visibleIds?: ReadonlySet<string> | null;
+    activeCommentInstanceId?: string | null;
+};
+type RemovedReviewCardContinuityInput = {
     previousIds: readonly string[];
     currentIds: ReadonlySet<string>;
-    removedId: string;
-}): string | null;
+    removedId: string | null | undefined;
+};
+export declare const isAnchorOutsideFloatingViewport: (anchorTop: OptionalNumber, viewportTop: OptionalNumber, viewportBottom: OptionalNumber, anchorBottom?: OptionalNumber) => boolean;
+export declare const shouldKeepFloatingCardAtAnchor: ({ anchorTop, anchorBottom, viewportTop, viewportBottom, }: FloatingAnchorGeometry) => boolean;
+export declare const resolveOffscreenFloatingCardTop: ({ anchorTop, anchorBottom, cardHeight, viewportTop, viewportBottom, }: OffscreenFloatingCardInput) => number | null;
+export declare const shouldMountFloatingCommentDialog: ({ id, visibleIds, activeCommentInstanceId, }: FloatingCommentDialogMountInput) => boolean;
+export declare const resolveRemovedReviewCardContinuityTarget: ({ previousIds, currentIds, removedId, }: RemovedReviewCardContinuityInput) => string | null;
+export {};

package/dist/superdoc/src/components/CommentsLayer/tracked-change-threading.d.ts

@@ -1,2 +1 @@
-export function hasLegacyTrackedChangeThreadSignal(comment: Record<string, any> | null | undefined): boolean;
 export function trackedChangeThreadParentIdForComment(comment: Record<string, any> | null | undefined): string | number | null;

package/dist/superdoc/src/components/CommentsLayer/use-comment.d.ts

@@ -149,21 +149,31 @@ export default function useComment(params: UseCommentParams): {
     isInternal: boolean;
     commentText: string;
     selection: {
-        documentId: any;
-        page: any;
-        selectionBounds: any;
+        documentId: unknown;
+        page: number | undefined;
+        selectionBounds: {
+            top?: number | undefined;
+            left?: number | undefined;
+            right?: number | undefined;
+            bottom?: number | undefined;
+        };
         getValues: () => {
-            documentId: any;
-            page: any;
-            selectionBounds: any;
-            source: any;
+            documentId: unknown;
+            page: number | undefined;
+            selectionBounds: {
+                top?: number;
+                left?: number;
+                right?: number;
+                bottom?: number;
+            };
+            source: string | null | undefined;
         };
         getContainerId: () => string;
-        getContainerLocation: (parentContainer: any) => {
+        getContainerLocation: (parentContainer: Pick<Element, "getBoundingClientRect"> | null | undefined) => {
             top: number;
             left: number;
         };
-        source: any;
+        source: string | null | undefined;
     };
     floatingPosition: {
         top?: number | undefined;
@@ -253,10 +263,15 @@ export default function useComment(params: UseCommentParams): {
         isInternal: boolean;
         commentText: string;
         selection: {
-            documentId: any;
-            page: any;
-            selectionBounds: any;
-            source: any;
+            documentId: unknown;
+            page: number | undefined;
+            selectionBounds: {
+                top?: number;
+                left?: number;
+                right?: number;
+                bottom?: number;
+            };
+            source: string | null | undefined;
         } | null;
         trackedChange: boolean | undefined;
         trackedChangeText: string | null;
@@ -326,4 +341,5 @@ export default function useComment(params: UseCommentParams): {
     };
     updateIdentityValues: (updates?: CommentIdentity) => void;
 };
+export type CommentModel = ReturnType<typeof useComment>;
 export {};