superdoc 2.2.0 → 2.3.0

package/dist/superdoc/src/SuperDoc.vue.d.ts

@@ -0,0 +1,88 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "selection-update", ...args: any[]) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    superdocRoot: HTMLDivElement;
+    layers: HTMLDivElement;
+    selectionLayer: HTMLDivElement;
+    pdfViewerRef: (import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        updateScale: (nextScale: any) => void;
+        $emit: (event: "page-rendered" | "selection-raw" | "bypass-selection" | "pages-loaded" | "document-loaded" | "document-ready" | "document-error", ...args: any[]) => void;
+        config: Record<string, any>;
+        file: Record<string, any>;
+        initialScale: number;
+        fileId?: string | undefined;
+        $props: {
+            readonly config?: Record<string, any> | undefined;
+            readonly file?: Record<string, any> | undefined;
+            readonly initialScale?: number | undefined;
+            readonly fileId?: string | undefined;
+        };
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        rootRef: HTMLDivElement;
+        documentRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+            $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
+            config: Record<string, any>;
+            pages: unknown[];
+            hasTextLayer: boolean;
+            pdf?: Record<string, any> | undefined;
+            scale?: number | undefined;
+            outputScale?: number | undefined;
+            $props: {
+                readonly config?: Record<string, any> | undefined;
+                readonly pages?: unknown[] | undefined;
+                readonly hasTextLayer?: boolean | undefined;
+                readonly pdf?: Record<string, any> | undefined;
+                readonly scale?: number | undefined;
+                readonly outputScale?: number | undefined;
+            };
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            documentRef: HTMLDivElement;
+            documentWrapper: HTMLDivElement;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {
+            $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
+            config: Record<string, any>;
+            pages: unknown[];
+            hasTextLayer: boolean;
+            pdf?: Record<string, any> | undefined;
+            scale?: number | undefined;
+            outputScale?: number | undefined;
+            $props: {
+                readonly config?: Record<string, any> | undefined;
+                readonly pages?: unknown[] | undefined;
+                readonly hasTextLayer?: boolean | undefined;
+                readonly pdf?: Record<string, any> | undefined;
+                readonly scale?: number | undefined;
+                readonly outputScale?: number | undefined;
+            };
+        }, {}, {}, {}, {}> | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        updateScale: (nextScale: any) => void;
+        $emit: (event: "page-rendered" | "selection-raw" | "bypass-selection" | "pages-loaded" | "document-loaded" | "document-ready" | "document-error", ...args: any[]) => void;
+        config: Record<string, any>;
+        file: Record<string, any>;
+        initialScale: number;
+        fileId?: string | undefined;
+        $props: {
+            readonly config?: Record<string, any> | undefined;
+            readonly file?: Record<string, any> | undefined;
+            readonly initialScale?: number | undefined;
+            readonly fileId?: string | undefined;
+        };
+    }, {}, {}, {}, {}> | null)[];
+    rightSidebarRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/cdn-entry.d.ts

@@ -0,0 +1,2 @@
+import { SuperDoc } from './core/SuperDoc.js';
+export default SuperDoc;

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

@@ -0,0 +1,62 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "resize" | "click-outside" | "ready" | "dialog-exit", ...args: any[]) => void;
+    comment: Record<string, any>;
+    autoFocus: boolean;
+    floatingInstanceId: string;
+    floatingPageIndex: number;
+    floatingPositionEntry: Record<string, any>;
+    parent?: Record<string, any> | undefined;
+    isFloatingInstanceActive?: boolean | undefined;
+    $props: {
+        readonly comment?: Record<string, any> | undefined;
+        readonly autoFocus?: boolean | undefined;
+        readonly floatingInstanceId?: string | undefined;
+        readonly floatingPageIndex?: number | undefined;
+        readonly floatingPositionEntry?: Record<string, any> | undefined;
+        readonly parent?: Record<string, any> | undefined;
+        readonly isFloatingInstanceActive?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    commentDialogElement: HTMLDivElement;
+    commentInput: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        focus: () => void;
+        $emit: (event: "focus", ...args: any[]) => void;
+        config: Record<string, any>;
+        users: unknown[];
+        isFocused: boolean;
+        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, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        inputRef: HTMLTextAreaElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        focus: () => void;
+        $emit: (event: "focus", ...args: any[]) => void;
+        config: Record<string, any>;
+        users: unknown[];
+        isFocused: boolean;
+        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;
+        };
+    }, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,26 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "resolve" | "reject" | "reopen" | "overflow-select", ...args: any[]) => void;
+    config: Record<string, any>;
+    isPendingInput: boolean;
+    isActive: boolean;
+    resolveDisabledReason: string;
+    rejectDisabledReason: string;
+    reopenDisabledReason: string;
+    reopenSupported: boolean;
+    writeDisabledReason: string;
+    timestamp?: number | undefined;
+    comment?: Record<string, any> | 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 timestamp?: number | undefined;
+        readonly comment?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,19 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    focus: () => void;
+    $emit: (event: "focus", ...args: any[]) => void;
+    config: Record<string, any>;
+    users: unknown[];
+    isFocused: boolean;
+    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, {
+    inputRef: HTMLTextAreaElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,30 @@
+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 = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLDivElement;
+        menuRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};

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

