teamsync-pdf-viewer 1.0.3 → 1.1.0

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,47 @@
+import { default as React } from 'react';
+import { Annotation } from '../annotations/types';
+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;
+    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, 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,35 @@
+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;
+    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, 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,92 @@
+import { ViewerBus } from './eventBus';
+import { ExportOptions } from './export';
+import { Annotation } from '../annotations/types';
+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;
+    /** Root element of the viewer once mounted. */
+    element: HTMLElement | null;
+    private binding;
+    private unmountRoot;
+    private destroyed;
+    constructor(bus: ViewerBus);
+    /** @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[];
+    /**
+     * 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: {
+        annotationManager: {
+            /** Legacy: returns the bespoke JSON annotation list. XFDF import/export arrives in 1.2.0. */
+            exportAnnotations: () => string;
+            getAnnotationsList: () => Annotation[];
+        };
+        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;
+}

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

@@ -0,0 +1,20 @@
+import { Annotation } from '../annotations/types';
+import { Redaction, WatermarkOptions } from './types';
+/** Refuse to build documents larger than this in the browser (memory safety). */
+export declare const MAX_EXPORT_BYTES: number;
+export interface ExportInput {
+    /** Returns the original document bytes (prefer `pdfDocument.getData()`). */
+    getSourceBytes: () => Promise<Uint8Array | ArrayBuffer>;
+    annotations: Annotation[];
+    redactions: Redaction[];
+    watermark?: WatermarkOptions;
+    /** Name printed on digital-signature placeholder blocks when the annotation has no signer. */
+    signerName?: string;
+}
+export interface ExportOptions {
+    /** Bake exactly these annotations instead of the live list. */
+    explicitAnnotations?: Annotation[];
+    /** Accepted for API compatibility. Honoured from 1.2.0 (native XFDF import). */
+    xfdfString?: string;
+}
+export declare function buildPdfBytes(input: ExportInput, options?: ExportOptions): Promise<Uint8Array>;

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

@@ -0,0 +1,27 @@
+import { DocumentInitParameters } from 'pdfjs-dist/types/src/display/api';
+export interface PdfAssetPaths {
+    /** URL of `pdf.worker.min.mjs` matching the installed pdfjs-dist version. REQUIRED. */
+    workerSrc?: string;
+    /** Directory URL (trailing slash) of the packed CMaps — needed for CJK/Indic text. */
+    cMapUrl?: string;
+    /** Directory URL (trailing slash) of the standard 14 font substitutes. */
+    standardFontDataUrl?: string;
+    /** Directory URL (trailing slash) of the wasm decoders (JPX/OpenJPEG, qcms). */
+    wasmUrl?: string;
+    /** Directory URL (trailing slash) of ICC profiles. */
+    iccUrl?: string;
+}
+export declare function configurePdfAssets(paths: PdfAssetPaths): void;
+export declare function getPdfAssetPaths(): Readonly<PdfAssetPaths>;
+/** True once a worker URL has been configured (either via configurePdfAssets or directly on pdf.js). */
+export declare function isWorkerConfigured(): boolean;
+/**
+ * Throws a descriptive error when the worker has not been configured. Called lazily right before
+ * the first `getDocument()` — never at module scope, so importing the package is side-effect free
+ * and safe under SSR.
+ */
+export declare function assertWorkerConfigured(): void;
+/** Extra `getDocument()` parameters derived from the configured asset paths. */
+export declare function getDocumentParams(): Partial<DocumentInitParameters>;
+/** pdfjs-dist version this build was compiled against (useful for worker-version mismatch checks). */
+export declare const pdfjsVersion: string;

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

