@jacktea/pdf-viewer-core 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,1092 @@
+type DocumentSource = {
+    type: "url";
+    url: string;
+    headers?: Record<string, string>;
+} | {
+    type: "data";
+    data: Uint8Array | ArrayBuffer;
+};
+interface PdfOutlineEntry {
+    title?: string;
+    dest?: unknown;
+    items?: PdfOutlineEntry[];
+}
+type DocumentSourceRef = {
+    type: "url";
+    url: string;
+} | {
+    type: "data";
+};
+declare function toDocumentSourceRef(source: DocumentSource): DocumentSourceRef;
+interface PdfPageHandle {
+    getViewport: (params: {
+        scale: number;
+        rotation?: number;
+    }) => {
+        width: number;
+        height: number;
+    };
+    rotate?: number;
+}
+interface PdfDocumentHandle {
+    numPages: number;
+    getPage(pageNumber: number): Promise<PdfPageHandle>;
+    getOutline?: () => Promise<PdfOutlineEntry[] | null>;
+    getDestination?: (dest: string) => Promise<unknown>;
+    getPageIndex?: (ref: unknown) => Promise<number>;
+    getMetadata?: () => Promise<unknown>;
+    getData?: () => Promise<Uint8Array | ArrayBuffer>;
+    destroy?: () => void;
+}
+interface PdfMetadata {
+    title?: string;
+    author?: string;
+    subject?: string;
+    keywords?: string;
+    creator?: string;
+    producer?: string;
+    creationDate?: string;
+    modDate?: string;
+    pdfVersion?: string;
+}
+interface UserInfo {
+    id: string;
+    name?: string;
+    color?: string;
+    avatarUrl?: string;
+    avatar?: string;
+    role?: "admin" | "user" | "viewer" | string;
+}
+
+type PdfPasswordRequestReason = "need-password" | "incorrect-password" | "unknown";
+interface PdfLoaderOptions {
+    cMapUrl?: string;
+    cMapPacked?: boolean;
+    standardFontDataUrl?: string;
+    wasmUrl?: string;
+    password?: string;
+    onPasswordRequest?: (reason: PdfPasswordRequestReason) => Promise<string | null> | string | null;
+    passwordCancelErrorMessage?: string;
+}
+interface PdfJsGetDocument {
+    (source: {
+        url?: string;
+        data?: Uint8Array | ArrayBuffer;
+        httpHeaders?: Record<string, string>;
+        cMapUrl?: string;
+        cMapPacked?: boolean;
+        standardFontDataUrl?: string;
+        wasmUrl?: string;
+        password?: string;
+    }): {
+        promise: Promise<PdfDocumentHandle>;
+    } | Promise<PdfDocumentHandle>;
+}
+type PdfLoader = (source: DocumentSource) => Promise<PdfDocumentHandle>;
+declare function createPdfLoader(getDocument: PdfJsGetDocument, options?: PdfLoaderOptions | (() => PdfLoaderOptions)): PdfLoader;
+
+interface PageMoveResult {
+    from: number;
+    to: number;
+}
+interface PageDeleteResult {
+    visibleIndex: number;
+    sourceIndex: number;
+}
+declare class PageManager {
+    private order;
+    constructor(pageCount: number);
+    getPageCount(): number;
+    getOrder(): number[];
+    deletePage(visibleIndex: number): PageDeleteResult | undefined;
+    insertPage(visibleIndex: number, sourceIndex: number): void;
+    movePage(fromIndex: number, toIndex: number): PageMoveResult | undefined;
+}
+
+declare function exportPdf(sourceData: Uint8Array, pageOrder: number[]): Promise<Uint8Array>;
+
+interface OutlineNode {
+    title: string;
+    pageIndex?: number;
+    children: OutlineNode[];
+}
+declare function extractPdfOutline(doc: PdfDocumentHandle): Promise<OutlineNode[]>;
+
+interface ThumbnailDescriptor {
+    pageIndex: number;
+    width: number;
+    height: number;
+    viewportScale: number;
+    rotation: number;
+}
+interface ThumbnailOptions {
+    scale?: number;
+}
+declare function extractPdfThumbnails(doc: PdfDocumentHandle, options?: ThumbnailOptions): Promise<ThumbnailDescriptor[]>;
+
+interface UndoableCommand {
+    execute(): boolean;
+    undo(): void;
+}
+
+interface NormalizedPoint {
+    x: number;
+    y: number;
+}
+interface NormalizedRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type AnnotationGeometry = {
+    kind: "rect";
+    rect: NormalizedRect;
+} | {
+    kind: "ellipse";
+    rect: NormalizedRect;
+} | {
+    kind: "path";
+    points: NormalizedPoint[];
+} | {
+    kind: "point";
+    point: NormalizedPoint;
+};
+declare function clampNormalizedPoint(point: NormalizedPoint): NormalizedPoint;
+declare function clampNormalizedRect(rect: NormalizedRect): NormalizedRect;
+
+interface AnnotationStyle {
+    strokeColor: string;
+    strokeWidth: number;
+    fillColor?: string;
+    fillOpacity?: number;
+    opacity?: number;
+    lineCap?: "round" | "butt" | "square";
+    lineJoin?: "round" | "miter" | "bevel";
+    dash?: "solid" | "dash" | "dot";
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: number | string;
+    arrowStyle?: "none" | "standard" | "tapered" | "hollow";
+}
+declare const DEFAULT_ANNOTATION_STYLE: AnnotationStyle;
+
+type PermissionAction = "annotation.view" | "annotation.create" | "annotation.update" | "annotation.delete" | "annotation.comment.create" | "comment.view" | "comment.update" | "comment.delete" | "comment.reply" | "thread.resolve" | "thread.reopen";
+type PermissionEffect = "allow" | "deny";
+interface PrincipalInfo {
+    userId: string;
+    roles: string[];
+}
+interface PolicyRule {
+    effect: PermissionEffect;
+    actions: PermissionAction[] | "*";
+    roles?: string[];
+    users?: string[];
+    owner?: boolean;
+}
+interface PolicySet {
+    rules: PolicyRule[];
+}
+interface ResourcePolicyOverride {
+    rules: PolicyRule[];
+}
+interface PermissionContext {
+    previewMode: boolean;
+    ownerId?: string;
+}
+interface PermissionEvaluationInput {
+    action: PermissionAction;
+    principal: PrincipalInfo;
+    globalPolicy: PolicySet;
+    resourcePolicy?: ResourcePolicyOverride;
+    context: PermissionContext;
+}
+type PermissionDenyReason = "preview_mode" | "resource_explicit_deny" | "global_explicit_deny" | "no_matching_allow";
+interface PermissionDecision {
+    allowed: boolean;
+    reason?: PermissionDenyReason;
+    source?: "preview" | "resource" | "global" | "default";
+}
+interface AnnotationCapabilities {
+    view: boolean;
+    update: boolean;
+    delete: boolean;
+    commentCreate: boolean;
+    resolveThread: boolean;
+    reopenThread: boolean;
+}
+interface CommentCapabilities {
+    view: boolean;
+    update: boolean;
+    delete: boolean;
+    reply: boolean;
+}
+interface DocumentCapabilities {
+    annotationCreate: boolean;
+    setMode: boolean;
+}
+interface ThreadCapabilities {
+    resolve: boolean;
+    reopen: boolean;
+}
+type DocumentMode = "normal" | "preview";
+
+declare function evaluatePermission(input: PermissionEvaluationInput): PermissionDecision;
+
+declare const DEFAULT_PERMISSION_POLICY: PolicySet;
+
+type AnnotationType = "highlight" | "underline" | "strike" | "draw" | "rect" | "ellipse" | "text" | "arrow";
+interface AnnotationMetadata {
+    authorId?: string;
+    authorName?: string;
+    createdAt: number;
+    updatedAt?: number;
+    content?: string;
+    code?: string;
+    status?: "open" | "resolved";
+    acl?: ResourcePolicyOverride;
+}
+interface Annotation {
+    id: string;
+    pageIndex: number;
+    type: AnnotationType;
+    geometry: AnnotationGeometry;
+    style: AnnotationStyle;
+    metadata: AnnotationMetadata;
+    capabilities?: AnnotationCapabilities;
+}
+
+type AnnotationStoreChangeType = "add" | "update" | "remove" | "replace";
+interface AnnotationStoreChange {
+    type: AnnotationStoreChangeType;
+    annotation?: Annotation;
+    previous?: Annotation;
+    annotations: Annotation[];
+}
+type AnnotationStoreListener = (change: AnnotationStoreChange) => void;
+declare class AnnotationStore {
+    private annotations;
+    private listeners;
+    getAll(): Annotation[];
+    getById(id: string): Annotation | undefined;
+    getByPage(pageIndex: number): Annotation[];
+    subscribe(listener: AnnotationStoreListener): () => void;
+    replaceAll(annotations: Annotation[]): void;
+    applyAdd(annotation: Annotation): boolean;
+    applyUpdate(next: Annotation): boolean;
+    applyRemove(id: string): Annotation | undefined;
+    private emit;
+    private updateAnnotationAt;
+}
+
+declare class AddAnnotationCommand implements UndoableCommand {
+    private store;
+    private annotation;
+    constructor(store: AnnotationStore, annotation: Annotation);
+    execute(): boolean;
+    undo(): void;
+}
+
+declare class DeletePageCommand implements UndoableCommand {
+    private manager;
+    private pageIndex;
+    private lastDeleted?;
+    constructor(manager: PageManager, pageIndex: number);
+    execute(): boolean;
+    undo(): void;
+}
+
+declare class RemoveAnnotationCommand implements UndoableCommand {
+    private store;
+    private annotationId;
+    private removed?;
+    constructor(store: AnnotationStore, annotationId: string);
+    execute(): boolean;
+    undo(): void;
+}
+
+declare class ReorderPageCommand implements UndoableCommand {
+    private manager;
+    private fromIndex;
+    private toIndex;
+    private lastMove?;
+    constructor(manager: PageManager, fromIndex: number, toIndex: number);
+    execute(): boolean;
+    undo(): void;
+}
+
+declare class UpdateAnnotationCommand implements UndoableCommand {
+    private store;
+    private next;
+    private previous?;
+    constructor(store: AnnotationStore, next: Annotation);
+    execute(): boolean;
+    undo(): void;
+}
+
+interface UndoManagerOptions {
+    /** Maximum number of commands to keep in the undo stack (default: 100) */
+    maxStackSize?: number;
+}
+declare class UndoManager {
+    private readonly maxStackSize;
+    private undoStack;
+    private redoStack;
+    constructor(options?: UndoManagerOptions);
+    execute(command: UndoableCommand): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    reset(): void;
+    /** Get the current size of the undo stack */
+    getUndoStackSize(): number;
+    /** Get the current size of the redo stack */
+    getRedoStackSize(): number;
+    /** Get the maximum stack size */
+    getMaxStackSize(): number;
+}
+
+interface CommentContent {
+    text: string;
+    html?: string;
+    imgs?: string[];
+    imgRefs?: string[];
+}
+interface AnnotationComment {
+    id: string;
+    targetAnnotationId: string;
+    authorId: string;
+    authorName?: string;
+    content: CommentContent;
+    parentId?: string;
+    createdAt: number;
+    updatedAt?: number;
+    code?: string;
+    acl?: ResourcePolicyOverride;
+    capabilities?: CommentCapabilities;
+}
+
+type CommentThreadStatus = "open" | "resolved";
+interface CommentThread {
+    id: string;
+    targetAnnotationId: string;
+    /**
+     * @deprecated Reserved for future use only.
+     * Current business status is managed by Annotation.metadata.status.
+     */
+    status?: CommentThreadStatus;
+    comments: AnnotationComment[];
+    /**
+     * @deprecated Reserved for future use only.
+     * Current business status is managed by Annotation.metadata.status.
+     */
+    capabilities?: ThreadCapabilities;
+}
+
+type CommentStoreChangeType = "add" | "update" | "remove" | "replace";
+interface CommentStoreChange {
+    type: CommentStoreChangeType;
+    thread?: CommentThread;
+    comment?: AnnotationComment;
+    previous?: AnnotationComment;
+    threads: CommentThread[];
+}
+type CommentStoreListener = (change: CommentStoreChange) => void;
+declare class CommentStore {
+    private threadsByAnnotation;
+    private listeners;
+    getThreads(): CommentThread[];
+    getThreadByAnnotationId(annotationId: string): CommentThread | undefined;
+    subscribe(listener: CommentStoreListener): () => void;
+    replaceAll(threads: CommentThread[]): void;
+    ensureThread(annotationId: string): CommentThread;
+    addComment(comment: AnnotationComment): CommentThread;
+    updateComment(next: AnnotationComment): CommentThread | undefined;
+    removeComment(annotationId: string, commentId: string): CommentThread | undefined;
+    /**
+     * @deprecated Reserved for future extension.
+     * Thread status is not managed in current business rules.
+     */
+    resolveThread(annotationId: string): CommentThread | undefined;
+    /**
+     * @deprecated Reserved for future extension.
+     * Thread status is not managed in current business rules.
+     */
+    reopenThread(annotationId: string): CommentThread | undefined;
+    private emit;
+    private createThread;
+    private cloneThread;
+    private addCommentToThread;
+    private updateCommentInThread;
+    private findCommentById;
+    private removeCommentFromThread;
+}
+
+type Rotation = 0 | 90 | 180 | 270;
+type ViewerStatus = "idle" | "loading" | "ready" | "error";
+type ScaleMode = "page" | "width" | "actual";
+interface ViewerState {
+    page: number;
+    pageCount: number;
+    pageOrder: number[];
+    canUndo: boolean;
+    canRedo: boolean;
+    scale: number;
+    scaleMode: ScaleMode;
+    rotation: Rotation;
+    status: ViewerStatus;
+    outline: OutlineNode[];
+    thumbnails: ThumbnailDescriptor[];
+    source?: DocumentSourceRef;
+    error?: string;
+}
+declare const DEFAULT_VIEWER_STATE: ViewerState;
+declare function clampPage(page: number, pageCount: number): number;
+declare function clampScale(scale: number, minScale: number, maxScale: number): number;
+declare function normalizeRotation(rotation: number): Rotation;
+
+type ViewerListener = (state: ViewerState) => void;
+
+type TemplatePlaceholderType = "text" | "image";
+interface TemplateStyle {
+    rotation: number;
+    opacity?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: number | string;
+    fontColor?: string;
+    textAlign?: "left" | "center" | "right";
+}
+interface BusinessField {
+    key: string;
+    label: string;
+    type: TemplatePlaceholderType;
+    defaultValue?: any;
+}
+interface TemplateElement {
+    id: string;
+    key: string;
+    value: any;
+    type: TemplatePlaceholderType;
+    pageIndex: number;
+    geometry: NormalizedRect;
+    style: TemplateStyle;
+    renderPolicy: TemplateRenderPolicy;
+}
+interface TemplateRenderPolicy {
+    mode: "single" | "all-pages" | "range" | "seam";
+    pageRange?: {
+        start?: number;
+        end?: number;
+    };
+    seam?: {
+        direction: "vertical" | "horizontal";
+        align: "center" | "left" | "right";
+        overlapRatio?: number;
+    };
+}
+
+declare class TemplateManager {
+    private fields;
+    private elements;
+    constructor();
+    /**
+     * Load business schema fields
+     */
+    loadBusinessSchema(fields: BusinessField[]): void;
+    /**
+     * Get all available business fields
+     */
+    getFields(): BusinessField[];
+    /**
+     * Add a new element to the template
+     */
+    addElement(element: TemplateElement): void;
+    /**
+     * Update an existing element
+     */
+    updateElement(element: TemplateElement): void;
+    /**
+     * Remove an element by ID
+     */
+    removeElement(id: string): void;
+    /**
+     * Get all elements
+     */
+    getElements(): TemplateElement[];
+    /**
+     * Get elements for a specific page
+     */
+    getElementsByPage(pageIndex: number): TemplateElement[];
+    /**
+     * Get element by ID
+     */
+    getElement(id: string): TemplateElement | undefined;
+}
+
+interface ViewerControllerOptions {
+    loader: PdfLoader;
+    minScale?: number;
+    maxScale?: number;
+    zoomStep?: number;
+    initialScale?: number;
+    initialScaleMode?: ScaleMode;
+    initialRotation?: Rotation;
+    maxUndoStackSize?: number;
+}
+declare class ViewerController {
+    private templateManager;
+    private state;
+    private listeners;
+    private doc?;
+    private pageManager?;
+    private readonly undoManager;
+    private annotationStore;
+    private commentStore;
+    private loadToken;
+    private readonly loader;
+    private readonly minScale;
+    private readonly maxScale;
+    private readonly zoomStep;
+    private readonly initialScale;
+    private readonly initialRotation;
+    constructor(options: ViewerControllerOptions);
+    loadDocument(source: DocumentSource): Promise<void>;
+    getDocument(): PdfDocumentHandle | undefined;
+    getTemplateManager(): TemplateManager;
+    setPage(page: number): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    rotate(): void;
+    setScale(scale: number): void;
+    setRotation(rotation: number): void;
+    setScaleMode(scaleMode: ScaleMode): void;
+    getState(): ViewerState;
+    getAnnotationStore(): AnnotationStore;
+    getCommentStore(): CommentStore;
+    setAnnotations(annotations: Annotation[]): void;
+    setCommentThreads(threads: CommentThread[]): void;
+    subscribe(listener: ViewerListener): () => void;
+    destroy(): void;
+    syncPageManager(options?: {
+        preserveOrder?: boolean;
+    }): Promise<void>;
+    deletePage(pageIndex: number): boolean;
+    movePage(fromIndex: number, toIndex: number): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    hasEditableDocumentData(): boolean;
+    exportPdf(): Promise<Uint8Array>;
+    addAnnotation(annotation: Annotation): boolean;
+    updateAnnotation(annotation: Annotation): boolean;
+    removeAnnotation(annotationId: string): boolean;
+    addComment(comment: AnnotationComment): CommentThread;
+    updateComment(comment: AnnotationComment): CommentThread | undefined;
+    removeComment(annotationId: string, commentId: string): CommentThread | undefined;
+    /**
+     * @deprecated Kept for API compatibility.
+     * Current business status is managed on annotation metadata.
+     */
+    resolveCommentThread(annotationId: string): CommentThread | undefined;
+    /**
+     * @deprecated Kept for API compatibility.
+     * Current business status is managed on annotation metadata.
+     */
+    reopenCommentThread(annotationId: string): CommentThread | undefined;
+    private setAnnotationStatus;
+    private updateState;
+    private applyPageOrderChange;
+    private updateUndoState;
+    private isValidAnnotationPage;
+    private loadSupplemental;
+}
+
+/**
+ * Position of the watermark on the page
+ */
+type WatermarkPosition = "center" | "top-left" | "top-center" | "top-right" | "middle-left" | "middle-right" | "bottom-left" | "bottom-center" | "bottom-right";
+/**
+ * Text alignment for multi-line watermarks
+ */
+type TextAlign = "left" | "center" | "right";
+/**
+ * Base watermark properties shared by all watermark types
+ */
+interface BaseWatermark {
+    /** Opacity from 0 (transparent) to 1 (opaque) */
+    opacity: number;
+    /** Rotation in degrees */
+    rotation: number;
+    /** Position on the page */
+    position: WatermarkPosition;
+}
+/**
+ * Text watermark configuration
+ */
+interface TextWatermark extends BaseWatermark {
+    type: "text";
+    /** The text content to display (supports multi-line with \n) */
+    content: string;
+    /** Font size in points */
+    fontSize: number;
+    /** Color as hex string (e.g., "#808080") */
+    color: string;
+    /** Text alignment for multi-line content */
+    textAlign: TextAlign;
+}
+/**
+ * Image watermark configuration
+ */
+interface ImageWatermark extends BaseWatermark {
+    type: "image";
+    /** Image data as Uint8Array (PNG or JPG) */
+    imageData: Uint8Array;
+    /** Image MIME type */
+    mimeType: "image/png" | "image/jpeg";
+    /** Scale factor from 0 to 1 */
+    scale: number;
+}
+/**
+ * Union type for all watermark types
+ */
+type Watermark = TextWatermark | ImageWatermark;
+/**
+ * Default text watermark settings
+ */
+declare const DEFAULT_TEXT_WATERMARK: TextWatermark;
+/**
+ * Default image watermark settings (without image data)
+ */
+declare const DEFAULT_IMAGE_WATERMARK_SETTINGS: Omit<ImageWatermark, "imageData" | "mimeType">;
+/**
+ * Parse hex color to RGB values (0-1 range)
+ */
+declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Check if text requires image rendering (non-ASCII chars or multi-line)
+ */
+declare function hasNonAsciiChars(text: string): boolean;
+
+type ImageMimeType = "image/png" | "image/jpeg";
+interface WatermarkImageUploadResult {
+    ref: string;
+    url?: string;
+}
+interface WatermarkImageLoadSource {
+    ref?: string;
+    url?: string;
+    mimeType?: ImageMimeType;
+}
+interface WatermarkImageLoadResult {
+    data: Uint8Array | ArrayBuffer | Blob;
+    mimeType?: ImageMimeType;
+}
+interface WatermarkTransferOptions {
+    uploadImage?: (image: {
+        data: Uint8Array;
+        mimeType: ImageMimeType;
+    }) => Promise<WatermarkImageUploadResult | string>;
+    loadImage?: (source: WatermarkImageLoadSource) => Promise<WatermarkImageLoadResult | Uint8Array | ArrayBuffer | Blob>;
+}
+interface PdfData {
+    version: "1.0";
+    meta?: {
+        createdAt: number;
+        source?: string;
+    };
+    watermark?: {
+        type: "text" | "image";
+        opacity: number;
+        rotation: number;
+        position: "center" | "top-left" | "top-center" | "top-right" | "middle-left" | "middle-right" | "bottom-left" | "bottom-center" | "bottom-right";
+        content?: string;
+        fontSize?: number;
+        color?: string;
+        textAlign?: "left" | "center" | "right";
+        mimeType?: "image/png" | "image/jpeg";
+        imageWidth?: number;
+        imageHeight?: number;
+        scale?: number;
+        imageDataBase64?: string;
+        imageRef?: string;
+        imageUrl?: string;
+    };
+    annotations?: Array<Annotation & {
+        commentThread?: {
+            id: string;
+            targetAnnotationId: string;
+            /**
+             * @deprecated Reserved for future use only.
+             * Current business status is managed by Annotation.metadata.status.
+             */
+            status?: "open" | "resolved";
+            comments: Array<{
+                id: string;
+                authorId: string;
+                content: CommentContent;
+                parentId?: string;
+                createdAt: number;
+                updatedAt?: number;
+            }>;
+        };
+    }>;
+    templates?: Array<TemplateElement>;
+}
+declare function watermarkToData(watermark: Watermark | null, options?: WatermarkTransferOptions): Promise<PdfData["watermark"] | undefined>;
+declare function dataToWatermark(data: PdfData["watermark"], options?: WatermarkTransferOptions): Promise<Watermark | null>;
+declare function mergeComments(annotations: Annotation[], threads: CommentThread[]): NonNullable<PdfData["annotations"]>;
+declare function extractComments(dataPermissions: NonNullable<PdfData["annotations"]>): {
+    annotations: Annotation[];
+    threads: CommentThread[];
+};
+
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Embed watermark (Text or Image) into PDF
+ *
+ * config_json examples:
+ * Text: {"type": "text", "content": "Hello", "opacity": 0.5, ...}
+ * Image: {"type": "image", "imageDataBase64": "...", ...}
+ */
+declare function embed_watermark_wasm(pdf_bytes: Uint8Array, config_json: string): Uint8Array;
+
+/**
+ * Extract specific pages from PDF
+ * page_indices should be a Uint32Array from JS side
+ */
+declare function extract_pages_wasm(pdf_bytes: Uint8Array, page_indices: Uint32Array): Uint8Array;
+
+/**
+ * Get number of pages in PDF
+ */
+declare function get_page_count_wasm(pdf_bytes: Uint8Array): number;
+
+/**
+ * Read PdfData JSON from PDF bytes
+ */
+declare function read_pdf_data_wasm(pdf_bytes: Uint8Array): any;
+
+/**
+ * Write PdfData JSON to PDF bytes
+ */
+declare function write_pdf_data_wasm(pdf_bytes: Uint8Array, json_data: string): Uint8Array;
+
+declare function loadPdfTools(): Promise<void>;
+
+interface PdfToolsModule {
+    embed_watermark_wasm: typeof embed_watermark_wasm;
+    read_pdf_data_wasm: typeof read_pdf_data_wasm;
+    write_pdf_data_wasm: typeof write_pdf_data_wasm;
+    extract_pages_wasm: typeof extract_pages_wasm;
+    get_page_count_wasm: typeof get_page_count_wasm;
+}
+
+type RemoteAnnotationChange = Omit<AnnotationStoreChange, "annotations">;
+type RemoteCommentChange = Omit<CommentStoreChange, "threads">;
+interface SyncState {
+    annotations: Annotation[];
+    comments: CommentThread[];
+    activeUsers: UserInfo[];
+    documentMode?: DocumentMode;
+}
+type RemoteChangePayload = {
+    type: "annotation";
+    change: RemoteAnnotationChange;
+} | {
+    type: "comment";
+    change: RemoteCommentChange;
+};
+type RemoteInteractionPayload = {
+    type: "drag";
+    annotationId: string;
+    geometry: AnnotationGeometry;
+    userId: string;
+} | {
+    type: "drag-end";
+    annotationId: string;
+    userId: string;
+};
+/**
+ * Connection status for collaboration providers.
+ */
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/**
+ * Type-safe event handler
+ */
+type EventHandler$1<T = unknown> = (payload: T) => void;
+interface CollaborationProvider {
+    /**
+     * Current connection status.
+     */
+    readonly status: ConnectionStatus;
+    /**
+     * Connect to the collaboration session.
+     */
+    connect(options: {
+        documentId: string;
+        user: UserInfo;
+    }): Promise<void>;
+    /**
+     * Disconnect from the session.
+     */
+    disconnect(): void;
+    /**
+     * Destroy the provider and clean up all resources.
+     * Call this when the provider will no longer be used.
+     */
+    destroy?(): void;
+    /**
+     * Send a local annotation change to remote peers.
+     */
+    sendAnnotationChange(change: RemoteAnnotationChange): void;
+    /**
+     * Send a local comment change to remote peers.
+     */
+    sendCommentChange(change: RemoteCommentChange): void;
+    /**
+     * Send an ephemeral interaction event (e.g. drag)
+     */
+    sendInteraction(payload: RemoteInteractionPayload): void;
+    /**
+     * Subscribe to remote changes.
+     */
+    on(event: "remote:change", handler: EventHandler$1<RemoteChangePayload>): void;
+    /**
+     * Subscribe to remote interactions.
+     */
+    on(event: "remote:interaction", handler: EventHandler$1<RemoteInteractionPayload>): void;
+    /**
+     * Subscribe to initial state sync or full re-sync.
+     */
+    on(event: "sync", handler: EventHandler$1<SyncState>): void;
+    /**
+     * Subscribe to awareness updates (e.g. who is online).
+     */
+    on(event: "users:update", handler: EventHandler$1<UserInfo[]>): void;
+    /**
+     * Subscribe to connection status changes.
+     */
+    on(event: "status:change", handler: EventHandler$1<ConnectionStatus>): void;
+    /**
+     * Subscribe to connection errors.
+     */
+    on(event: "error", handler: EventHandler$1<Error>): void;
+    /**
+     * Subscribe to collaboration document mode changes.
+     */
+    on(event: "document:mode:changed", handler: EventHandler$1<DocumentMode>): void;
+    /**
+     * Set collaboration document mode for the current room.
+     */
+    setDocumentMode?(mode: DocumentMode): void;
+    /**
+     * Unsubscribe from events
+     */
+    off<T = unknown>(event: string, handler: EventHandler$1<T>): void;
+    /**
+     * Remove all listeners for a specific event
+     */
+    offAll?(event: string): void;
+    /**
+     * Remove all event listeners
+     */
+    removeAllListeners?(): void;
+}
+
+declare class UserManager {
+    private _currentUser;
+    private users;
+    constructor(currentUser?: UserInfo);
+    get currentUser(): UserInfo | null;
+    setCurrentUser(user: UserInfo): void;
+    getUser(id: string): UserInfo | undefined;
+    updateUsers(users: UserInfo[]): void;
+    /**
+     * Check if current user can edit/delete an annotation.
+     */
+    canEditAnnotation(annotation: Annotation): boolean;
+    /**
+     * Check if current user can edit/delete a comment.
+     */
+    canEditComment(comment: AnnotationComment): boolean;
+}
+
+/**
+ * Type-safe event handler for remote interactions
+ */
+type InteractionHandler = (payload: RemoteInteractionPayload) => void;
+/**
+ * CollaborationManager coordinates real-time collaboration between
+ * local state changes and remote peers via a CollaborationProvider.
+ */
+declare class CollaborationManager {
+    private annotationStore;
+    private commentStore;
+    private provider;
+    private userManager;
+    private isApplyingRemote;
+    private localUnsubscribers;
+    private remoteHandlers;
+    private interactionListeners;
+    private documentModeListeners;
+    private documentMode;
+    private isDestroyed;
+    constructor(annotationStore: AnnotationStore, commentStore: CommentStore, provider: (CollaborationProvider | null) | undefined, userManager: UserManager);
+    /**
+     * Set or replace the collaboration provider.
+     * Cleans up previous provider listeners before setting new one.
+     */
+    setProvider(provider: CollaborationProvider): void;
+    /**
+     * Get the current provider
+     */
+    getProvider(): CollaborationProvider | null;
+    private cleanupLocalListeners;
+    private cleanupRemoteListeners;
+    /**
+     * Connect to a collaboration session for the given document.
+     * User must be set via UserManager before connecting.
+     */
+    connect(documentId: string): Promise<void>;
+    /**
+     * Disconnect from the current collaboration session.
+     */
+    disconnect(): void;
+    /**
+     * Destroy the collaboration manager and clean up all resources.
+     * Call this when the manager will no longer be used.
+     */
+    destroy(): void;
+    private setupLocalListeners;
+    /**
+     * Send an ephemeral interaction event to remote peers.
+     */
+    sendInteraction(payload: RemoteInteractionPayload): void;
+    /**
+     * Update collaboration document mode for all participants in current room.
+     */
+    setDocumentMode(mode: DocumentMode): void;
+    /**
+     * Get latest known collaboration document mode.
+     */
+    getDocumentMode(): DocumentMode;
+    private setupRemoteListeners;
+    private applyRemoteChange;
+    private applySyncState;
+    private applyDocumentMode;
+    private applyRemoteInteraction;
+    /**
+     * Register a handler for remote interaction events.
+     * Returns an unsubscribe function.
+     */
+    onInteraction(handler: InteractionHandler): () => void;
+    /**
+     * Remove all interaction listeners.
+     */
+    clearInteractionListeners(): void;
+    /**
+     * Register document mode change listener.
+     */
+    onDocumentModeChange(listener: (mode: DocumentMode) => void): () => void;
+}
+
+declare class BroadcastChannelProvider implements CollaborationProvider {
+    private channel;
+    private listeners;
+    private currentUser;
+    private _status;
+    constructor();
+    get status(): ConnectionStatus;
+    private setStatus;
+    connect(options: {
+        documentId: string;
+        user: UserInfo;
+    }): Promise<void>;
+    disconnect(): void;
+    sendAnnotationChange(change: RemoteAnnotationChange): void;
+    sendCommentChange(change: RemoteCommentChange): void;
+    sendInteraction(payload: RemoteInteractionPayload): void;
+    setDocumentMode(mode: DocumentMode): void;
+    on(event: string, handler: Function): void;
+    off(event: string, handler: Function): void;
+    private broadcast;
+    private handleMessage;
+    private emit;
+}
+
+/**
+ * Configuration options for WebSocketProvider.
+ */
+interface WebSocketProviderOptions {
+    /** Enable automatic reconnection (default: true) */
+    reconnection?: boolean;
+    /** Maximum number of reconnection attempts (default: 10) */
+    reconnectionAttempts?: number;
+    /** Initial delay between reconnection attempts in ms (default: 1000) */
+    reconnectionDelay?: number;
+    /** Maximum delay between reconnection attempts in ms (default: 5000) */
+    reconnectionDelayMax?: number;
+    /** Connection timeout in ms (default: 20000) */
+    timeout?: number;
+    /** Optional authentication token for collaboration server */
+    authToken?: string;
+}
+/**
+ * Type-safe event handler type
+ */
+type EventHandler<T = unknown> = (payload: T) => void;
+declare class WebSocketProvider implements CollaborationProvider {
+    private url;
+    private socket;
+    private listeners;
+    private _status;
+    private pendingMessages;
+    private connectOptions?;
+    private readonly options;
+    private readonly authToken?;
+    private isDestroyed;
+    constructor(url: string, options?: WebSocketProviderOptions);
+    get status(): ConnectionStatus;
+    private setStatus;
+    connect(options: {
+        documentId: string;
+        user: UserInfo;
+    }): Promise<void>;
+    /**
+     * Disconnect from the server and clean up resources
+     */
+    disconnect(): void;
+    /**
+     * Destroy the provider and prevent any further use
+     * Call this when the provider will no longer be used
+     */
+    destroy(): void;
+    sendAnnotationChange(change: RemoteAnnotationChange): void;
+    sendCommentChange(change: RemoteCommentChange): void;
+    sendInteraction(payload: RemoteInteractionPayload): void;
+    setDocumentMode(mode: DocumentMode): void;
+    on<T = unknown>(event: string, handler: EventHandler<T>): void;
+    off<T = unknown>(event: string, handler: EventHandler<T>): void;
+    /**
+     * Remove all listeners for a specific event
+     */
+    offAll(event: string): void;
+    /**
+     * Remove all event listeners
+     */
+    removeAllListeners(): void;
+    private emit;
+    private sendOrQueue;
+    private flushQueue;
+}
+
+export { AddAnnotationCommand, type Annotation, type AnnotationCapabilities, type AnnotationComment, type AnnotationGeometry, type AnnotationMetadata, AnnotationStore, type AnnotationStoreChange, type AnnotationStoreListener, type AnnotationStyle, type AnnotationType, type BaseWatermark, BroadcastChannelProvider, type BusinessField, CollaborationManager, type CollaborationProvider, type CommentCapabilities, type CommentContent, CommentStore, type CommentStoreChange, type CommentStoreListener, type CommentThread, type CommentThreadStatus, type ConnectionStatus, DEFAULT_ANNOTATION_STYLE, DEFAULT_IMAGE_WATERMARK_SETTINGS, DEFAULT_PERMISSION_POLICY, DEFAULT_TEXT_WATERMARK, DEFAULT_VIEWER_STATE, DeletePageCommand, type DocumentCapabilities, type DocumentMode, type DocumentSource, type DocumentSourceRef, type ImageWatermark, type NormalizedPoint, type NormalizedRect, type OutlineNode, PageManager, type PdfData, type PdfDocumentHandle, type PdfJsGetDocument, type PdfLoader, type PdfLoaderOptions, type PdfMetadata, type PdfOutlineEntry, type PdfPageHandle, type PdfPasswordRequestReason, type PdfToolsModule, type PermissionAction, type PermissionContext, type PermissionDecision, type PermissionDenyReason, type PermissionEffect, type PermissionEvaluationInput, type PolicyRule, type PolicySet, type PrincipalInfo, type RemoteChangePayload, RemoveAnnotationCommand, ReorderPageCommand, type ResourcePolicyOverride, type Rotation, type ScaleMode, type SyncState, type TemplateElement, TemplateManager, type TemplatePlaceholderType, type TemplateRenderPolicy, type TemplateStyle, type TextAlign, type TextWatermark, type ThreadCapabilities, type ThumbnailDescriptor, UndoManager, type UndoableCommand, UpdateAnnotationCommand, type UserInfo, UserManager, ViewerController, type ViewerListener, type ViewerState, type ViewerStatus, type Watermark, type WatermarkImageLoadResult, type WatermarkImageLoadSource, type WatermarkImageUploadResult, type WatermarkPosition, type WatermarkTransferOptions, WebSocketProvider, type WebSocketProviderOptions, clampNormalizedPoint, clampNormalizedRect, clampPage, clampScale, createPdfLoader, dataToWatermark, embed_watermark_wasm, evaluatePermission, exportPdf, extractComments, extractPdfOutline, extractPdfThumbnails, extract_pages_wasm, get_page_count_wasm, hasNonAsciiChars, hexToRgb, loadPdfTools, mergeComments, normalizeRotation, read_pdf_data_wasm, toDocumentSourceRef, watermarkToData, write_pdf_data_wasm };