teamsync-pdf-viewer 1.0.3 → 1.2.0

package/dist/src/annotations/AnnotationManager.d.ts

@@ -0,0 +1,90 @@
+import { PDFDocumentProxy } from 'pdfjs-dist';
+import { Annotation, AnnotationInput } from './types';
+import { XfdfExportOptions } from './xfdf';
+export type AnnotationAction = 'add' | 'modify' | 'delete';
+export interface AnnotationChangedEvent {
+    annotations: Annotation[];
+    action: AnnotationAction;
+    /** True when the change came from importAnnotations()/programmatic APIs flagged as imported. */
+    imported: boolean;
+}
+export interface CommitOptions {
+    /** Mark the change as an import round-trip (not persisted by host bridges, not undoable). */
+    imported?: boolean;
+    /** Bypass read-only / authorship checks (programmatic host operations). */
+    force?: boolean;
+    /** Record in the undo history (default: true unless imported). */
+    undoable?: boolean;
+}
+export interface ViewerUserInfo {
+    id?: string;
+    name?: string;
+}
+type ChangedListener = (event: AnnotationChangedEvent) => void;
+export declare class AnnotationManager {
+    private list;
+    private past;
+    private future;
+    private changedListeners;
+    private listListeners;
+    private user;
+    private readOnly;
+    private canEditOthers;
+    private resolver;
+    setDocument(doc: PDFDocumentProxy | null): void;
+    hasDocument(): boolean;
+    setCurrentUser(name: string, id?: string): void;
+    setCurrentUserInfo(user: ViewerUserInfo | undefined): void;
+    getCurrentUser(): string;
+    getCurrentUserInfo(): ViewerUserInfo;
+    setReadOnly(readOnly: boolean): void;
+    isReadOnly(): boolean;
+    /** Allow editing/deleting annotations authored by other users (default false). */
+    setCanEditOthers(value: boolean): void;
+    /** Whether the current user may modify or delete this annotation through the UI. */
+    canEdit(a: Annotation): boolean;
+    canAdd(): boolean;
+    /** The current list. The array reference is stable until the next change. */
+    getAnnotationsList(): Annotation[];
+    getAnnotationById(id: string): Annotation | undefined;
+    /** React `useSyncExternalStore` pair. */
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => Annotation[];
+    addEventListener(type: 'annotationChanged', listener: ChangedListener): () => void;
+    removeEventListener(type: 'annotationChanged', listener: ChangedListener): void;
+    /** Apryse-compat no-op: React re-renders from the list. */
+    drawAnnotationsFromList(_annotations: Annotation[]): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    /**
+     * Replace the whole list (the UI's edit path). Diffs against the current list, enforces
+     * permissions (rejected edits keep the previous version), records history and emits one
+     * `annotationChanged` event per action.
+     */
+    commit(next: Annotation[], opts?: CommitOptions): Annotation[];
+    addAnnotations(inputs: AnnotationInput[], opts?: CommitOptions): Annotation[];
+    updateAnnotation(id: string, patch: Partial<AnnotationInput>, opts?: CommitOptions): Annotation | undefined;
+    deleteAnnotations(targets: Array<Annotation | string>, opts?: CommitOptions): void;
+    /** Remove every annotation (e.g. on document switch). Not undoable, emits deletes as imported. */
+    clear(): void;
+    /**
+     * Import an XFDF document or bare fragments. Annotations whose `name` already exists are
+     * replaced (modify), new ones added; the change is flagged `imported` and is not undoable.
+     * Returns the imported annotations as they now exist in the list.
+     */
+    importAnnotations(xfdf: string): Promise<Annotation[]>;
+    /**
+     * Export as XFDF. With `annotList`, returns the bare fragment(s) for those annotations (the
+     * form hosts persist per annotation); without it, a complete XFDF document.
+     */
+    exportAnnotations(opts?: XfdfExportOptions): Promise<string>;
+    /** Legacy bespoke JSON export (pre-1.2 `exportAnnotations()` shape). */
+    exportAnnotationsLegacyJson(): string;
+    private requireResolver;
+    private apply;
+    private stampNew;
+    private emit;
+}
+export {};