@@ -0,0 +1,10 @@
+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;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/CommentsLayer/collect-removed-comment-ids.d.ts

@@ -0,0 +1 @@
+export function collectRemovedCommentIds(comments: ReadonlyArray<Record<string, any>>, targetIds: ReadonlyArray<string>, isInScope?: (comment: Record<string, any>) => boolean): Set<string>;

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

@@ -0,0 +1,6 @@
+export function collectTrackedChangeThread<Comment extends {
+    commentId: string;
+    parentCommentId?: string | null;
+    threadingParentCommentId?: string | null;
+    trackedChangeThreadParentId?: string | null;
+}>(parentComment: Comment, allComments: ReadonlyArray<Comment>): Array<Comment>;

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

@@ -0,0 +1,18 @@
+export namespace conversation {
+    let conversationId: null;
+    let documentId: null;
+    let creatorId: null;
+    let creatorEmail: null;
+    let creatorName: null;
+    let comments: never[];
+    let selection: null;
+}
+export namespace comment {
+    let comment: null;
+    namespace user {
+        let id: null;
+        let name: null;
+        let email: null;
+    }
+    let timestamp: null;
+}

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

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    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, {}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/CommentsLayer/commentsList/super-comments-list.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'eventemitter3';
+/**
+ * Comments list renderer (not floating comments)
+ *
+ * This renders a list of comments into an element, connected to main SuperDoc instance
+ */
+export class SuperComments extends EventEmitter<string | symbol, any> {
+    constructor(options: any, superdoc: any);
+    element: any;
+    config: {
+        comments: never[];
+        element: null;
+        commentsStore: null;
+    };
+    app: import('vue').App<Element> | null;
+    superdoc: any;
+    createVueApp(): void;
+    container: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null | undefined;
+    close(): void;
+    open(): void;
+}

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

@@ -0,0 +1,28 @@
+export function isPersistentReviewSidebarItem(comment: any): boolean;
+export function normalizeFloatingAnchorTop(top: any): any;
+export function isAnchorOutsideFloatingViewport(anchorTop: any, viewportTop: any, viewportBottom: any, anchorBottom?: any): boolean;
+export function shouldKeepPersistentReviewCardAtAnchor({ comment, anchorTop, anchorBottom, viewportTop, viewportBottom, }: {
+    comment: any;
+    anchorTop: any;
+    anchorBottom: any;
+    viewportTop: any;
+    viewportBottom: any;
+}): boolean;
+export function resolvePersistentReviewCardTop({ comment, anchorTop, anchorBottom, cardHeight, viewportTop, viewportBottom, }: {
+    comment: any;
+    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 }: {
+    previousIds: readonly string[];
+    currentIds: ReadonlySet<string>;
+    removedId: string;
+}): string | null;

package/dist/superdoc/src/components/CommentsLayer/helpers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Comments helper to format dates from timestamp
+ *
+ * @param {Number} timestamp The timestamp to format
+ * @returns {String} The formatted date
+ */
+export function formatDate(timestamp: number): string;

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

@@ -0,0 +1,2 @@
+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/types.d.ts

@@ -0,0 +1,3 @@
+export type Comment = import('../../../../../shared/common').Comment;
+export type CommentContent = import('../../../../../shared/common').CommentContent;
+export type CommentJSON = import('../../../../../shared/common').CommentJSON;

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

@@ -0,0 +1,8 @@
+/**
+ * Comment composable
+ *
+ * @param {Object} params The initial values of the comment
+ * @returns {Object} The comment composable
+ */
+export default function useComment(params: Object): Object;
+export const COMMENT_RECONCILIATION_TOKEN: unique symbol;

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

@@ -0,0 +1,22 @@
+export default function useConversation(params: any): {
+    getValues: () => Object;
+    markDone: (email: any, name: any) => void;
+    conversationId: any;
+    thread: import('vue').Ref<any, any>;
+    documentId: any;
+    creatorEmail: any;
+    creatorName: any;
+    comments: import('vue').Ref<any, any>;
+    selection: any;
+    markedDone: import('vue').Ref<any, any>;
+    markedDoneByEmail: import('vue').Ref<any, any>;
+    markedDoneByName: import('vue').Ref<any, any>;
+    isFocused: import('vue').Ref<any, any>;
+    group: import('vue').Ref<null, null>;
+    conversationElement: import('vue').Ref<null, null>;
+    suppressHighlight: import('vue').Ref<any, any>;
+    suppressClick: import('vue').Ref<any, any>;
+    isInternal: import('vue').Ref<any, any>;
+    isTrackedChange: import('vue').Ref<any, any>;
+    trackedChange: any;
+};

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

