superdoc 2.28.0 → 2.29.0-next.13

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;

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

@@ -1,17 +1,53 @@
-declare const _default: import('vue').DefineComponent<{}, {
+import { PropType } from 'vue';
+import { WhiteboardPage } 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;
+    };
+    page: {
+        type: PropType<WhiteboardPage>;
+        required: true;
+    };
+    pageSize: {
+        type: PropType<WhiteboardPageSize | null>;
+        default: null;
+    };
+    pageOffset: {
+        type: PropType<WhiteboardPageOffset | null>;
+        default: null;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    whiteboard: {
+        type: PropType<WhiteboardDropTarget>;
+        required: true;
+    };
+    page: {
+        type: PropType<WhiteboardPage>;
+        required: true;
+    };
+    pageSize: {
+        type: PropType<WhiteboardPageSize | null>;
+        default: null;
+    };
+    pageOffset: {
+        type: PropType<WhiteboardPageOffset | null>;
+        default: null;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
     enabled: boolean;
-    page: Record<string, any>;
-    whiteboard: Record<string, any>;
-    pageSize: Record<string, any>;
-    pageOffset: Record<string, any>;
-    $props: {
-        readonly enabled?: boolean | undefined;
-        readonly page?: Record<string, any> | undefined;
-        readonly whiteboard?: Record<string, any> | undefined;
-        readonly pageSize?: Record<string, any> | undefined;
-        readonly pageOffset?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    pageSize: WhiteboardPageSize | null;
+    pageOffset: WhiteboardPageOffset | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     containerRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/Whiteboard/use-whiteboard.d.ts

@@ -1,18 +1,33 @@
-export function useWhiteboard({ proxy, layers, documents, modules }: {
-    proxy: any;
-    layers: any;
-    documents: any;
-    modules: any;
-}): {
-    whiteboard: any;
-    whiteboardModuleConfig: import('vue').ComputedRef<any>;
-    whiteboardPages: import('vue').ShallowRef<never[], never[]>;
-    whiteboardPageSizes: {};
-    whiteboardPageOffsets: {};
-    whiteboardEnabled: import('vue').Ref<any, any>;
-    whiteboardOpacity: import('vue').Ref<number, number>;
-    whiteboardReady: import('vue').Ref<boolean, boolean>;
-    handleWhiteboardPageReady: (payload: any) => void;
+import { Ref } from 'vue';
+import { SuperDoc } from '../../core/SuperDoc.js';
+import { Document, Modules } from '../../core/types/index.js';
+import { WhiteboardPageSize } from '../../core/whiteboard/Whiteboard.js';
+import { WhiteboardPage } from '../../core/whiteboard/WhiteboardPage.js';
+import { PdfPageRenderedPayload } from '../PdfViewer/pdf-viewer-types.js';
+import { WhiteboardPageOffset } from './whiteboard-types.js';
+type WhiteboardDocument = Pick<Document, 'id' | 'type'>;
+type WhiteboardPageReadyPayload = Pick<PdfPageRenderedPayload, 'pageIndex' | 'width' | 'height' | 'originalWidth' | 'originalHeight'>;
+export type UseWhiteboardOptions = {
+    proxy: {
+        $superdoc: Pick<SuperDoc, 'emit' | 'whiteboard'>;
+    };
+    layers: Ref<HTMLElement | null>;
+    documents: Ref<WhiteboardDocument[]>;
+    modules: Modules;
+};
+export declare const useWhiteboard: ({ proxy, layers, documents, modules }: UseWhiteboardOptions) => {
+    whiteboard: import('../../core/whiteboard/Whiteboard.js').Whiteboard | null;
+    whiteboardModuleConfig: import('vue').ComputedRef<{
+        enabled?: boolean;
+    } | null>;
+    whiteboardPages: import('vue').ShallowRef<WhiteboardPage[], WhiteboardPage[]>;
+    whiteboardPageSizes: Record<number, WhiteboardPageSize>;
+    whiteboardPageOffsets: Record<number, WhiteboardPageOffset>;
+    whiteboardEnabled: Ref<boolean, boolean>;
+    whiteboardOpacity: Ref<number, number>;
+    whiteboardReady: Ref<boolean, boolean>;
+    handleWhiteboardPageReady: (payload: WhiteboardPageReadyPayload | null | undefined) => void;
     updateWhiteboardPageSizes: () => void;
     updateWhiteboardPageOffsets: () => void;
 };
+export {};

package/dist/superdoc/src/components/Whiteboard/whiteboard-types.d.ts

@@ -0,0 +1,11 @@
+import { Whiteboard } from '../../core/whiteboard/Whiteboard.js';
+export type WhiteboardPageSize = {
+    width: number;
+    height: number;
+    originalWidth?: number | null;
+};
+export type WhiteboardPageOffset = {
+    top: number;
+    left: number;
+};
+export type WhiteboardDropTarget = Pick<Whiteboard, 'getTool' | 'getType'>;

package/dist/superdoc/src/components/general/Avatar.vue.d.ts

@@ -0,0 +1,14 @@
+import { PropType } from 'vue';
+import { User } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    user: {
+        type: PropType<User>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    user: {
+        type: PropType<User>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;