@@ -0,0 +1,103 @@
+import { ViewerPlugin } from '../plugins/types';
+import { Annotation } from '../annotations/types';
+import { PdfAssetPaths } from './pdfAssets';
+export type { PdfAssetPaths };
+export interface Redaction {
+    id?: string;
+    /** 1-based page number */
+    pageIndex: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    status?: 'pending' | 'applied';
+}
+export interface WatermarkOptions {
+    text: string;
+    opacity?: number;
+    size?: number;
+    mode?: 'single' | 'tiled';
+    color?: string;
+}
+export interface SDKPermissions {
+    canAddAnnotations?: boolean;
+    canEditAnnotations?: boolean;
+    canDeleteAnnotations?: boolean;
+    canRedact?: boolean;
+}
+export interface ViewerUser {
+    id: string;
+    name: string;
+}
+export type InitialScale = number | 'fit-width' | 'fit-page';
+/**
+ * Options accepted by `createWebViewer()` (and the deprecated `WebViewer()` alias).
+ * Every option is also available as a prop on `<TeamSyncViewer>`.
+ */
+export interface WebViewerOptions {
+    /** @deprecated Only meaningful for the iframe package (`public/webviewer.js`). */
+    path?: string;
+    /** URL of the PDF to load. Presigned/CORS-enabled URLs work; bytes are fetched by pdf.js. */
+    initialDoc?: string;
+    /** Display name used for downloads. */
+    fileName?: string;
+    initialScale?: InitialScale;
+    /** 1-based page to scroll to after load. */
+    initialPage?: number;
+    plugins?: ViewerPlugin[];
+    redactions?: Redaction[];
+    regexRedactions?: RegExp[];
+    enableAnnotations?: boolean;
+    enableSign?: boolean;
+    signOptions?: ('digital' | 'ades' | 'simple')[];
+    watermark?: WatermarkOptions;
+    permissions?: SDKPermissions;
+    enableRedactions?: boolean;
+    canAddAnnotations?: boolean;
+    canEditAnnotations?: boolean;
+    canDeleteAnnotations?: boolean;
+    /** Shorthand for "no annotation/redaction editing at all". */
+    readOnly?: boolean;
+    /** Author attached to annotations created in this viewer. */
+    currentUser?: ViewerUser;
+    /** pdf.js worker / CMap / font / wasm locations (see `configurePdfAssets`). */
+    assets?: PdfAssetPaths;
+    /** Send cookies with the document request (same-origin session-bound URLs). Default false. */
+    withCredentials?: boolean;
+    /** Render the top toolbar. Default true. */
+    toolbar?: boolean;
+    /** Render the left (thumbnails) and right (comments/search) panels. Default true. */
+    sidebars?: boolean;
+    /** Start with the thumbnails panel open. Default true. */
+    leftPanelOpen?: boolean;
+    /** Focus the viewer on mount so keyboard shortcuts work immediately. Default false. */
+    autoFocus?: boolean;
+}
+/** Events available through `instance.on(type, listener)`. */
+export interface ViewerEventMap {
+    documentLoaded: {
+        url: string;
+        numPages: number;
+    };
+    documentLoadError: {
+        url: string;
+        error: Error;
+        passwordRequired: boolean;
+    };
+    firstPageRendered: {
+        url: string;
+        pageNumber: number;
+    };
+    pageChanged: {
+        pageNumber: number;
+        numPages: number;
+    };
+    annotationsChanged: {
+        annotations: Annotation[];
+    };
+    toolChanged: {
+        tool: string | null;
+    };
+    destroy: Record<string, never>;
+}
+export type ViewerEventType = keyof ViewerEventMap;

package/dist/src/hooks/usePdfSearch.d.ts

@@ -0,0 +1,23 @@
+import { Redaction } from '../core/types';
+import * as pdfjsLib from 'pdfjs-dist';
+export interface SearchBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SearchResult {
+    id: string;
+    pageIndex: number;
+    snippet: string;
+    matchStartIndex: number;
+    matchLength: number;
+    bounds: SearchBounds[];
+}
+export declare function usePdfSearch(pdfDoc: pdfjsLib.PDFDocumentProxy | null, redactions?: Redaction[]): {
+    search: (query: string) => Promise<void>;
+    searchResults: SearchResult[];
+    isSearching: boolean;
+    searchProgress: number;
+    clearSearch: () => void;
+};