@@ -0,0 +1,11 @@
+export function useFloatingComment(params: any): {
+    id: any;
+    comment: import('vue').Ref<any, any>;
+    position: {
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+    };
+    offset: import('vue').Ref<number, number>;
+};

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

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "ready" | "selection-change", ...args: any[]) => void;
+    documentId: string;
+    fileSource: File | Blob;
+    $props: {
+        readonly documentId?: string | undefined;
+        readonly fileSource?: File | Blob | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,61 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    updateScale: typeof updateScale;
+    $emit: (event: "page-rendered" | "selection-raw" | "bypass-selection" | "pages-loaded" | "document-loaded" | "document-ready" | "document-error", ...args: any[]) => void;
+    config: Record<string, any>;
+    file: Record<string, any>;
+    initialScale: number;
+    fileId?: string | undefined;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+        readonly file?: 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, {
+    rootRef: HTMLDivElement;
+    documentRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
+        config: Record<string, any>;
+        pages: unknown[];
+        hasTextLayer: boolean;
+        pdf?: Record<string, any> | undefined;
+        scale?: number | undefined;
+        outputScale?: number | undefined;
+        $props: {
+            readonly config?: Record<string, any> | undefined;
+            readonly pages?: unknown[] | undefined;
+            readonly hasTextLayer?: boolean | undefined;
+            readonly pdf?: Record<string, any> | undefined;
+            readonly scale?: number | undefined;
+            readonly outputScale?: number | undefined;
+        };
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        documentRef: HTMLDivElement;
+        documentWrapper: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
+        config: Record<string, any>;
+        pages: unknown[];
+        hasTextLayer: boolean;
+        pdf?: Record<string, any> | undefined;
+        scale?: number | undefined;
+        outputScale?: number | undefined;
+        $props: {
+            readonly config?: Record<string, any> | undefined;
+            readonly pages?: unknown[] | undefined;
+            readonly hasTextLayer?: boolean | undefined;
+            readonly pdf?: Record<string, any> | undefined;
+            readonly scale?: number | undefined;
+            readonly outputScale?: number | undefined;
+        };
+    }, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+export default _default;
+declare function updateScale(nextScale: any): void;

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

@@ -0,0 +1,21 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
+    config: Record<string, any>;
+    pages: unknown[];
+    hasTextLayer: boolean;
+    pdf?: Record<string, any> | undefined;
+    scale?: number | undefined;
+    outputScale?: number | undefined;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+        readonly pages?: unknown[] | undefined;
+        readonly hasTextLayer?: boolean | undefined;
+        readonly pdf?: Record<string, any> | undefined;
+        readonly scale?: number | undefined;
+        readonly outputScale?: number | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    documentRef: HTMLDivElement;
+    documentWrapper: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,24 @@
+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;
+    config: Record<string, any>;
+    page: Record<string, any>;
+    pages: unknown[];
+    scale: number;
+    hasTextLayer: boolean;
+    outputScale: number;
+    documentEl: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+        readonly page?: Record<string, any> | undefined;
+        readonly pages?: unknown[] | 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, {
+    pageRef: HTMLDivElement;
+    canvasRef: HTMLCanvasElement;
+    textLayerRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,19 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    opacity: number;
+    enabled: boolean;
+    pages: unknown[];
+    whiteboard: Record<string, any>;
+    pageSizes: Record<string, any>;
+    pageOffsets: Record<string, any>;
+    interactive: boolean;
+    $props: {
+        readonly opacity?: number | undefined;
+        readonly enabled?: boolean | 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>;
+export default _default;

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

@@ -0,0 +1,17 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    page: Record<string, any>;
+    enabled: boolean;
+    whiteboard: Record<string, any>;
+    pageSize: Record<string, any>;
+    pageOffset: Record<string, any>;
+    $props: {
+        readonly page?: Record<string, any> | undefined;
+        readonly enabled?: boolean | 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, {
+    containerRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,18 @@
+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;
+    updateWhiteboardPageSizes: () => void;
+    updateWhiteboardPageOffsets: () => void;
+};

package/dist/superdoc/src/components/surfaces/FindReplaceSurface.vue.d.ts

@@ -0,0 +1,19 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    close: Function;
+    resolve: Function;
+    request: Record<string, any>;
+    mode: string;
+    surfaceId: string;
+    findReplace: Record<string, any>;
+    $props: {
+        readonly close?: Function | undefined;
+        readonly resolve?: Function | undefined;
+        readonly request?: Record<string, any> | undefined;
+        readonly mode?: string | undefined;
+        readonly surfaceId?: string | undefined;
+        readonly findReplace?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    findInputRef: HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/surfaces/PasswordPromptSurface.vue.d.ts

@@ -0,0 +1,17 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    close: Function;
+    resolve: Function;
+    request: Record<string, any>;
+    mode: string;
+    surfaceId: string;
+    passwordPrompt: Record<string, any>;
+    $props: {
+        readonly close?: Function | undefined;
+        readonly resolve?: Function | undefined;
+        readonly request?: Record<string, any> | undefined;
+        readonly mode?: string | undefined;
+        readonly surfaceId?: string | undefined;
+        readonly passwordPrompt?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/surfaces/SurfaceDialog.vue.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "close", ...args: any[]) => void;
+    surface: Record<string, any>;
+    scrollLockTarget: Record<string, any>;
+    $props: {
+        readonly surface?: Record<string, any> | undefined;
+        readonly scrollLockTarget?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    dialogRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;