superdoc 2.29.0-next.2 → 2.29.0-next.9

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;

package/dist/superdoc/src/components/PdfViewer/PdfViewer.vue.d.ts

@@ -1,35 +1,108 @@
-declare const _default: import('vue').DefineComponent<{}, {
+import { PropType } from 'vue';
+import { PdfViewerConfig, PdfViewerDocumentData, PdfViewerPageData } from './pdf-viewer-types.js';
+declare function updateScale(nextScale: number): void;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    file: {
+        type: PropType<Blob | null>;
+        required: true;
+    };
+    fileId: {
+        type: StringConstructor;
+    };
+    /**
+     * Zoom scale to render the first paint at (1 = 100%). The host seeds
+     * this from `config.zoom.initial` so a PDF never flashes 100% before
+     * a watcher catches up; later changes still arrive via updateScale().
+     */
+    initialScale: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {
     updateScale: typeof updateScale;
-    $emit: (event: "page-rendered" | "selection-raw" | "bypass-selection" | "pages-loaded" | "document-loaded" | "document-ready" | "document-error", ...args: any[]) => void;
-    file: Record<string, any>;
-    config: Record<string, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "page-rendered": (...args: any[]) => void;
+    "selection-raw": (...args: any[]) => void;
+    "bypass-selection": (...args: any[]) => void;
+    "pages-loaded": (...args: any[]) => void;
+    "document-loaded": (...args: any[]) => void;
+    "document-ready": (...args: any[]) => void;
+    "document-error": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    file: {
+        type: PropType<Blob | null>;
+        required: true;
+    };
+    fileId: {
+        type: StringConstructor;
+    };
+    /**
+     * Zoom scale to render the first paint at (1 = 100%). The host seeds
+     * this from `config.zoom.initial` so a PDF never flashes 100% before
+     * a watcher catches up; later changes still arrive via updateScale().
+     */
+    initialScale: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onPage-rendered"?: ((...args: any[]) => any) | undefined;
+    "onSelection-raw"?: ((...args: any[]) => any) | undefined;
+    "onBypass-selection"?: ((...args: any[]) => any) | undefined;
+    "onPages-loaded"?: ((...args: any[]) => any) | undefined;
+    "onDocument-loaded"?: ((...args: any[]) => any) | undefined;
+    "onDocument-ready"?: ((...args: any[]) => any) | undefined;
+    "onDocument-error"?: ((...args: any[]) => any) | undefined;
+}>, {
     initialScale: number;
-    fileId?: string | undefined;
-    $props: {
-        readonly file?: Record<string, any> | undefined;
-        readonly config?: Record<string, any> | undefined;
-        readonly initialScale?: number | undefined;
-        readonly fileId?: string | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     rootRef: HTMLDivElement;
-    documentRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
-        $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
-        pages: unknown[];
-        config: Record<string, any>;
+    documentRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: PropType<PdfViewerConfig>;
+            required: true;
+        };
+        pdf: {
+            type: PropType<PdfViewerDocumentData | null>;
+        };
+        pages: {
+            type: PropType<PdfViewerPageData[]>;
+            required: true;
+        };
+        scale: {
+            type: NumberConstructor;
+            required: true;
+        };
+        hasTextLayer: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        outputScale: {
+            type: NumberConstructor;
+        };
+    }>> & Readonly<{
+        "onPage-rendered"?: ((...args: any[]) => any) | undefined;
+        "onPage-error"?: ((...args: any[]) => any) | undefined;
+        "onSelection-raw"?: ((...args: any[]) => any) | undefined;
+        "onBypass-selection"?: ((...args: any[]) => any) | undefined;
+        "onPage-focus"?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "page-rendered": (...args: any[]) => void;
+        "page-error": (...args: any[]) => void;
+        "selection-raw": (...args: any[]) => void;
+        "bypass-selection": (...args: any[]) => void;
+        "page-focus": (...args: any[]) => void;
+    }, import('vue').PublicProps, {
         hasTextLayer: boolean;
-        scale?: number | undefined;
-        pdf?: Record<string, any> | undefined;
-        outputScale?: number | undefined;
-        $props: {
-            readonly pages?: unknown[] | undefined;
-            readonly config?: Record<string, any> | undefined;
-            readonly hasTextLayer?: boolean | undefined;
-            readonly scale?: number | undefined;
-            readonly pdf?: Record<string, any> | undefined;
-            readonly outputScale?: number | undefined;
-        };
-    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         documentRef: HTMLDivElement;
         documentWrapper: HTMLDivElement;
     }, HTMLDivElement, import('vue').ComponentProvideOptions, {
@@ -39,23 +112,37 @@ declare const _default: import('vue').DefineComponent<{}, {
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<{}> & Readonly<{}>, {
-        $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
-        pages: unknown[];
-        config: Record<string, any>;
+    }, Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: PropType<PdfViewerConfig>;
+            required: true;
+        };
+        pdf: {
+            type: PropType<PdfViewerDocumentData | null>;
+        };
+        pages: {
+            type: PropType<PdfViewerPageData[]>;
+            required: true;
+        };
+        scale: {
+            type: NumberConstructor;
+            required: true;
+        };
+        hasTextLayer: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        outputScale: {
+            type: NumberConstructor;
+        };
+    }>> & Readonly<{
+        "onPage-rendered"?: ((...args: any[]) => any) | undefined;
+        "onPage-error"?: ((...args: any[]) => any) | undefined;
+        "onSelection-raw"?: ((...args: any[]) => any) | undefined;
+        "onBypass-selection"?: ((...args: any[]) => any) | undefined;
+        "onPage-focus"?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
         hasTextLayer: boolean;
-        scale?: number | undefined;
-        pdf?: Record<string, any> | undefined;
-        outputScale?: number | undefined;
-        $props: {
-            readonly pages?: unknown[] | undefined;
-            readonly config?: Record<string, any> | undefined;
-            readonly hasTextLayer?: boolean | undefined;
-            readonly scale?: number | undefined;
-            readonly pdf?: Record<string, any> | undefined;
-            readonly outputScale?: number | undefined;
-        };
-    }, {}, {}, {}, {}> | null;
+    }> | null;
 }, HTMLDivElement>;
 export default _default;