package/dist/src/hooks/useShortcuts.d.ts

@@ -0,0 +1,13 @@
+export type ActionType = 'ROTATE_CW' | 'ROTATE_CCW' | 'UNDO' | 'REDO' | 'DELETE' | 'COPY' | 'PASTE' | 'FILE_PICKER' | 'SEARCH';
+export interface Shortcut {
+    action: ActionType;
+    description: string;
+    defaultCommand: string;
+    command: string;
+}
+export declare function useShortcuts(): {
+    shortcuts: Shortcut[];
+    updateShortcut: (action: ActionType, newCommand: string) => void;
+    getCommand: (action: ActionType) => string;
+};
+export declare function matchShortcut(e: KeyboardEvent, commandString: string): boolean;

package/dist/src/hooks/useViewerBus.d.ts

@@ -0,0 +1,7 @@
+import { ViewerBus, BusListener } from '../core/eventBus';
+export declare function useViewerBus(): ViewerBus;
+/**
+ * Subscribe to a bus event for the lifetime of the component.
+ * The latest `listener` is always invoked (no stale closures) without re-subscribing on every render.
+ */
+export declare function useBusEvent<T = unknown>(type: string, listener: BusListener<T>): void;

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * © 2026 AngelBot Ai Pvt Ltd. All rights reserved.
+ * TeamSync PDF Viewer SDK — public entry point.
+ *
+ * This module is side-effect free: importing it never touches `window`/`document`, so it is safe
+ * to import under SSR. Mount with `createWebViewer()` or render `<TeamSyncViewer>` on the client.
+ */
+export { createWebViewer, WebViewer } from './core/createWebViewer';
+export { WebViewerInstance } from './core/ViewerInstance';
+export { TeamSyncViewer } from './components/TeamSyncViewer';
+export type { TeamSyncViewerProps } from './components/TeamSyncViewer';
+export { configurePdfAssets, getPdfAssetPaths, isWorkerConfigured, pdfjsVersion } from './core/pdfAssets';
+export type { PdfAssetPaths } from './core/pdfAssets';
+export { ViewerBus } from './core/eventBus';
+export type { BusListener } from './core/eventBus';
+export { buildPdfBytes, MAX_EXPORT_BYTES } from './core/export';
+export type { ExportInput, ExportOptions } from './core/export';
+export type { WebViewerOptions, Redaction, WatermarkOptions, SDKPermissions, ViewerUser, InitialScale, ViewerEventMap, ViewerEventType, } from './core/types';
+export type { Annotation, AnnotationType, AnnotationPoint } from './annotations/types';
+export * from './plugins/types';

package/dist/src/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

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

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+export interface PluginContext {
+    activeTool: string | null;
+    setActiveTool: (tool: string | null) => void;
+    annotations: any[];
+    setAnnotations: React.Dispatch<React.SetStateAction<any[]>>;
+    commitAnnotations: (anns: any[]) => void;
+    scale: number;
+    pdfDoc: any;
+    permissions?: any;
+    initialDoc?: string;
+    watermark?: any;
+}
+export interface ViewerPlugin {
+    id: string;
+    name: string;
+    renderHeaderActions?: (context: PluginContext) => React.ReactNode;
+    renderModals?: (context: PluginContext) => React.ReactNode;
+    onInit?: (context: PluginContext) => void;
+    onBeforeSave?: (pdfBytes: Uint8Array, context: PluginContext) => Promise<Uint8Array>;
+}
+export interface DigitalSignerOptions {
+    allowedTypes?: Array<'digital' | 'ades' | 'simple'>;
+    usbBridgeUrl?: string;
+    defaultSignerName?: string;
+}