/**
 * Type definitions for Barymont PDF Viewer
 */
interface PDFDocumentProxy {
    numPages: number;
    getPage(pageNumber: number): Promise<PDFPageProxy>;
}
interface PDFPageProxy {
    getViewport(options: {
        scale: number;
    }): PDFPageViewport;
    render(options: RenderParameters): RenderTask;
}
interface PDFPageViewport {
    width: number;
    height: number;
}
interface RenderParameters {
    canvasContext: CanvasRenderingContext2D;
    viewport: PDFPageViewport;
}
interface RenderTask {
    promise: Promise<void>;
}
interface PDFJSStatic {
    getDocument(src: string | {
        data: ArrayBuffer;
    }): {
        promise: Promise<PDFDocumentProxy>;
    };
    GlobalWorkerOptions: {
        workerSrc: string;
    };
}
interface ViewerOptions {
    theme?: 'default' | 'dark' | 'minimal';
    height?: string;
    width?: string;
    enableControls?: boolean;
    enableKeyboard?: boolean;
    enableZoom?: boolean;
    enableOpenPdf?: boolean;
    enableGestureNavigation?: boolean;
    defaultScale?: number;
    minScale?: number;
    maxScale?: number;
    pdfjsVersion?: string;
    locale?: 'en' | 'es';
}
interface ViewerState {
    pdfDoc: PDFDocumentProxy | null;
    currentPage: number;
    scale: number;
    isRendering: boolean;
    isLoading: boolean;
}
interface ViewerElements {
    viewer?: HTMLElement | undefined;
    canvas?: HTMLCanvasElement | undefined;
    context?: CanvasRenderingContext2D | undefined;
    loading?: HTMLElement | undefined;
    error?: HTMLElement | undefined;
    errorMessage?: HTMLElement | undefined;
    retryBtn?: HTMLElement | undefined;
    controls?: {
        prev?: HTMLButtonElement | undefined;
        next?: HTMLButtonElement | undefined;
        pageInput?: HTMLInputElement | undefined;
        pageCount?: HTMLElement | undefined;
        zoomOut?: HTMLButtonElement | undefined;
        zoomIn?: HTMLButtonElement | undefined;
        zoomSelect?: HTMLSelectElement | undefined;
        openPdf?: HTMLButtonElement | undefined;
    } | undefined;
}
type ContainerInput = string | HTMLElement;
interface PDFUtils {
    waitForDOM(): Promise<void>;
    waitForContainer(selector: string, timeout?: number): Promise<HTMLElement>;
}
type ViewerFactory = (container: ContainerInput, pdfUrl?: string | null, options?: ViewerOptions) => Promise<IBarymontPDFViewer>;
interface IBarymontPDFViewer {
    readonly container: HTMLElement;
    readonly options: Required<ViewerOptions>;
    readonly state: ViewerState;
    readonly elements: ViewerElements;
    init(): Promise<void>;
    loadPDF(url: string): Promise<void>;
    destroy(): void;
    previousPage(): void;
    nextPage(): void;
    goToPage(pageNum: number): void;
    zoomIn(): void;
    zoomOut(): void;
    setScale(scale: number): void;
    fitToWidth(): Promise<void>;
    getCurrentPage(): number;
    getTotalPages(): number;
    getScale(): number;
    getPDFDocument(): PDFDocumentProxy | null;
    getLocale(): string;
    setLocale(locale: 'en' | 'es'): void;
}
interface BarymontPDFViewerModule {
    BarymontPDFViewer: new (container: ContainerInput, options?: ViewerOptions) => IBarymontPDFViewer;
    createBarymontPDFViewer: ViewerFactory;
    PDFJSLoader: {
        load: (version?: string) => Promise<PDFJSStatic>;
    };
    BarymontPDFUtils: PDFUtils;
}
declare global {
    interface Window {
        pdfjsLib?: PDFJSStatic;
        BarymontPDFViewer?: new (container: ContainerInput, options?: ViewerOptions) => IBarymontPDFViewer;
        createBarymontPDFViewer?: ViewerFactory;
        PDFJSLoader?: {
            load: (version?: string) => Promise<PDFJSStatic>;
            reset: () => void;
        };
        BarymontPDFUtils?: PDFUtils;
    }
    var pdfjsLib: PDFJSStatic | undefined;
}

/**
 * Barymont PDF Viewer
 */