-declare function updateScale(nextScale: any): void;

package/dist/superdoc/src/components/PdfViewer/PdfViewerDocument.vue.d.ts

@@ -1,20 +1,66 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
-    pages: unknown[];
-    config: Record<string, any>;
+import { PropType } from 'vue';
+import { PdfViewerConfig, PdfViewerDocumentData, PdfViewerPageData } from './pdf-viewer-types.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    pdf: {
+        type: PropType<PdfViewerDocumentData | null>;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "page-rendered": (...args: any[]) => void;
+    "page-error": (...args: any[]) => void;
+    "selection-raw": (...args: any[]) => void;
+    "bypass-selection": (...args: any[]) => void;
+    "page-focus": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    pdf: {
+        type: PropType<PdfViewerDocumentData | null>;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+    };
+}>> & Readonly<{
+    "onPage-rendered"?: ((...args: any[]) => any) | undefined;
+    "onPage-error"?: ((...args: any[]) => any) | undefined;
+    "onSelection-raw"?: ((...args: any[]) => any) | undefined;
+    "onBypass-selection"?: ((...args: any[]) => any) | undefined;
+    "onPage-focus"?: ((...args: any[]) => any) | undefined;
+}>, {
     hasTextLayer: boolean;
-    scale?: number | undefined;
-    pdf?: Record<string, any> | undefined;
-    outputScale?: number | undefined;
-    $props: {
-        readonly pages?: unknown[] | undefined;
-        readonly config?: Record<string, any> | undefined;
-        readonly hasTextLayer?: boolean | undefined;
-        readonly scale?: number | undefined;
-        readonly pdf?: Record<string, any> | undefined;
-        readonly outputScale?: number | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     documentRef: HTMLDivElement;
     documentWrapper: HTMLDivElement;
 }, HTMLDivElement>;

package/dist/superdoc/src/components/PdfViewer/PdfViewerPage.vue.d.ts

@@ -1,22 +1,82 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "page-rendered" | "page-error" | "text-layer-rendered" | "text-layer-error" | "selection-raw" | "bypass-selection", ...args: any[]) => void;
-    page: Record<string, any>;
-    pages: unknown[];
-    config: Record<string, any>;
-    scale: number;
+import { PropType } from 'vue';
+import { PdfViewerConfig, PdfViewerPageData } from './pdf-viewer-types.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    page: {
+        type: PropType<PdfViewerPageData>;
+        required: true;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+        default: number;
+    };
+    documentEl: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "page-rendered": (...args: any[]) => void;
+    "page-error": (...args: any[]) => void;
+    "text-layer-rendered": (...args: any[]) => void;
+    "text-layer-error": (...args: any[]) => void;
+    "selection-raw": (...args: any[]) => void;
+    "bypass-selection": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    page: {
+        type: PropType<PdfViewerPageData>;
+        required: true;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+        default: number;
+    };
+    documentEl: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    "onPage-rendered"?: ((...args: any[]) => any) | undefined;
+    "onPage-error"?: ((...args: any[]) => any) | undefined;
+    "onText-layer-rendered"?: ((...args: any[]) => any) | undefined;
+    "onText-layer-error"?: ((...args: any[]) => any) | undefined;
+    "onSelection-raw"?: ((...args: any[]) => any) | undefined;
+    "onBypass-selection"?: ((...args: any[]) => any) | undefined;
+}>, {
     hasTextLayer: boolean;
     outputScale: number;
-    documentEl: Record<string, any>;
-    $props: {
-        readonly page?: Record<string, any> | undefined;
-        readonly pages?: unknown[] | undefined;
-        readonly config?: Record<string, any> | undefined;
-        readonly scale?: number | undefined;
-        readonly hasTextLayer?: boolean | undefined;
-        readonly outputScale?: number | undefined;
-        readonly documentEl?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    documentEl: HTMLElement | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     pageRef: HTMLDivElement;
     canvasRef: HTMLCanvasElement;
     textLayerRef: HTMLDivElement;

package/dist/superdoc/src/components/PdfViewer/pdf-viewer-types.d.ts

@@ -0,0 +1,45 @@
+import { Raw } from 'vue';
+import { PDFDocumentProxy, PDFPageProxy, TextLayer } from 'pdfjs-dist';
+export type PdfViewerLib = {
+    TextLayer?: typeof TextLayer;
+};
+export type PdfViewerConfig = {
+    pdfLib?: PdfViewerLib;
+    workerSrc?: string;
+    setWorker?: boolean;
+    textLayer?: boolean;
+    outputScale?: number;
+};
+export type PdfViewerDocumentData = {
+    documentId: string;
+    pdfjsDocument: Raw<PDFDocumentProxy>;
+};
+export type PdfViewerPageData = {
+    documentId: string;
+    pageId: string;
+    pageNumber: number;
+    pageIsRendered: boolean;
+    pdfjsPage: Raw<PDFPageProxy>;
+};
+export type PdfPageRenderedPayload = {
+    page: PdfViewerPageData;
+    documentId: string;
+    pageIndex: number;
+    pageNumber: number;
+    width: number;
+    height: number;
+    originalWidth: number;
+    originalHeight: number;
+};
+export type PdfSelectionBounds = {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+};
+export type PdfSelectionRawPayload = {
+    selectionBounds: PdfSelectionBounds;
+    documentId: string;
+    page: number;
+    source: 'pdf';
+};

package/dist/superdoc/src/components/Whiteboard/WhiteboardLayer.vue.d.ts

@@ -1,19 +1,84 @@
-declare const _default: import('vue').DefineComponent<{}, {
+import { PropType } from 'vue';
+import { WhiteboardPage as WhiteboardPageModel } from '../../core/whiteboard/WhiteboardPage.js';
+import { WhiteboardDropTarget, WhiteboardPageOffset, WhiteboardPageSize } from './whiteboard-types.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    whiteboard: {
+        type: PropType<WhiteboardDropTarget>;
+        required: true;
+    };
+    pages: {
+        type: PropType<WhiteboardPageModel[]>;
+        default: () => never[];
+    };
+    pageSizes: {
+        type: PropType<Record<number, WhiteboardPageSize>>;
+        default: () => {};
+    };
+    pageOffsets: {
+        type: PropType<Record<number, WhiteboardPageOffset>>;
+        default: () => {};
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Pointer ownership flag, separate from `enabled` (which controls show + Konva
+     * interactivity). When the whiteboard surface overlays a PDF, the host passes
+     * `interactive` so a visible-but-inert whiteboard layer never swallows PDF text
+     * selection or PDF comment selection. Defaults to `enabled` to preserve the
+     * legacy single-flag behavior when a host does not provide an explicit value.
+     */
+    interactive: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    opacity: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    whiteboard: {
+        type: PropType<WhiteboardDropTarget>;
+        required: true;
+    };
+    pages: {
+        type: PropType<WhiteboardPageModel[]>;
+        default: () => never[];
+    };
+    pageSizes: {
+        type: PropType<Record<number, WhiteboardPageSize>>;
+        default: () => {};
+    };
+    pageOffsets: {
+        type: PropType<Record<number, WhiteboardPageOffset>>;
+        default: () => {};
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Pointer ownership flag, separate from `enabled` (which controls show + Konva
+     * interactivity). When the whiteboard surface overlays a PDF, the host passes
+     * `interactive` so a visible-but-inert whiteboard layer never swallows PDF text
+     * selection or PDF comment selection. Defaults to `enabled` to preserve the
+     * legacy single-flag behavior when a host does not provide an explicit value.
+     */
+    interactive: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    opacity: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
     enabled: boolean;
     opacity: number;
-    pages: unknown[];
-    whiteboard: Record<string, any>;
-    pageSizes: Record<string, any>;
-    pageOffsets: Record<string, any>;
-    interactive: boolean;
-    $props: {
-        readonly enabled?: boolean | undefined;
-        readonly opacity?: number | undefined;
-        readonly pages?: unknown[] | undefined;
-        readonly whiteboard?: Record<string, any> | undefined;
-        readonly pageSizes?: Record<string, any> | undefined;
-        readonly pageOffsets?: Record<string, any> | undefined;
-        readonly interactive?: boolean | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    pages: WhiteboardPageModel[];
+    pageSizes: Record<number, WhiteboardPageSize>;
+    pageOffsets: Record<number, WhiteboardPageOffset>;
+    interactive: boolean | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;