package/dist/src/annotations/geometry.d.ts

@@ -0,0 +1,51 @@
+import { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist';
+export type Matrix = [number, number, number, number, number, number];
+export interface PageGeometry {
+    /** 1-based page number */
+    pageNumber: number;
+    /** PDF user-space bounding box [x0, y0, x1, y1] (the CropBox pdf.js renders). */
+    viewBox: [number, number, number, number];
+    /** Intrinsic page rotation (/Rotate), normalized to 0/90/180/270. */
+    rotate: number;
+    /** Base page size in points (already swapped for 90/270). */
+    width: number;
+    height: number;
+    /** Base-space (viewer) -> PDF user-space transform is the inverse of this viewport transform. */
+    transform: Matrix;
+}
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+/** PDF rectangle as XFDF writes it: [llx, lly, urx, ury]. */
+export type PdfRect = [number, number, number, number];
+/** Build the geometry for a page from its viewBox and intrinsic rotation (mirrors pdf.js PageViewport at scale 1). */
+export declare function createPageGeometry(pageNumber: number, viewBox: [number, number, number, number], rotate: number): PageGeometry;
+export declare function geometryFromPage(page: PDFPageProxy): PageGeometry;
+/** Small per-document cache so callers can resolve geometry for many annotations cheaply. */
+export declare function createGeometryResolver(pdfDoc: PDFDocumentProxy): (pageNumber: number) => Promise<PageGeometry>;
+export type GeometryResolver = (pageNumber: number) => Promise<PageGeometry>;
+export declare function toPdfPoint(g: PageGeometry, p: Point): Point;
+export declare function fromPdfPoint(g: PageGeometry, p: Point): Point;
+/** Viewer rect (top-left origin) -> PDF rect [llx, lly, urx, ury]. */
+export declare function rectToPdf(g: PageGeometry, r: Rect): PdfRect;
+/** PDF rect [llx, lly, urx, ury] -> viewer rect (top-left origin). */
+export declare function rectFromPdf(g: PageGeometry, r: PdfRect): Rect;
+export declare function pathToPdf(g: PageGeometry, points: Point[]): Point[];
+export declare function pathFromPdf(g: PageGeometry, points: Point[]): Point[];
+/**
+ * XFDF QuadPoints for a viewer rect: x1,y1 (upper-left) x2,y2 (upper-right) x3,y3 (lower-left)
+ * x4,y4 (lower-right) in PDF space — the order Acrobat and Apryse write for text markup.
+ */
+export declare function rectToQuadPoints(g: PageGeometry, r: Rect): number[];
+/** Bounding viewer rect of one or more XFDF quads (8 numbers each). */
+export declare function quadPointsToRects(g: PageGeometry, quads: number[]): Rect[];
+export declare function unionRects(rects: Rect[]): Rect;
+/** Round to 3 decimals for XFDF output (Apryse writes 3, Acrobat up to 6). */
+export declare const fmt: (n: number) => string;

package/dist/src/annotations/ids.d.ts

@@ -0,0 +1,6 @@
+/**
+ * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
+ * Stable, collision-free annotation ids. They double as the XFDF `name` attribute, which hosts use
+ * to match persisted rows to live annotations, so they must never be timestamps.
+ */
+export declare function newAnnotationId(): string;

package/dist/src/annotations/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
+ * Annotation data model.
+ *
+ * Coordinates are in "base page space": the pdf.js viewport at scale 1 with the page's intrinsic
+ * /Rotate applied (top-left origin, PDF points). UI rotation applied by the viewer is composed on
+ * top of this space at render time, so stored annotations are independent of the current view.
+ */
+export type AnnotationType = 'rectangle' | 'ellipse' | 'line' | 'arrow' | 'freehand' | 'text' | 'note' | 'callout' | 'signature' | 'highlight' | 'digital_signature_placeholder' | 'link'
+/**
+ * An annotation imported from XFDF that this viewer cannot edit or render natively (e.g.
+ * underline, squiggly, polygon, redaction). It is drawn as a read-only outline at its bounding
+ * box and re-exported verbatim (`rawXfdf`) so nothing is lost on a save round-trip.
+ */
+ | 'opaque';
+export interface AnnotationPoint {
+    x: number;
+    y: number;
+}
+export interface Annotation {
+    id: string;
+    /** 1-based page number */
+    pageIndex: number;
+    type: AnnotationType;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text?: string;
+    points?: AnnotationPoint[];
+    rects?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[];
+    color: string;
+    strokeWidth: number;
+    opacity: number;
+    imageUrl?: string;
+    timestamp?: number;
+    signer?: string;
+    signType?: 'advanced' | 'simple';
+    linkUrl?: string;
+    /** Display name of the author (set from `currentUser` when created in-viewer). */
+    author?: string;
+    /** Stable author identifier (opaque to the viewer). */
+    authorId?: string;
+    /** When true the annotation cannot be moved, edited or deleted in the UI. */
+    readOnly?: boolean;
+    /** Multi-stroke ink (each stroke a polyline). `points` holds the first stroke for legacy consumers. */
+    strokes?: AnnotationPoint[][];
+    /** ISO-8601 timestamps (XFDF creationdate / date). */
+    createdAt?: string;
+    modifiedAt?: string;
+    /** Subject / XFDF element name of an opaque annotation (informational). */
+    opaqueKind?: string;
+    /** Verbatim XFDF element for `opaque` annotations. */
+    rawXfdf?: string;
+    /**
+     * XFDF attributes and child elements this viewer does not model (e.g. Apryse `trn-custom-data`,
+     * `defaultappearance`). Preserved on import and re-emitted on export so other viewers keep
+     * their metadata across a round-trip.
+     */
+    xfdfExtras?: {
+        attrs?: Record<string, string>;
+        children?: string[];
+    };
+}
+export type AnnotationInput = Omit<Annotation, 'id'> & {
+    id?: string;
+};

package/dist/src/annotations/xfdf.d.ts

@@ -0,0 +1,18 @@
+import { Annotation } from './types';
+import { GeometryResolver } from './geometry';
+export declare const XFDF_NS = "http://ns.adobe.com/xfdf/";
+export interface XfdfExportOptions {
+    /** Annotations to serialize (default: all given). */
+    annotList?: Annotation[];
+    /** Write the author's display name into `title` (default true). */
+    useDisplayAuthor?: boolean;
+}
+/** ISO-8601 -> PDF date `D:YYYYMMDDHHmmSS+HH'mm'`. */
+export declare function toPdfDate(iso: string | undefined): string;
+/** PDF date -> ISO-8601 (best effort; returns undefined when unparseable). */
+export declare function fromPdfDate(pdf: string | null | undefined): string | undefined;
+/** Serialize one annotation to an XFDF element (no envelope). */
+export declare function annotationToXfdfFragment(a: Annotation, resolve: GeometryResolver, opts?: XfdfExportOptions): Promise<string>;
+/** Serialize annotations to a complete XFDF document. */
+export declare function annotationsToXfdf(annotations: Annotation[], resolve: GeometryResolver, opts?: XfdfExportOptions): Promise<string>;
+export declare function parseXfdf(xml: string, resolve: GeometryResolver): Promise<Annotation[]>;

package/dist/src/components/AboutModal.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface AboutModalProps {
+    onClose: () => void;
+}
+export default function AboutModal({ onClose }: AboutModalProps): React.JSX.Element;
+export {};

package/dist/src/components/AnnotationContextMenu.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { Annotation } from '../annotations/types';
+import { SDKPermissions } from '../core/types';
+interface AnnotationContextMenuProps {
+    annotation: Annotation;
+    position: {
+        top: number;
+        left: number;
+    };
+    onCopy: () => void;
+    onDelete: () => void;
+    onUpdateColor: (color: string) => void;
+    onOpenLinkModal: () => void;
+    permissions?: SDKPermissions;
+}
+export default function AnnotationContextMenu({ annotation, position, onCopy, onDelete, onUpdateColor, onOpenLinkModal, permissions }: AnnotationContextMenuProps): React.JSX.Element;
+export {};

package/dist/src/components/DocumentViewer.d.ts

@@ -0,0 +1,50 @@
+import { default as React } from 'react';
+import { Annotation } from '../annotations/types';
+import { AnnotationManager } from '../annotations/AnnotationManager';
+import { Redaction, WatermarkOptions, SDKPermissions, PdfAssetPaths } from '../core/types';
+import * as pdfjsLib from 'pdfjs-dist';
+export interface DocumentLoadErrorInfo {
+    url: string;
+    passwordRequired: boolean;
+}
+interface DocumentViewerProps {
+    leftSidebarOpen: boolean;
+    rightSidebarOpen: boolean;
+    activeTab: string;
+    /** Canonical annotation list, history, permissions and XFDF (owned by the viewer instance). */
+    annotationManager: AnnotationManager;
+    initialDoc?: string;
+    /** Bump to force a reload of the same URL (retry after a load error). */
+    loadNonce?: number;
+    /** Send cookies with the document request. */
+    withCredentials?: boolean;
+    /** pdf.js asset locations, applied right before the document is opened. */
+    assets?: PdfAssetPaths;
+    /** Render the thumbnails (left) and comments/search (right) panels. Default true. */
+    sidebars?: boolean;
+    redactions?: Redaction[];
+    regexRedactions?: RegExp[];
+    scale: number;
+    setScale: (scale: number | ((prev: number) => number)) => void;
+    sidebarTab: 'Comments' | 'Search';
+    setSidebarTab: (tab: 'Comments' | 'Search') => void;
+    onAnnotationsChange?: (annotations: Annotation[]) => void;
+    /** Reports the combined (prop + regex + manual) redaction list whenever it changes. */
+    onRedactionsChange?: (redactions: Redaction[]) => void;
+    onDocumentLoaded?: (doc: pdfjsLib.PDFDocumentProxy, url: string) => void;
+    onLoadError?: (error: Error, info: DocumentLoadErrorInfo) => void;
+    /** Fires once per loaded document, after the first page canvas has been painted. */
+    onFirstPageRendered?: (pageNumber: number) => void;
+    onPageChange?: (pageNumber: number, numPages: number) => void;
+    pageTransition: 'continuous' | 'page-by-page';
+    pageLayout: 'single' | 'double' | 'cover-facing';
+    rotation: number;
+    setRotation: (r: number | ((prev: number) => number)) => void;
+    watermark?: WatermarkOptions;
+    watermarkText?: string;
+    enableAnnotations?: boolean;
+    initialPage?: number;
+    permissions?: SDKPermissions;
+}
+export default function DocumentViewer({ leftSidebarOpen, rightSidebarOpen, activeTab, annotationManager, initialDoc, loadNonce, withCredentials, assets, sidebars, redactions, regexRedactions, scale, setScale, sidebarTab, setSidebarTab, onAnnotationsChange, onRedactionsChange, onDocumentLoaded, onLoadError, onFirstPageRendered, onPageChange, pageTransition, pageLayout, rotation, setRotation, watermark, watermarkText, enableAnnotations: _enableAnnotations, initialPage, permissions }: DocumentViewerProps): React.JSX.Element;
+export {};

package/dist/src/components/Header.d.ts

@@ -0,0 +1,36 @@
+import { default as React } from 'react';
+import { SDKPermissions } from '../core/types';
+import { ViewerPlugin } from '../plugins/types';
+interface HeaderProps {
+    activeTab: string;
+    setActiveTab: (tab: string) => void;
+    leftSidebarOpen: boolean;
+    setLeftSidebarOpen: (open: boolean) => void;
+    rightSidebarOpen: boolean;
+    setRightSidebarOpen: (open: boolean) => void;
+    sidebarTab: 'Comments' | 'Search';
+    scale: number;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onZoomSet: (scale: number) => void;
+    onDownload: () => void;
+    onFullScreen: () => void;
+    onSaveAs: () => void;
+    onPrint?: () => void;
+    onOpenSettings: () => void;
+    onOpenAbout: () => void;
+    onOpenSidebarTab: (tab: 'Comments' | 'Search') => void;
+    pageTransition: 'continuous' | 'page-by-page';
+    setPageTransition: (t: 'continuous' | 'page-by-page') => void;
+    pageLayout: 'single' | 'double' | 'cover-facing';
+    setPageLayout: (l: 'single' | 'double' | 'cover-facing') => void;
+    rotation: number;
+    setRotation: (r: number) => void;
+    signatureCount?: number;
+    enableAnnotations?: boolean;
+    enableSign?: boolean;
+    plugins?: ViewerPlugin[];
+    permissions?: SDKPermissions;
+}
+export default function Header({ activeTab, setActiveTab, leftSidebarOpen, setLeftSidebarOpen, rightSidebarOpen, setRightSidebarOpen: _setRightSidebarOpen, sidebarTab, scale, onZoomIn, onZoomOut, onZoomSet, onDownload, onFullScreen, onSaveAs, onPrint, onOpenSettings, onOpenAbout, onOpenSidebarTab, pageTransition, setPageTransition, pageLayout, setPageLayout, rotation, setRotation, signatureCount, enableAnnotations, enableSign, plugins, permissions }: HeaderProps): React.JSX.Element;
+export {};

package/dist/src/components/InsertLinkModal.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface InsertLinkModalProps {
+    initialUrl?: string;
+    initialText?: string;
+    showTextInput?: boolean;
+    onClose: () => void;
+    onSave: (url: string, text?: string) => void;
+}
+export default function InsertLinkModal({ initialUrl, initialText, showTextInput, onClose, onSave }: InsertLinkModalProps): React.JSX.Element;
+export {};

package/dist/src/components/LeftSidebar.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import * as pdfjsLib from 'pdfjs-dist';
+interface LeftSidebarProps {
+    isOpen: boolean;
+    pdfDoc: pdfjsLib.PDFDocumentProxy | null;
+    pageNum: number;
+    setPageNum: (p: number) => void;
+}
+export default function LeftSidebar({ isOpen, pdfDoc, pageNum, setPageNum }: LeftSidebarProps): React.JSX.Element;
+export {};

package/dist/src/components/PageContextMenu.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+interface PageContextMenuProps {
+    position: {
+        top: number;
+        left: number;
+    };
+    hasSelection?: boolean;
+    onSetTool: (tool: any) => void;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onClose: () => void;
+    onLink?: () => void;
+    onHighlight?: () => void;
+    onUnderline?: () => void;
+    onStrikethrough?: () => void;
+    onCopy?: () => void;
+    enableAnnotations?: boolean;
+}
+export default function PageContextMenu({ position, hasSelection, onSetTool, onZoomIn, onZoomOut, onClose, onLink, onHighlight, onUnderline, onStrikethrough, onCopy, enableAnnotations }: PageContextMenuProps): React.JSX.Element;
+export {};

package/dist/src/components/PageRenderer.d.ts

@@ -0,0 +1,40 @@
+import { default as React } from 'react';
+import { SearchResult } from '../hooks/usePdfSearch';
+import { Redaction, WatermarkOptions } from '../core/types';
+import { Annotation } from '../annotations/types';
+import * as pdfjsLib from 'pdfjs-dist';
+export type { Annotation };
+interface PageRendererProps {
+    pageNum: number;
+    pdfDoc: pdfjsLib.PDFDocumentProxy;
+    scale: number;
+    rotation: number;
+    containerWidth: number;
+    containerHeight: number;
+    scrollTop: number;
+    scrollLeft: number;
+    pageTop: number;
+    pageLeft?: number;
+    basePageWidth: number;
+    basePageHeight: number;
+    activeTab: string;
+    activeTool: string | null;
+    annotations: Annotation[];
+    selectedAnnotationId: string | null;
+    activeSearchResult: SearchResult | null;
+    onMouseDown: (e: React.MouseEvent<Element>, pageNum: number) => void;
+    onMouseMove: (e: React.MouseEvent<Element>, pageNum: number) => void;
+    onMouseUp: (e: React.MouseEvent<Element>, pageNum: number) => void;
+    onAnnotationClick: (id: string, e: React.MouseEvent) => void;
+    onAnnotationMouseEnter: (id: string) => void;
+    onClearSelection: () => void;
+    watermark?: WatermarkOptions;
+    watermarkText?: string;
+    redactions?: Redaction[];
+    onDiscardRedaction?: (redaction: Redaction) => void;
+    /** Called after the page canvas has been painted (used for first-page-rendered telemetry). */
+    onRendered?: (pageNum: number) => void;
+}
+declare function PageRendererComponent({ pageNum, pdfDoc, scale, rotation, containerWidth: _containerWidth, containerHeight: _containerHeight, scrollTop: _scrollTop, scrollLeft: _scrollLeft, pageTop, pageLeft, basePageWidth, basePageHeight, activeTab, activeTool, annotations, selectedAnnotationId, activeSearchResult, onMouseDown, onMouseMove, onMouseUp, onAnnotationClick, onAnnotationMouseEnter, onClearSelection, watermark, watermarkText, redactions, onDiscardRedaction, onRendered }: PageRendererProps): React.JSX.Element;
+declare const PageRenderer: React.MemoExoticComponent<typeof PageRendererComponent>;
+export default PageRenderer;

package/dist/src/components/SettingsModal.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface SettingsModalProps {
+    onClose: () => void;
+    watermarkText: string;
+    setWatermarkText: (text: string) => void;
+}
+export default function SettingsModal({ onClose, watermarkText, setWatermarkText }: SettingsModalProps): React.JSX.Element;
+export {};

package/dist/src/components/Sidebar.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { SearchResult } from '../hooks/usePdfSearch';
+interface SidebarProps {
+    isOpen: boolean;
+    annotations: any[];
+    setAnnotations: (anns: any[]) => void;
+    selectedAnnotationId: string | null;
+    setSelectedAnnotationId: (id: string | null) => void;
+    onSearch: (query: string) => void;
+    searchResults: SearchResult[];
+    isSearching: boolean;
+    searchProgress: number;
+    onResultClick: (result: SearchResult) => void;
+    activeTab: 'Comments' | 'Search';
+    setActiveTab: (tab: 'Comments' | 'Search') => void;
+}
+export default function Sidebar({ isOpen, annotations, setAnnotations, selectedAnnotationId, setSelectedAnnotationId, onSearch, searchResults, isSearching, searchProgress, onResultClick, activeTab, setActiveTab }: SidebarProps): React.JSX.Element;
+export {};

package/dist/src/components/TeamSyncViewer.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { DocumentLoadErrorInfo } from './DocumentViewer';
+import { WebViewerInstance } from '../core/ViewerInstance';
+import { WebViewerOptions } from '../core/types';
+import { Annotation } from '../annotations/types';
+export interface TeamSyncViewerProps extends Omit<WebViewerOptions, 'path'> {
+    /** URL of the PDF to display. Alias of `initialDoc`; `fileUrl` wins when both are set. */
+    fileUrl?: string;
+    /** Fires once, after mount, with the instance handle. */
+    onReady?: (instance: WebViewerInstance) => void;
+    onDocumentLoaded?: (info: {
+        url: string;
+        numPages: number;
+    }) => void;
+    /**
+     * Fires when the document could not be loaded. `retry(newUrl?)` reloads — pass a fresh URL when
+     * the previous one was a presigned link that expired.
+     */
+    onDocumentLoadError?: (error: Error, retry: (newUrl?: string) => void, info: DocumentLoadErrorInfo) => void;
+    /** Fires once per document, after the first page canvas has been painted. */
+    onFirstPageRendered?: (info: {
+        url: string;
+        pageNumber: number;
+    }) => void;
+    /** Fires (in addition to onDocumentLoadError) when the document is password protected. */
+    onPasswordRequired?: (info: {
+        url: string;
+    }) => void;
+    onPageChange?: (pageNumber: number, numPages: number) => void;
+    onAnnotationsChange?: (annotations: Annotation[]) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const TeamSyncViewer: React.ForwardRefExoticComponent<TeamSyncViewerProps & React.RefAttributes<WebViewerInstance>>;
+export default TeamSyncViewer;

package/dist/src/components/TextSelectionMenu.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { SDKPermissions } from '../core/types';
+interface TextSelectionMenuProps {
+    position: {
+        top: number;
+        left: number;
+    };
+    onHighlight: () => void;
+    onText?: () => void;
+    onRedact?: () => void;
+    onCopy?: () => void;
+    onLink?: () => void;
+    permissions?: SDKPermissions;
+    isViewMode?: boolean;
+    hasText?: boolean;
+}
+export default function TextSelectionMenu({ position, onHighlight, onText, onRedact, onCopy, onLink, permissions, isViewMode, hasText }: TextSelectionMenuProps): React.JSX.Element | null;
+export {};

package/dist/src/core/ViewerInstance.d.ts

@@ -0,0 +1,94 @@
+import { ViewerBus } from './eventBus';
+import { ExportOptions } from './export';
+import { Annotation } from '../annotations/types';
+import { AnnotationManager } from '../annotations/AnnotationManager';
+import { Redaction, WatermarkOptions, ViewerEventMap, ViewerEventType } from './types';
+/**
+ * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
+ * WebViewerInstance — the imperative handle returned by `createWebViewer()` and exposed through
+ * `<TeamSyncViewer ref>`. Keeps the legacy `UI` / `Core` facade for drop-in compatibility.
+ */
+import type * as pdfjsLib from 'pdfjs-dist';
+/** Callbacks the React component installs so the instance can reach live state. */
+export interface ViewerBinding {
+    getAnnotations(): Annotation[];
+    getRedactions(): Redaction[];
+    getWatermark(): WatermarkOptions | undefined;
+    getPdfDocument(): pdfjsLib.PDFDocumentProxy | null;
+    getDocumentUrl(): string | undefined;
+    getFileName(): string | undefined;
+    getCurrentUserName(): string | undefined;
+    getCurrentPage(): number;
+    getPageCount(): number;
+    loadDocument(url: string): void;
+}
+export declare class WebViewerInstance {
+    readonly bus: ViewerBus;
+    /** Annotation list, history, permissions and XFDF import/export. */
+    readonly annotationManager: AnnotationManager;
+    /** Root element of the viewer once mounted. */
+    element: HTMLElement | null;
+    private binding;
+    private unmountRoot;
+    private destroyed;
+    constructor(bus: ViewerBus, annotationManager?: AnnotationManager);
+    /** @internal */
+    _bind(binding: ViewerBinding, element: HTMLElement | null): void;
+    /** @internal */
+    _unbind(): void;
+    /** @internal — installed by createWebViewer() so destroy() can unmount the React root. */
+    _setUnmount(fn: () => void): void;
+    get isDestroyed(): boolean;
+    get isMounted(): boolean;
+    /**
+     * Tear the viewer down: unmounts the React tree created by `createWebViewer()`, drops every
+     * listener and refuses further use. Safe to call twice.
+     */
+    destroy(): void;
+    on<K extends ViewerEventType>(type: K, listener: (detail: ViewerEventMap[K]) => void): () => void;
+    off<K extends ViewerEventType>(type: K, listener: (detail: ViewerEventMap[K]) => void): void;
+    /** Load (or reload) a document by URL. Resolves when loaded, rejects on load error. */
+    loadDocument(url: string): Promise<{
+        url: string;
+        numPages: number;
+    }>;
+    getDocumentUrl(): string | undefined;
+    getPdfDocument(): pdfjsLib.PDFDocumentProxy | null;
+    getCurrentPage(): number;
+    getPageCount(): number;
+    getAnnotations(): Annotation[];
+    /** Print the exported document (annotations, redactions and watermark baked in). */
+    print(): void;
+    /**
+     * Build the exported PDF (annotations + watermark baked, redacted pages rasterized).
+     * Uses the bytes of the loaded document; never re-fetches the URL.
+     */
+    getFileData(options?: ExportOptions): Promise<Uint8Array>;
+    readonly UI: {
+        /** Theming is not implemented; kept for API compatibility. */
+        setTheme: (_theme: string) => void;
+        openElements: (elements: string[]) => void;
+        closeElements: (elements: string[]) => void;
+        enableElements: (elements: string[]) => void;
+        disableElements: (elements: string[]) => void;
+        setActiveLeftPanel: (panel: string) => void;
+        setToolMode: (tool: string | null) => void;
+        fitWidth: () => void;
+        fitPage: () => void;
+        fitToWidth: () => void;
+        fitToPage: () => void;
+    };
+    readonly Core: {
+        /** The real AnnotationManager (XFDF import/export, granular events, permissions). */
+        readonly annotationManager: AnnotationManager;
+        documentViewer: {
+            addEventListener: (event: string, callback: (detail: unknown) => void) => (() => void);
+            removeEventListener: (event: string, callback: (detail: unknown) => void) => void;
+            getCurrentPage: () => number;
+            getPageCount: () => number;
+            getDocument: () => {
+                getFileData: (options?: ExportOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+            };
+        };
+    };
+}

package/dist/src/core/busContext.d.ts

@@ -0,0 +1,3 @@
+import { ViewerBus } from './eventBus';
+/** Provided by <TeamSyncViewer>; every internal component reads its bus from here. */
+export declare const ViewerBusContext: import('react').Context<ViewerBus | null>;

package/dist/src/core/createWebViewer.d.ts

@@ -0,0 +1,5 @@
+import { WebViewerInstance } from './ViewerInstance';
+import { WebViewerOptions } from './types';
+export declare function createWebViewer(options: WebViewerOptions, viewerElement: HTMLElement): Promise<WebViewerInstance>;
+/** @deprecated Use `createWebViewer`. Kept as an alias for drop-in compatibility. */
+export declare const WebViewer: typeof createWebViewer;

package/dist/src/core/eventBus.d.ts

@@ -0,0 +1,25 @@
+/**
+ * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
+ * Per-instance event bus.
+ *
+ * Replaces the former `window.dispatchEvent(new CustomEvent('action-*'))` plumbing so that several
+ * viewer instances can coexist on one page without cross-talk, and so that `destroy()` can drop
+ * every listener an instance ever registered.
+ */
+export type BusListener<T = unknown> = (detail: T) => void;
+export declare class ViewerBus {
+    private readonly listeners;
+    private destroyed;
+    /** Subscribe. Returns an unsubscribe function. */
+    on<T = unknown>(type: string, listener: BusListener<T>): () => void;
+    /** Subscribe for a single delivery. */
+    once<T = unknown>(type: string, listener: BusListener<T>): () => void;
+    off<T = unknown>(type: string, listener: BusListener<T>): void;
+    /** Dispatch synchronously to every listener. Listener errors are isolated and logged. */
+    emit<T = unknown>(type: string, detail?: T): void;
+    listenerCount(type?: string): number;
+    removeAll(): void;
+    /** Drop every listener and refuse further subscriptions/emissions. */
+    destroy(): void;
+    get isDestroyed(): boolean;
+}