declare class BarymontPDFViewer implements IBarymontPDFViewer {
    readonly container: HTMLElement;
    readonly options: Required<ViewerOptions>;
    readonly state: ViewerState;
    readonly elements: ViewerElements;
    private shadowRoot;
    private root;
    private lastPdfUrl;
    private resizeObserver;
    private i18n;
    private touchStartX;
    private touchStartY;
    private touchEndX;
    private touchEndY;
    private minSwipeDistance;
    private isZoomed;
    private manualZoomChange;
    private isDragging;
    private dragStartX;
    private dragStartY;
    private lastDragX;
    private lastDragY;
    private minDragDistance;
    private resizeTimeout;
    /**
     * Create a new PDF viewer instance
     * @param container - Container element or selector
     * @param options - Viewer configuration options
     */
    constructor(container: ContainerInput, options?: ViewerOptions);
    /**
     * Initialize the viewer
     */
    init(): Promise<void>;
    /**
     * Create HTML structure with Shadow DOM for style isolation
     */
    private createHTML;
    /**
     * Create toolbar HTML
     */
    private createToolbar;
    /**
     * Store references to DOM elements
     */
    private storeElementReferences;
    /**
     * Apply styles to the main container
     */
    private applyContainerStyles;
    /**
     * Setup event listeners
     */
    private setupEvents;
    /**
     * Setup control event listeners
     */
    private setupControlEvents;
    /**
     * Setup keyboard event listeners
     */
    private setupKeyboardEvents;
    /**
     * Setup gesture navigation event listeners for mobile devices
     */
    private setupGestureEvents;
    /**
     * Setup mouse drag events for desktop
     */
    private setupMouseDragEvents;
    /**
     * Check if the PDF is currently zoomed beyond fit-to-width
     */
    private checkZoomState;
    /**
     * Update touch-action CSS based on zoom state
     */
    private updateTouchAction;
    /**
     * Handle swipe gesture for page navigation
     */
    private handleSwipeGesture;
    /**
     * Start drag operation
     */
    private startDrag;
    /**
     * Handle drag movement
     */
    private handleDrag;
    /**
     * End drag operation
     */
    private endDrag;
    /**
     * Check if keyboard events should be handled
     */
    private shouldHandleKeyboardEvent;
    /**
     * Setup resize observer for responsive behavior
     */
    private setupResizeObserver;
    /**
     * Load a PDF from URL
     * @param url - URL of the PDF to load
     */
    loadPDF(url: string): Promise<void>;
    /**
     * Render a specific page
     * @param pageNum - Page number to render (1-based)
     */
    renderPage(pageNum: number): Promise<void>;
    /**
     * Update control states
     */
    updateControls(): void;
    previousPage(): void;
    nextPage(): void;
    goToPage(pageNum: number): void;
    zoomIn(): void;
    zoomOut(): void;
    setScale(scale: number, updateSelector?: boolean): void;
    fitToWidth(): Promise<void>;
    showLoading(): void;
    hideLoading(): void;
    showError(message: string): void;
    getCurrentPage(): number;
    getTotalPages(): number;
    getScale(): number;
    getPDFDocument(): PDFDocumentProxy | null;
    /**
     * Get current locale
     */
    getLocale(): string;
    /**
     * Set locale and refresh UI
     * @param locale - Locale to set ('en' or 'es')
     */
    setLocale(locale: 'en' | 'es'): void;
    /**
     * Setup focus prevention event listeners
     */
    private setupFocusPrevention;
    /**
     * Remove focus from the viewer and all its elements
     */
    private removeFocus;
    /**
     * Open the current PDF document
     */
    openPDF(): void;
    /**
     * Clean up resources and event listeners
     */
    destroy(): void;
}

/**
 * PDF.js Loader
 * Handles dynamic loading of PDF.js library
 */

/**
 * Load PDF.js
 * @param version - PDF.js version to load
 * @returns Promise that resolves to PDF.js library
 */
declare function load(version?: string): Promise<PDFJSStatic>;
declare const PDFJSLoader: {
    load: typeof load;
};

/**
 * Utility functions for Barymont PDF Viewer
 */

/**
 * Utility functions for PDF viewer operations
 */
declare const BarymontPDFUtils: PDFUtils;

/**
 * Factory function for creating PDF viewer instances
 */

/**
 * Factory function to create and initialize a PDF viewer
 * @param container - Container element or selector
 * @param pdfUrl - Optional PDF URL to load immediately
 * @param options - Viewer configuration options
 * @returns Promise that resolves to initialized viewer instance
 */
declare const createBarymontPDFViewer: ViewerFactory;

/**
 * Internationalization (i18n) system for Barymont PDF Viewer
 */
type SupportedLocale = 'en' | 'es';
interface TranslationKeys {
    loadingPdf: string;
    errorLoadingPdf: string;
    retry: string;
    previousPage: string;
    previous: string;
    page: string;
    of: string;
    nextPage: string;
    next: string;
    zoomOut: string;
    zoomIn: string;
    zoomLevel: string;
    fit: string;
    zoom50: string;
    zoom75: string;
    zoom100: string;
    zoom125: string;
    zoom150: string;
    zoom200: string;
    open: string;
    openPdf: string;
    errorInitializing: string;
}
/**
 * I18n class for managing translations
 */
declare class I18n {
    private currentLocale;
    private currentTranslations;
    constructor(locale?: SupportedLocale);
    /**
     * Get current locale
     */
    getLocale(): SupportedLocale;
    /**
     * Set current locale
     * @param locale - Locale to set
     */
    setLocale(locale: SupportedLocale): void;
    /**
     * Translate a key
     * @param key - Translation key
     * @param params - Optional parameters for string interpolation
     * @returns Translated string
     */
    t(key: keyof TranslationKeys, params?: Record<string, string | number>): string;
    /**
     * Get all available locales
     */
    static getAvailableLocales(): SupportedLocale[];
}

/**
 * Barymont PDF Viewer v1.0
 * A PDF viewer built on top of PDF.js with Barymont branding
 *
 * @version 1.0.0
 * @author Barymont Development Team
 * @license MIT
 */

/**
 * Module object containing all exports
 * Useful for environments that prefer object-style imports
 */
declare const BarymontPDFViewerLib: BarymontPDFViewerModule;

export { BarymontPDFUtils, BarymontPDFViewer, BarymontPDFViewerLib, I18n, PDFJSLoader, createBarymontPDFViewer, BarymontPDFViewer as default };
export type { BarymontPDFViewerModule, ContainerInput, PDFDocumentProxy, PDFJSStatic, PDFPageProxy, PDFPageViewport, SupportedLocale, TranslationKeys, ViewerElements, ViewerFactory, ViewerOptions, ViewerState };