pdfjs-reader-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1292 @@
+import * as react from 'react';
+import { Component, ReactNode, ErrorInfo } from 'react';
+import { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist';
+import * as pdfjsDist from 'pdfjs-dist';
+export { pdfjsDist as pdfjsLib };
+import * as zustand from 'zustand';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as pdfjs_dist_types_src_display_api from 'pdfjs-dist/types/src/display/api';
+import { ClassValue } from 'clsx';
+import * as pdfjs_dist_types_src_display_metadata from 'pdfjs-dist/types/src/display/metadata';
+
+interface PDFViewerProps {
+    /** URL or ArrayBuffer of the PDF file */
+    src: string | ArrayBuffer | Uint8Array;
+    /** Initial page number (1-indexed) */
+    initialPage?: number;
+    /** Initial scale/zoom level */
+    initialScale?: number | 'page-fit' | 'page-width' | 'auto';
+    /** Theme mode */
+    theme?: 'light' | 'dark' | 'sepia';
+    /** Custom class name */
+    className?: string;
+    /** Whether to show the toolbar */
+    showToolbar?: boolean;
+    /** Whether to show the sidebar */
+    showSidebar?: boolean;
+    /** Whether to show the annotation toolbar */
+    showAnnotationToolbar?: boolean;
+    /** Default sidebar panel */
+    defaultSidebarPanel?: SidebarPanel;
+    /** View mode for the document */
+    viewMode?: ViewMode;
+    /** Callback when document is loaded */
+    onDocumentLoad?: (document: PDFDocumentLoadedEvent) => void;
+    /** Callback when page changes */
+    onPageChange?: (page: number) => void;
+    /** Callback when scale/zoom changes */
+    onScaleChange?: (scale: number) => void;
+    /** Callback when text is selected */
+    onTextSelect?: (selection: TextSelection) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Worker source URL for pdf.js */
+    workerSrc?: string;
+}
+interface PDFDocumentLoadedEvent {
+    numPages: number;
+    document: PDFDocumentProxy;
+}
+interface TextSelection {
+    text: string;
+    pageNumber: number;
+    rects: DOMRect[];
+}
+interface PDFPageState {
+    pageNumber: number;
+    page: PDFPageProxy | null;
+    width: number;
+    height: number;
+    scale: number;
+    rotation: number;
+    isRendering: boolean;
+    isRendered: boolean;
+    error: Error | null;
+}
+interface PageDimensions {
+    width: number;
+    height: number;
+    scale: number;
+}
+type ViewMode = 'single' | 'dual' | 'continuous';
+type ScrollMode = 'single' | 'continuous';
+type SidebarPanel = 'thumbnails' | 'outline' | 'search' | 'annotations' | null;
+type Theme = 'light' | 'dark' | 'sepia';
+interface ViewerState {
+    document: PDFDocumentProxy | null;
+    numPages: number;
+    isLoading: boolean;
+    error: Error | null;
+    currentPage: number;
+    scale: number;
+    rotation: number;
+    viewMode: ViewMode;
+    scrollMode: ScrollMode;
+    theme: Theme;
+    sidebarOpen: boolean;
+    sidebarPanel: SidebarPanel;
+    isFullscreen: boolean;
+    isPresentationMode: boolean;
+}
+interface ViewerActions {
+    setDocument: (doc: PDFDocumentProxy) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: Error | null) => void;
+    setCurrentPage: (page: number) => void;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    previousPage: () => void;
+    setScale: (scale: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    fitToWidth: () => void;
+    fitToPage: () => void;
+    setRotation: (rotation: number) => void;
+    rotateClockwise: () => void;
+    rotateCounterClockwise: () => void;
+    setViewMode: (mode: ViewMode) => void;
+    setScrollMode: (mode: ScrollMode) => void;
+    setTheme: (theme: Theme) => void;
+    toggleSidebar: () => void;
+    setSidebarPanel: (panel: SidebarPanel) => void;
+    setFullscreen: (fullscreen: boolean) => void;
+    reset: () => void;
+}
+interface Highlight {
+    id: string;
+    pageNumber: number;
+    rects: HighlightRect[];
+    color: HighlightColor;
+    text: string;
+    comment?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HighlightRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type HighlightColor = 'yellow' | 'green' | 'blue' | 'pink' | 'orange';
+type AnnotationType = 'note' | 'drawing' | 'shape' | 'stamp';
+interface BaseAnnotation {
+    id: string;
+    type: AnnotationType;
+    pageNumber: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface NoteAnnotation extends BaseAnnotation {
+    type: 'note';
+    x: number;
+    y: number;
+    content: string;
+    color: string;
+}
+interface DrawingAnnotation extends BaseAnnotation {
+    type: 'drawing';
+    paths: DrawingPath[];
+    color: string;
+    strokeWidth: number;
+}
+interface DrawingPath {
+    points: {
+        x: number;
+        y: number;
+    }[];
+}
+interface ShapeAnnotation extends BaseAnnotation {
+    type: 'shape';
+    shapeType: 'rect' | 'circle' | 'arrow' | 'line';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    strokeWidth: number;
+}
+type Annotation = NoteAnnotation | DrawingAnnotation | ShapeAnnotation;
+interface SearchResult {
+    pageNumber: number;
+    matchIndex: number;
+    text: string;
+    rects: HighlightRect[];
+}
+interface SearchState {
+    query: string;
+    results: SearchResult[];
+    currentResultIndex: number;
+    isSearching: boolean;
+    caseSensitive: boolean;
+    wholeWord: boolean;
+}
+interface OutlineItem {
+    title: string;
+    pageNumber: number;
+    children: OutlineItem[];
+    expanded?: boolean;
+}
+interface Plugin {
+    name: string;
+    version: string;
+    initialize?: (api: PluginAPI) => void | Promise<void>;
+    destroy?: () => void | Promise<void>;
+}
+interface PluginAPI {
+    viewer: ViewerState & ViewerActions;
+    registerToolbarItem: (item: ToolbarItem) => void;
+    registerSidebarPanel: (panel: SidebarPanelConfig) => void;
+    registerContextMenuItem: (item: ContextMenuItem) => void;
+}
+interface ToolbarItem {
+    id: string;
+    position: 'left' | 'center' | 'right';
+    render: () => React.ReactNode;
+    order?: number;
+}
+interface SidebarPanelConfig {
+    id: string;
+    title: string;
+    icon: React.ReactNode;
+    render: () => React.ReactNode;
+}
+interface ContextMenuItem {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    onClick: () => void;
+    condition?: () => boolean;
+}
+interface PDFViewerEventMap {
+    pagechange: {
+        pageNumber: number;
+    };
+    scalechange: {
+        scale: number;
+    };
+    documentload: PDFDocumentLoadedEvent;
+    textselect: TextSelection;
+    error: Error;
+}
+
+/**
+ * Main PDF Viewer component.
+ *
+ * This component is SSR-safe and will only render on the client side.
+ * It uses React.lazy and Suspense to defer loading of the PDF viewer
+ * which depends on browser APIs.
+ *
+ * @example
+ * ```tsx
+ * import { PDFViewer } from '@pdf-reader/core';
+ *
+ * function App() {
+ *   return (
+ *     <PDFViewer
+ *       src="/document.pdf"
+ *       showToolbar
+ *       showSidebar
+ *       onDocumentLoad={(doc) => console.log('Loaded', doc.numPages, 'pages')}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare const PDFViewer: react.NamedExoticComponent<PDFViewerProps>;
+
+/**
+ * SSR-safe PDF Viewer component.
+ * Wraps the inner viewer with the context provider.
+ */
+declare const PDFViewerClient: react.NamedExoticComponent<PDFViewerProps>;
+
+interface DocumentContainerProps {
+    className?: string;
+    /** Enable touch gestures for mobile */
+    enableTouchGestures?: boolean;
+}
+declare const DocumentContainer: react.NamedExoticComponent<DocumentContainerProps>;
+
+interface VirtualizedDocumentContainerProps {
+    /** Number of pages to render above/below viewport */
+    overscan?: number;
+    /** Gap between pages in pixels */
+    pageGap?: number;
+    /** Enable touch gestures */
+    enableTouchGestures?: boolean;
+    className?: string;
+}
+declare const VirtualizedDocumentContainer: react.NamedExoticComponent<VirtualizedDocumentContainerProps>;
+
+interface ContinuousScrollContainerProps extends VirtualizedDocumentContainerProps {
+    /** Scroll to page smoothly */
+    smoothScroll?: boolean;
+}
+/**
+ * ContinuousScrollContainer is a convenience wrapper around VirtualizedDocumentContainer
+ * that provides continuous scrolling behavior with all pages visible in a single
+ * scrollable view.
+ *
+ * Features:
+ * - All pages rendered in a continuous scroll view
+ * - Virtualized rendering for performance (only visible pages + buffer are rendered)
+ * - Automatic page tracking based on scroll position
+ * - Scroll-to-page functionality
+ * - Memory management (unloads distant pages)
+ */
+declare const ContinuousScrollContainer: react.NamedExoticComponent<ContinuousScrollContainerProps>;
+
+interface DualPageContainerProps {
+    /** Show the first page alone (like a book cover) */
+    showCover?: boolean;
+    /** Book spread mode: odd pages on right side */
+    bookSpread?: boolean;
+    /** Gap between the two pages */
+    pageGap?: number;
+    /** Enable touch gestures */
+    enableTouchGestures?: boolean;
+    className?: string;
+}
+declare const DualPageContainer: react.NamedExoticComponent<DualPageContainerProps>;
+
+interface PDFPageProps {
+    pageNumber: number;
+    page: PDFPageProxy | null;
+    scale: number;
+    rotation: number;
+    className?: string;
+    showTextLayer?: boolean;
+    showHighlightLayer?: boolean;
+    showAnnotationLayer?: boolean;
+    onPageLoad?: (page: PDFPageProxy) => void;
+    onRenderComplete?: () => void;
+    onRenderError?: (error: Error) => void;
+    onAnnotationClick?: (annotation: Annotation) => void;
+    onPageClick?: (pageNumber: number, point: {
+        x: number;
+        y: number;
+    }) => void;
+}
+declare const PDFPage: react.NamedExoticComponent<PDFPageProps>;
+
+interface CanvasLayerProps {
+    page: PDFPageProxy;
+    scale: number;
+    rotation: number;
+    className?: string;
+    onRenderStart?: () => void;
+    onRenderComplete?: () => void;
+    onRenderError?: (error: Error) => void;
+}
+declare const CanvasLayer: react.NamedExoticComponent<CanvasLayerProps>;
+
+interface TextLayerProps {
+    page: PDFPageProxy;
+    scale: number;
+    rotation: number;
+    className?: string;
+}
+declare const TextLayer: react.NamedExoticComponent<TextLayerProps>;
+
+interface HighlightLayerProps {
+    highlights: Highlight[];
+    scale: number;
+    selectedId?: string | null;
+    onHighlightClick?: (highlight: Highlight) => void;
+    className?: string;
+}
+declare const HighlightLayer: react.NamedExoticComponent<HighlightLayerProps>;
+
+interface AnnotationLayerProps {
+    pageNumber: number;
+    annotations: Annotation[];
+    scale: number;
+    selectedId?: string | null;
+    isDrawing?: boolean;
+    currentDrawingPath?: DrawingPath | null;
+    drawingColor?: string;
+    drawingStrokeWidth?: number;
+    activeAnnotationTool?: 'note' | 'draw' | 'shape' | null;
+    onAnnotationClick?: (annotation: Annotation) => void;
+    onNoteClick?: (annotation: Annotation, event: {
+        x: number;
+        y: number;
+    }) => void;
+    onDrawStart?: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    onDrawMove?: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    onDrawEnd?: () => void;
+    onPageClick?: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    className?: string;
+}
+declare const AnnotationLayer: react.NamedExoticComponent<AnnotationLayerProps>;
+
+interface ToolbarProps {
+    className?: string;
+    showNavigation?: boolean;
+    showZoom?: boolean;
+    showRotation?: boolean;
+    showTheme?: boolean;
+    showSidebar?: boolean;
+    showFullscreen?: boolean;
+}
+declare const Toolbar: react.NamedExoticComponent<ToolbarProps>;
+
+interface MobileToolbarProps {
+    currentPage: number;
+    totalPages: number;
+    onPreviousPage: () => void;
+    onNextPage: () => void;
+    onGoToPage: (page: number) => void;
+    scale: number;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onToggleSidebar: () => void;
+    sidebarOpen: boolean;
+    theme: 'light' | 'dark' | 'sepia';
+    onThemeChange: (theme: 'light' | 'dark' | 'sepia') => void;
+    position?: 'top' | 'bottom';
+    className?: string;
+}
+declare const MobileToolbar: react.NamedExoticComponent<MobileToolbarProps>;
+
+interface SidebarProps {
+    className?: string;
+    width?: number;
+}
+declare const Sidebar: react.NamedExoticComponent<SidebarProps>;
+
+interface MobileSidebarProps {
+    isOpen: boolean;
+    onClose: () => void;
+    activePanel: SidebarPanel;
+    onPanelChange: (panel: SidebarPanel) => void;
+    children: React.ReactNode;
+    className?: string;
+}
+declare const MobileSidebar: react.NamedExoticComponent<MobileSidebarProps>;
+
+interface ThumbnailPanelProps {
+    className?: string;
+    thumbnailScale?: number;
+}
+declare const ThumbnailPanel: react.NamedExoticComponent<ThumbnailPanelProps>;
+
+interface SearchPanelProps {
+    className?: string;
+}
+declare const SearchPanel: react.NamedExoticComponent<SearchPanelProps>;
+
+interface OutlinePanelProps {
+    className?: string;
+}
+declare const OutlinePanel: react.NamedExoticComponent<OutlinePanelProps>;
+
+interface HighlightsPanelProps {
+    className?: string;
+    /** Callback when a highlight item is clicked */
+    onHighlightClick?: (highlight: Highlight) => void;
+}
+declare const HighlightsPanel: react.NamedExoticComponent<HighlightsPanelProps>;
+
+interface SelectionToolbarProps {
+    /** Current text selection */
+    selection: TextSelection | null;
+    /** Callback when a color is clicked to create highlight */
+    onCreateHighlight: (color: HighlightColor) => void;
+    /** Callback when copy button is clicked */
+    onCopy?: () => void;
+    /** Active/default highlight color */
+    activeColor?: HighlightColor;
+    /** Additional class name */
+    className?: string;
+}
+declare const SelectionToolbar: react.NamedExoticComponent<SelectionToolbarProps>;
+
+interface HighlightPopoverProps {
+    /** The highlight to show the popover for */
+    highlight: Highlight | null;
+    /** The scale of the PDF page */
+    scale: number;
+    /** The page element containing the highlight */
+    pageElement: HTMLElement | null;
+    /** Callback when color is changed */
+    onColorChange: (id: string, color: HighlightColor) => void;
+    /** Callback when comment is updated */
+    onCommentChange: (id: string, comment: string) => void;
+    /** Callback when delete is clicked */
+    onDelete: (id: string) => void;
+    /** Callback when copy is clicked */
+    onCopy?: (text: string) => void;
+    /** Callback when popover is closed */
+    onClose: () => void;
+    /** Additional class name */
+    className?: string;
+}
+declare const HighlightPopover: react.NamedExoticComponent<HighlightPopoverProps>;
+
+type AnnotationTool = 'note' | 'draw' | 'shape' | null;
+type ShapeType = 'rect' | 'circle' | 'arrow' | 'line';
+interface AnnotationState {
+    highlights: Highlight[];
+    annotations: Annotation[];
+    selectedHighlightId: string | null;
+    selectedAnnotationId: string | null;
+    activeHighlightColor: HighlightColor;
+    isHighlightMode: boolean;
+    isAnnotationMode: boolean;
+    activeAnnotationTool: AnnotationTool;
+    activeShapeType: ShapeType;
+    drawingColor: string;
+    drawingStrokeWidth: number;
+    currentDrawingPath: DrawingPath | null;
+    currentDrawingPage: number | null;
+}
+interface AnnotationActions {
+    addHighlight: (highlight: Omit<Highlight, 'id' | 'createdAt' | 'updatedAt'>) => Highlight;
+    updateHighlight: (id: string, updates: Partial<Highlight>) => void;
+    removeHighlight: (id: string) => void;
+    selectHighlight: (id: string | null) => void;
+    setActiveHighlightColor: (color: HighlightColor) => void;
+    getHighlightsByPage: (pageNumber: number) => Highlight[];
+    addAnnotation: (annotation: Omit<Annotation, 'id' | 'createdAt' | 'updatedAt'>) => Annotation;
+    updateAnnotation: (id: string, updates: Partial<Annotation>) => void;
+    removeAnnotation: (id: string) => void;
+    selectAnnotation: (id: string | null) => void;
+    getAnnotationsByPage: (pageNumber: number) => Annotation[];
+    setHighlightMode: (enabled: boolean) => void;
+    setAnnotationMode: (enabled: boolean) => void;
+    setActiveAnnotationTool: (tool: AnnotationTool) => void;
+    setActiveShapeType: (shapeType: ShapeType) => void;
+    setDrawingColor: (color: string) => void;
+    setDrawingStrokeWidth: (width: number) => void;
+    startDrawing: (pageNumber: number, point: {
+        x: number;
+        y: number;
+    }) => void;
+    addDrawingPoint: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    finishDrawing: () => Annotation | null;
+    cancelDrawing: () => void;
+    exportHighlights: () => string;
+    importHighlights: (json: string) => void;
+    exportAnnotations: () => string;
+    importAnnotations: (json: string) => void;
+    clearAll: () => void;
+}
+type AnnotationStore = AnnotationState & AnnotationActions;
+declare function createAnnotationStore(initialOverrides?: Partial<AnnotationState>): zustand.StoreApi<AnnotationStore>;
+type AnnotationStoreApi = ReturnType<typeof createAnnotationStore>;
+
+interface AnnotationToolbarProps {
+    /** Override the active tool from store */
+    activeTool?: AnnotationTool;
+    /** Override the active shape type from store */
+    activeShapeType?: ShapeType;
+    /** Override the drawing color from store */
+    drawingColor?: string;
+    /** Override the stroke width from store */
+    strokeWidth?: number;
+    /** Custom tool change handler */
+    onToolChange?: (tool: AnnotationTool) => void;
+    /** Custom shape type change handler */
+    onShapeTypeChange?: (shapeType: ShapeType) => void;
+    /** Custom color change handler */
+    onColorChange?: (color: string) => void;
+    /** Custom stroke width change handler */
+    onStrokeWidthChange?: (width: number) => void;
+    /** Position of the toolbar */
+    position?: 'top' | 'bottom' | 'floating';
+    /** Additional class name */
+    className?: string;
+}
+declare const AnnotationToolbar: react.NamedExoticComponent<AnnotationToolbarProps>;
+
+interface StickyNoteProps {
+    note: NoteAnnotation;
+    scale: number;
+    isSelected?: boolean;
+    isEditing?: boolean;
+    onSelect?: () => void;
+    onUpdate?: (updates: Partial<NoteAnnotation>) => void;
+    onDelete?: () => void;
+    onStartEdit?: () => void;
+    onEndEdit?: () => void;
+    onDragStart?: (e: React.MouseEvent | React.TouchEvent) => void;
+    className?: string;
+}
+declare const StickyNote: react.NamedExoticComponent<StickyNoteProps>;
+
+interface DrawingCanvasProps {
+    width: number;
+    height: number;
+    scale: number;
+    color?: string;
+    strokeWidth?: number;
+    isActive?: boolean;
+    onDrawingComplete?: (path: DrawingPath) => void;
+    className?: string;
+}
+declare const DrawingCanvas: react.NamedExoticComponent<DrawingCanvasProps>;
+
+interface ShapeRendererProps {
+    shape: ShapeAnnotation;
+    scale: number;
+    isSelected?: boolean;
+    isEditing?: boolean;
+    onSelect?: () => void;
+    onUpdate?: (updates: Partial<ShapeAnnotation>) => void;
+    onDelete?: () => void;
+    className?: string;
+}
+declare const ShapeRenderer: react.NamedExoticComponent<ShapeRendererProps>;
+interface ShapePreviewProps {
+    shapeType: 'rect' | 'circle' | 'arrow' | 'line';
+    startPoint: {
+        x: number;
+        y: number;
+    };
+    endPoint: {
+        x: number;
+        y: number;
+    };
+    scale: number;
+    color: string;
+    strokeWidth: number;
+}
+declare const ShapePreview: react.NamedExoticComponent<ShapePreviewProps>;
+
+interface PDFErrorBoundaryProps {
+    /** Child components to render */
+    children: ReactNode;
+    /** Custom fallback UI */
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    /** Callback when an error is caught */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /** Whether to show the default error UI */
+    showDefaultUI?: boolean;
+    className?: string;
+}
+interface PDFErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class PDFErrorBoundary extends Component<PDFErrorBoundaryProps, PDFErrorBoundaryState> {
+    constructor(props: PDFErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): PDFErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleReset: () => void;
+    render(): ReactNode;
+}
+interface WithErrorBoundaryProps extends Omit<PDFErrorBoundaryProps, 'children'> {
+    component: ReactNode;
+}
+declare function withErrorBoundary({ component, ...props }: WithErrorBoundaryProps): ReactNode;
+
+type ViewerStore = ViewerState & ViewerActions;
+declare function createViewerStore(initialOverrides?: Partial<ViewerState>): zustand.StoreApi<ViewerStore>;
+type ViewerStoreApi = ReturnType<typeof createViewerStore>;
+
+interface SearchActions {
+    setQuery: (query: string) => void;
+    search: (document: PDFDocumentProxy) => Promise<void>;
+    clearSearch: () => void;
+    nextResult: () => void;
+    previousResult: () => void;
+    goToResult: (index: number) => void;
+    toggleCaseSensitive: () => void;
+    toggleWholeWord: () => void;
+    getCurrentResult: () => SearchResult | null;
+}
+type SearchStore = SearchState & SearchActions;
+declare function createSearchStore(initialOverrides?: Partial<SearchState>): zustand.StoreApi<SearchStore>;
+type SearchStoreApi = ReturnType<typeof createSearchStore>;
+
+interface PDFViewerContextValue {
+    viewerStore: ViewerStoreApi;
+    annotationStore: AnnotationStoreApi;
+    searchStore: SearchStoreApi;
+}
+interface PDFViewerProviderProps {
+    children: ReactNode;
+    initialState?: {
+        viewer?: Partial<ViewerState>;
+        annotation?: Partial<AnnotationState>;
+        search?: Partial<SearchState>;
+    };
+    theme?: Theme;
+    defaultSidebarPanel?: SidebarPanel;
+}
+declare const PDFViewerContext: react.Context<PDFViewerContextValue | null>;
+declare function PDFViewerProvider({ children, initialState, theme, defaultSidebarPanel, }: PDFViewerProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the viewer store.
+ * Optionally pass a selector to subscribe to specific state.
+ */
+declare function useViewerStore<T>(selector: (state: ViewerStore) => T): T;
+/**
+ * Hook to access the annotation store.
+ * Optionally pass a selector to subscribe to specific state.
+ */
+declare function useAnnotationStore<T>(selector: (state: AnnotationStore) => T): T;
+/**
+ * Hook to access the search store.
+ * Optionally pass a selector to subscribe to specific state.
+ */
+declare function useSearchStore<T>(selector: (state: SearchStore) => T): T;
+/**
+ * Hook to access all stores directly (for actions).
+ */
+declare function usePDFViewerStores(): PDFViewerContextValue;
+
+type AddHighlightParams = Omit<Highlight, 'id' | 'createdAt' | 'updatedAt'>;
+/**
+ * Main unified hook for accessing PDF viewer state and actions.
+ * This is the primary API for controlling the viewer.
+ */
+declare function usePDFViewer(): {
+    document: pdfjs_dist_types_src_display_api.PDFDocumentProxy | null;
+    numPages: number;
+    isLoading: boolean;
+    error: Error | null;
+    currentPage: number;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    previousPage: () => void;
+    scale: number;
+    setScale: (newScale: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    fitToWidth: () => void;
+    fitToPage: () => void;
+    rotation: number;
+    rotateClockwise: () => void;
+    rotateCounterClockwise: () => void;
+    theme: Theme;
+    setTheme: (newTheme: Theme) => void;
+    viewMode: ViewMode;
+    setViewMode: (mode: ViewMode) => void;
+    sidebarOpen: boolean;
+    toggleSidebar: () => void;
+    sidebarPanel: SidebarPanel;
+    setSidebarPanel: (panel: SidebarPanel) => void;
+    isFullscreen: boolean;
+    setFullscreen: (fullscreen: boolean) => void;
+    highlights: Highlight[];
+    selectedHighlightId: string | null;
+    activeHighlightColor: HighlightColor;
+    isHighlightMode: boolean;
+    addHighlight: (highlight: AddHighlightParams) => Highlight;
+    removeHighlight: (id: string) => void;
+    setActiveHighlightColor: (color: HighlightColor) => void;
+    setHighlightMode: (enabled: boolean) => void;
+    annotations: Annotation[];
+    searchQuery: string;
+    searchResults: SearchResult[];
+    currentSearchResult: number;
+    isSearching: boolean;
+    search: (query: string) => Promise<void>;
+    clearSearch: () => void;
+    nextSearchResult: () => void;
+    previousSearchResult: () => void;
+};
+
+interface UsePageNavigationOptions {
+    enableKeyboardNavigation?: boolean;
+}
+/**
+ * Hook for page navigation functionality.
+ */
+declare function usePageNavigation(options?: UsePageNavigationOptions): {
+    currentPage: number;
+    numPages: number;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    previousPage: () => void;
+    goToFirstPage: () => void;
+    goToLastPage: () => void;
+    canGoNext: boolean;
+    canGoPrevious: boolean;
+};
+
+interface UseZoomOptions {
+    enableWheelZoom?: boolean;
+    minScale?: number;
+    maxScale?: number;
+}
+/**
+ * Hook for zoom functionality.
+ */
+declare function useZoom(options?: UseZoomOptions): {
+    scale: number;
+    setScale: (newScale: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    fitToWidth: () => void;
+    fitToPage: () => void;
+    resetZoom: () => void;
+    setContainerRef: (el: HTMLElement | null) => void;
+    scalePercentage: number;
+};
+
+interface UseTextSelectionOptions {
+    onSelect?: (selection: TextSelection) => void;
+    onCopy?: (text: string) => void;
+}
+/**
+ * Hook for handling text selection in the PDF viewer.
+ */
+declare function useTextSelection(options?: UseTextSelectionOptions): {
+    selection: TextSelection | null;
+    isSelecting: boolean;
+    clearSelection: () => void;
+    copySelection: () => void;
+    hasSelection: boolean;
+};
+
+interface UseHighlightsOptions {
+    /** Callback when a highlight is created */
+    onHighlightCreate?: (highlight: Highlight) => void;
+    /** Callback when a highlight is updated */
+    onHighlightUpdate?: (highlight: Highlight) => void;
+    /** Callback when a highlight is deleted */
+    onHighlightDelete?: (id: string) => void;
+}
+interface UseHighlightsReturn {
+    /** Create a highlight from the current text selection */
+    createHighlightFromSelection: (selection: TextSelection, pageElement: HTMLElement, scale: number, color?: HighlightColor) => Highlight | null;
+    /**
+     * Add a highlight programmatically with coordinates.
+     * Coordinates should be in PDF points (not scaled).
+     *
+     * @example
+     * ```tsx
+     * addHighlight({
+     *   pageNumber: 1,
+     *   rects: [{ x: 100, y: 200, width: 150, height: 20 }],
+     *   text: "Highlighted text",
+     *   color: "yellow"
+     * });
+     * ```
+     */
+    addHighlight: (highlight: {
+        pageNumber: number;
+        rects: HighlightRect[];
+        text: string;
+        color?: HighlightColor;
+        comment?: string;
+    }) => Highlight;
+    /** Update an existing highlight */
+    updateHighlight: (id: string, updates: Partial<Pick<Highlight, 'color' | 'comment'>>) => void;
+    /** Delete a highlight */
+    deleteHighlight: (id: string) => void;
+    /** Get highlights for a specific page */
+    highlightsForPage: (pageNumber: number) => Highlight[];
+    /** Get all highlights */
+    allHighlights: Highlight[];
+    /** Get the currently selected highlight */
+    selectedHighlight: Highlight | null;
+    /** Select a highlight by ID */
+    selectHighlight: (id: string | null) => void;
+    /** Get the active highlight color */
+    activeColor: HighlightColor;
+    /** Set the active highlight color */
+    setActiveColor: (color: HighlightColor) => void;
+}
+/**
+ * Hook for creating and managing highlights from text selections.
+ */
+declare function useHighlights(options?: UseHighlightsOptions): UseHighlightsReturn;
+
+interface UseAnnotationsOptions {
+    onAnnotationCreate?: (annotation: Annotation) => void;
+    onAnnotationUpdate?: (annotation: Annotation) => void;
+    onAnnotationDelete?: (id: string) => void;
+}
+interface UseAnnotationsReturn {
+    annotations: Annotation[];
+    selectedAnnotation: Annotation | undefined;
+    selectedAnnotationId: string | null;
+    activeTool: AnnotationTool;
+    activeShapeType: ShapeType;
+    drawingColor: string;
+    drawingStrokeWidth: number;
+    isDrawing: boolean;
+    currentDrawingPath: {
+        points: {
+            x: number;
+            y: number;
+        }[];
+    } | null;
+    currentDrawingPage: number | null;
+    setActiveTool: (tool: AnnotationTool) => void;
+    setActiveShapeType: (shapeType: ShapeType) => void;
+    setDrawingColor: (color: string) => void;
+    setDrawingStrokeWidth: (width: number) => void;
+    createNote: (pageNumber: number, x: number, y: number, content?: string, color?: string) => NoteAnnotation;
+    updateNote: (id: string, updates: Partial<NoteAnnotation>) => void;
+    startDrawing: (pageNumber: number, point: {
+        x: number;
+        y: number;
+    }) => void;
+    continueDrawing: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    finishDrawing: () => Annotation | null;
+    cancelDrawing: () => void;
+    /**
+     * Create a shape annotation programmatically.
+     * Coordinates should be in PDF points (not scaled).
+     *
+     * @example
+     * ```tsx
+     * // Create a red rectangle box annotation
+     * createShape({
+     *   pageNumber: 1,
+     *   shapeType: 'rect',
+     *   x: 100,
+     *   y: 200,
+     *   width: 150,
+     *   height: 80,
+     *   color: '#ef4444',
+     *   strokeWidth: 2
+     * });
+     * ```
+     */
+    createShape: (options: {
+        pageNumber: number;
+        shapeType: ShapeType;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        color?: string;
+        strokeWidth?: number;
+    }) => ShapeAnnotation;
+    updateShape: (id: string, updates: Partial<ShapeAnnotation>) => void;
+    selectAnnotation: (id: string | null) => void;
+    deleteAnnotation: (id: string) => void;
+    getAnnotationsByPage: (pageNumber: number) => Annotation[];
+    exportAnnotations: () => string;
+    importAnnotations: (json: string) => void;
+}
+declare function useAnnotations(options?: UseAnnotationsOptions): UseAnnotationsReturn;
+
+interface UseTouchGesturesOptions {
+    /** Callback when pinch-to-zoom is detected */
+    onPinchZoom?: (scale: number, center: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Callback when swipe left is detected */
+    onSwipeLeft?: () => void;
+    /** Callback when swipe right is detected */
+    onSwipeRight?: () => void;
+    /** Callback when long press is detected */
+    onLongPress?: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Callback when double tap is detected */
+    onDoubleTap?: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Minimum swipe distance in pixels */
+    swipeThreshold?: number;
+    /** Long press duration in milliseconds */
+    longPressDuration?: number;
+    /** Double tap max interval in milliseconds */
+    doubleTapInterval?: number;
+    /** Whether gestures are enabled */
+    enabled?: boolean;
+}
+declare function useTouchGestures<T extends HTMLElement = HTMLElement>(options?: UseTouchGesturesOptions): {
+    ref: (element: T | null) => void;
+    elementRef: react.MutableRefObject<T | null>;
+};
+declare function useIsTouchDevice(): boolean;
+declare function useIsMobile(): boolean;
+
+interface PluginManagerOptions {
+    /** Callback when a plugin is registered */
+    onPluginRegistered?: (plugin: Plugin) => void;
+    /** Callback when a plugin is unregistered */
+    onPluginUnregistered?: (name: string) => void;
+    /** Callback when toolbar items change */
+    onToolbarItemsChanged?: (items: ToolbarItem[]) => void;
+    /** Callback when sidebar panels change */
+    onSidebarPanelsChanged?: (panels: SidebarPanelConfig[]) => void;
+    /** Callback when context menu items change */
+    onContextMenuItemsChanged?: (items: ContextMenuItem[]) => void;
+}
+declare class PluginManager {
+    private plugins;
+    private toolbarItems;
+    private sidebarPanels;
+    private contextMenuItems;
+    private viewerStateGetter;
+    private options;
+    constructor(options?: PluginManagerOptions);
+    /**
+     * Set the getter function for viewer state
+     */
+    setViewerStateGetter(getter: () => ViewerState & ViewerActions): void;
+    /**
+     * Create the plugin API for a specific plugin
+     */
+    private createPluginAPI;
+    /**
+     * Register a plugin
+     */
+    register(plugin: Plugin): Promise<void>;
+    /**
+     * Unregister a plugin
+     */
+    unregister(name: string): Promise<void>;
+    /**
+     * Get a registered plugin by name
+     */
+    getPlugin(name: string): Plugin | undefined;
+    /**
+     * Get all registered plugins
+     */
+    getAllPlugins(): Plugin[];
+    /**
+     * Check if a plugin is registered
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Get all toolbar items from all plugins
+     */
+    getToolbarItems(): ToolbarItem[];
+    /**
+     * Get toolbar items by position
+     */
+    getToolbarItemsByPosition(position: 'left' | 'center' | 'right'): ToolbarItem[];
+    /**
+     * Get all sidebar panels from all plugins
+     */
+    getSidebarPanels(): SidebarPanelConfig[];
+    /**
+     * Get all context menu items from all plugins
+     */
+    getContextMenuItems(): ContextMenuItem[];
+    /**
+     * Destroy all plugins and clean up
+     */
+    destroy(): Promise<void>;
+    private notifyToolbarItemsChanged;
+    private notifySidebarPanelsChanged;
+    private notifyContextMenuItemsChanged;
+}
+declare function getPluginManager(): PluginManager;
+declare function createPluginManager(options?: PluginManagerOptions): PluginManager;
+
+interface UsePluginsOptions extends PluginManagerOptions {
+    /** Initial plugins to register */
+    initialPlugins?: Plugin[];
+}
+interface UsePluginsReturn {
+    /** The plugin manager instance */
+    pluginManager: PluginManager;
+    /** All registered plugins */
+    plugins: Plugin[];
+    /** Toolbar items from plugins */
+    toolbarItems: ToolbarItem[];
+    /** Sidebar panels from plugins */
+    sidebarPanels: SidebarPanelConfig[];
+    /** Context menu items from plugins */
+    contextMenuItems: ContextMenuItem[];
+    /** Register a plugin */
+    registerPlugin: (plugin: Plugin) => Promise<void>;
+    /** Unregister a plugin by name */
+    unregisterPlugin: (name: string) => Promise<void>;
+    /** Check if a plugin is registered */
+    hasPlugin: (name: string) => boolean;
+}
+declare function usePlugins(options?: UsePluginsOptions): UsePluginsReturn;
+
+/**
+ * Utility for merging class names with support for conditionals.
+ * Uses clsx under the hood.
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+interface PDFJSInitOptions {
+    /** Custom worker source URL */
+    workerSrc?: string;
+    /** Whether to use the fake worker (for testing) */
+    useFakeWorker?: boolean;
+}
+/**
+ * Initialize pdf.js with the worker.
+ * This should be called before loading any PDFs.
+ */
+declare function initializePDFJS(options?: PDFJSInitOptions): Promise<void>;
+/**
+ * Check if pdf.js is initialized
+ */
+declare function isPDFJSInitialized(): boolean;
+
+interface LoadDocumentOptions {
+    /** URL or data of the PDF */
+    src: string | ArrayBuffer | Uint8Array;
+    /** Custom worker source */
+    workerSrc?: string;
+    /** Password for encrypted PDFs */
+    password?: string;
+    /** Callback for loading progress */
+    onProgress?: (progress: {
+        loaded: number;
+        total: number;
+    }) => void;
+}
+interface LoadDocumentResult {
+    document: PDFDocumentProxy;
+    numPages: number;
+}
+/**
+ * Load a PDF document from a URL or data buffer.
+ */
+declare function loadDocument(options: LoadDocumentOptions): Promise<LoadDocumentResult>;
+/**
+ * Get a specific page from a PDF document.
+ */
+declare function getPage(document: PDFDocumentProxy, pageNumber: number): Promise<PDFPageProxy>;
+/**
+ * Get text content from a PDF page.
+ */
+declare function getPageTextContent(page: PDFPageProxy): Promise<pdfjs_dist_types_src_display_api.TextContent>;
+/**
+ * Get the outline (table of contents) from a PDF document.
+ */
+declare function getOutline(document: PDFDocumentProxy): Promise<{
+    title: string;
+    bold: boolean;
+    italic: boolean;
+    color: Uint8ClampedArray;
+    dest: string | Array<any> | null;
+    url: string | null;
+    unsafeUrl: string | undefined;
+    newWindow: boolean | undefined;
+    count: number | undefined;
+    items: Array<any>;
+}[]>;
+/**
+ * Get metadata from a PDF document.
+ */
+declare function getMetadata(document: PDFDocumentProxy): Promise<{
+    info: Object;
+    metadata: pdfjs_dist_types_src_display_metadata.Metadata;
+}>;
+
+/**
+ * Save highlights to localStorage for a specific document.
+ *
+ * @param documentId - Unique identifier for the document (e.g., URL hash, filename)
+ * @param highlights - Array of highlights to save
+ * @returns true if save succeeded, false otherwise
+ */
+declare function saveHighlights(documentId: string, highlights: Highlight[]): boolean;
+/**
+ * Load highlights from localStorage for a specific document.
+ *
+ * @param documentId - Unique identifier for the document
+ * @returns Array of highlights, empty array if none found or error
+ */
+declare function loadHighlights(documentId: string): Highlight[];
+/**
+ * Remove all highlights for a specific document from localStorage.
+ *
+ * @param documentId - Unique identifier for the document
+ * @returns true if removal succeeded, false otherwise
+ */
+declare function clearHighlights(documentId: string): boolean;
+/**
+ * Get all document IDs that have stored highlights.
+ *
+ * @returns Array of document IDs
+ */
+declare function getAllDocumentIds(): string[];
+/**
+ * Export highlights as a JSON string.
+ * Includes metadata for import/export portability.
+ *
+ * @param highlights - Array of highlights to export
+ * @returns JSON string representation
+ */
+declare function exportHighlightsAsJSON(highlights: Highlight[]): string;
+/**
+ * Import highlights from a JSON string.
+ *
+ * @param json - JSON string to import
+ * @returns Array of highlights, or null if invalid
+ */
+declare function importHighlightsFromJSON(json: string): Highlight[] | null;
+/**
+ * Export highlights as Markdown format.
+ * Groups by page and includes text, comments, and metadata.
+ *
+ * @param highlights - Array of highlights to export
+ * @param documentTitle - Optional document title for the header
+ * @returns Markdown string representation
+ */
+declare function exportHighlightsAsMarkdown(highlights: Highlight[], documentTitle?: string): string;
+/**
+ * Generate a document ID from a URL or file path.
+ * Creates a consistent hash for the same document.
+ *
+ * @param source - URL or file path
+ * @returns Document ID string
+ */
+declare function generateDocumentId(source: string | ArrayBuffer | Uint8Array): string;
+
+interface PDFViewerControllerOptions {
+    /** Initial page number */
+    initialPage?: number;
+    /** Initial scale/zoom level */
+    initialScale?: number;
+    /** Theme mode */
+    theme?: Theme;
+    /** Whether to show the toolbar */
+    showToolbar?: boolean;
+    /** Whether to show the sidebar */
+    showSidebar?: boolean;
+    /** Custom onDocumentLoad callback */
+    onDocumentLoad?: (doc: PDFDocumentProxy) => void;
+    /** Custom onPageChange callback */
+    onPageChange?: (page: number) => void;
+    /** Custom onScaleChange callback */
+    onScaleChange?: (scale: number) => void;
+    /** Custom onError callback */
+    onError?: (error: Error) => void;
+    /** PDF source - URL, ArrayBuffer, or Uint8Array */
+    src?: string | ArrayBuffer | Uint8Array;
+}
+interface PDFViewerController {
+    loadDocument(src: string | ArrayBuffer | Uint8Array): Promise<void>;
+    getDocument(): PDFDocumentProxy | null;
+    goToPage(page: number): void;
+    nextPage(): void;
+    previousPage(): void;
+    getCurrentPage(): number;
+    getTotalPages(): number;
+    setZoom(scale: number): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    fitToWidth(): void;
+    fitToPage(): void;
+    getZoom(): number;
+    setRotation(rotation: number): void;
+    rotateClockwise(): void;
+    rotateCounterClockwise(): void;
+    getRotation(): number;
+    setTheme(theme: Theme): void;
+    getTheme(): Theme;
+    setViewMode(mode: ViewMode): void;
+    getViewMode(): ViewMode;
+    toggleSidebar(): void;
+    setSidebarPanel(panel: SidebarPanel): void;
+    isSidebarOpen(): boolean;
+    getHighlights(): Highlight[];
+    addHighlight(highlight: Omit<Highlight, 'id' | 'createdAt' | 'updatedAt'>): Highlight;
+    removeHighlight(id: string): void;
+    exportHighlights(): string;
+    importHighlights(json: string): void;
+    getAnnotations(): Annotation[];
+    addAnnotation(annotation: Omit<Annotation, 'id' | 'createdAt' | 'updatedAt'>): Annotation;
+    removeAnnotation(id: string): void;
+    exportAnnotations(): string;
+    importAnnotations(json: string): void;
+    on<K extends keyof PDFViewerEventHandlers>(event: K, handler: PDFViewerEventHandlers[K]): () => void;
+    destroy(): void;
+}
+interface PDFViewerEventHandlers {
+    pagechange: (page: number) => void;
+    scalechange: (scale: number) => void;
+    documentload: (doc: PDFDocumentProxy) => void;
+    error: (error: Error) => void;
+}
+/**
+ * Create a PDF viewer instance for non-React usage
+ */
+declare function createPDFViewer(container: HTMLElement, options?: PDFViewerControllerOptions): PDFViewerController;
+/**
+ * Initialize a PDF viewer with minimal configuration
+ */
+declare function quickViewer(container: HTMLElement | string, src: string | ArrayBuffer | Uint8Array, options?: Partial<PDFViewerControllerOptions>): Promise<PDFViewerController>;
+
+export { type Annotation, type AnnotationActions, AnnotationLayer, type AnnotationLayerProps, type AnnotationState, type AnnotationStore, type AnnotationStoreApi, type AnnotationTool, AnnotationToolbar, type AnnotationToolbarProps, type AnnotationType, CanvasLayer, type CanvasLayerProps, type ContextMenuItem, ContinuousScrollContainer, type ContinuousScrollContainerProps, DocumentContainer, type DocumentContainerProps, type DrawingAnnotation, DrawingCanvas, type DrawingCanvasProps, type DrawingPath, DualPageContainer, type DualPageContainerProps, type Highlight, type HighlightColor, HighlightLayer, type HighlightLayerProps, HighlightPopover, type HighlightPopoverProps, type HighlightRect, HighlightsPanel, type HighlightsPanelProps, type LoadDocumentOptions, type LoadDocumentResult, MobileSidebar, type MobileSidebarProps, MobileToolbar, type MobileToolbarProps, type NoteAnnotation, type OutlineItem, OutlinePanel, type OutlinePanelProps, type PDFDocumentLoadedEvent, PDFErrorBoundary, type PDFErrorBoundaryProps, PDFPage, type PDFPageProps, type PDFPageState, PDFViewer, PDFViewerClient, PDFViewerContext, type PDFViewerContextValue, type PDFViewerController, type PDFViewerControllerOptions, type PDFViewerEventMap, type PDFViewerProps, PDFViewerProvider, type PDFViewerProviderProps, type PageDimensions, type Plugin, type PluginAPI, PluginManager, type PluginManagerOptions, type ScrollMode, type SearchActions, SearchPanel, type SearchPanelProps, type SearchResult, type SearchState, type SearchStore, type SearchStoreApi, SelectionToolbar, type SelectionToolbarProps, type ShapeAnnotation, ShapePreview, type ShapePreviewProps, ShapeRenderer, type ShapeRendererProps, type ShapeType, Sidebar, type SidebarPanel, type SidebarPanelConfig, type SidebarProps, StickyNote, type StickyNoteProps, TextLayer, type TextLayerProps, type TextSelection, type Theme, ThumbnailPanel, type ThumbnailPanelProps, Toolbar, type ToolbarItem, type ToolbarProps, type UseAnnotationsOptions, type UseAnnotationsReturn, type UseHighlightsOptions, type UseHighlightsReturn, type UsePageNavigationOptions, type UsePluginsOptions, type UsePluginsReturn, type UseTextSelectionOptions, type UseTouchGesturesOptions, type UseZoomOptions, type ViewMode, type ViewerActions, type ViewerState, type ViewerStore, type ViewerStoreApi, VirtualizedDocumentContainer, type VirtualizedDocumentContainerProps, type WithErrorBoundaryProps, clearHighlights, cn, createAnnotationStore, createPDFViewer, createPluginManager, createSearchStore, createViewerStore, exportHighlightsAsJSON, exportHighlightsAsMarkdown, generateDocumentId, getAllDocumentIds, getMetadata, getOutline, getPage, getPageTextContent, getPluginManager, importHighlightsFromJSON, initializePDFJS, isPDFJSInitialized, loadDocument, loadHighlights, quickViewer, saveHighlights, useAnnotationStore, useAnnotations, useHighlights, useIsMobile, useIsTouchDevice, usePDFViewer, usePDFViewerStores, usePageNavigation, usePlugins, useSearchStore, useTextSelection, useTouchGestures, useViewerStore, useZoom, withErrorBoundary };