@progress/kendo-react-pdf-viewer 5.10.0-dev.202211241147

package/dist/cdn/js/kendo-react-pdf-viewer.js.LICENSE.txt

@@ -0,0 +1,21 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * JavaScript code in this page
+ *
+ * Copyright 2022 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * JavaScript code in this page
+ */

package/dist/es/PDFViewer.d.ts

@@ -0,0 +1,138 @@
+import * as React from 'react';
+import { Toolbar } from '@progress/kendo-react-buttons';
+import { SaveOptions } from '@progress/kendo-file-saver';
+import { TypedArray } from 'pdfjs-dist/types/src/display/api';
+import 'pdfjs-dist/build/pdf.worker.entry';
+interface PDFViewerEvent {
+    /**
+     * The event target object.
+     */
+    target: PDFViewerHandle;
+}
+/**
+ * The KendoReact [PDFViewer]({% slug api_pdf-viewer_pdfviewer %}) ErrorEvent object.
+ */
+export interface ErrorEvent extends PDFViewerEvent {
+    /**
+     * The raised error.
+     */
+    error: Error | {
+        message: string;
+    };
+}
+/**
+ * The KendoReact [PDFViewer]({% slug api_pdf-viewer_pdfviewer %}) DownloadEvent object.
+ */
+export interface DownloadEvent extends PDFViewerEvent {
+    /**
+     * The Blob object.
+     */
+    blob: Blob;
+    /**
+     * The name which will be used for saving the file.
+     */
+    fileName: string;
+    /**
+     * The options which will be used for saving the file.
+     */
+    saveOptions: SaveOptions;
+}
+/**
+ * The KendoReact [PDFViewer]({% slug api_pdf-viewer_pdfviewer %}) LoadEvent object.
+ */
+export interface LoadEvent extends PDFViewerEvent {
+}
+/**
+ * The props of the KendoReact [PDFViewer]({% slug api_pdf-viewer_pdfviewer %}) component.
+ */
+export interface PDFViewerProps {
+    /**
+     * Represents the url of the PDF file.
+     */
+    url?: string;
+    /**
+     * Represents the data of the PDF file in Base64 format.
+     */
+    data?: string;
+    /**
+     * Represents the raw binary data buffer of the PDF file.
+     */
+    arrayBuffer?: ArrayBuffer;
+    /**
+     * Represents the data of the PDF file in typed array format.
+     */
+    typedArray?: TypedArray;
+    /**
+     * Represents the additional styles which will be added to the PDFViewer component.
+     */
+    style?: React.CSSProperties;
+    /**
+     * Represents the file name used to save the file when the user clicks the download tool.
+     */
+    saveFileName?: string;
+    /**
+     * Represents the options for saving the file when the user clicks the download tool.
+     */
+    saveOptions?: SaveOptions;
+    /**
+     * Represents the zoom levels populated in the ComboBox component.
+     */
+    zoomLevels?: {
+        id: number;
+        value: number;
+        text: string;
+        type: string;
+        locationString?: string;
+    }[];
+    /**
+     * Fires when an error occurs.
+     */
+    onError?: (event: ErrorEvent) => void;
+    /**
+     * Fires when a PDF document has been loaded.
+     */
+    onLoad?: (event: LoadEvent) => void;
+    /**
+     * Fires when the download tool has been clicked. To prevent the download, return `false`.
+     */
+    onDownload?: (event: DownloadEvent) => boolean;
+    /**
+     * Fires when the toolbar component is about to be rendered. Use it to override the default appearance of the toolbar.
+     */
+    onRenderToolbar?: (defaultRendering: React.ReactElement<Toolbar>) => React.ReactNode;
+    /**
+     * Fires when the content component is about to be rendered. Use it to override the default appearance of the content.
+     */
+    onRenderContent?: (defaultRendering: React.ReactElement<HTMLDivElement>) => React.ReactNode;
+    /**
+     * Fires when the loading indication component is about to be rendered. Use it to override the default appearance of the loading.
+     */
+    onRenderLoader?: (defaultRendering: React.ReactElement<HTMLDivElement> | null) => React.ReactNode;
+}
+/**
+ * Represents the object which is passed to the [`ref`](https://reactjs.org/docs/refs-and-the-dom.html)
+ * callback of the [PDFViewer]({% slug api_pdf-viewer_pdfviewer %}) component.
+ */
+export interface PDFViewerHandle {
+    /**
+     * The root DOM element of the PDFViewer component.
+     */
+    element: HTMLDivElement | null;
+    /**
+     * The props of the PDFViewer component.
+     */
+    props: PDFViewerProps;
+    /**
+     * The `PDF.js` document loaded in the PDFViewer component.
+     */
+    document: any;
+    /**
+     * The `PDF.js` pages loaded in the PDFViewer component.
+     */
+    pages: any[];
+}
+/**
+ * Represents the [KendoReact PDFViewer component]({% slug api_pdf-viewer_pdfviewerprops %}).
+ */
+export declare const PDFViewer: React.ForwardRefExoticComponent<PDFViewerProps & React.RefAttributes<PDFViewerHandle | null>>;
+export {};

package/dist/es/PDFViewer.js

@@ -0,0 +1,365 @@
+import * as React from 'react';
+import * as PropTypes from 'prop-types';
+import { Button, ButtonGroup, Toolbar, ToolbarSpacer } from '@progress/kendo-react-buttons';
+import { TextBox, InputSuffix } from '@progress/kendo-react-inputs';
+import { Pager } from '@progress/kendo-react-data-tools';
+import { Upload } from '@progress/kendo-react-upload';
+import { ComboBox } from '@progress/kendo-react-dropdowns';
+import { Loader } from '@progress/kendo-react-indicators';
+import { classNames, validatePackage } from '@progress/kendo-react-common';
+import { useLocalization } from '@progress/kendo-react-intl';
+import 'pdfjs-dist/build/pdf.worker.entry';
+import { packageMetadata } from './package-metadata';
+import { Scroller } from './scroller';
+import { SearchService } from './search';
+import { DEFAULT_ZOOM_LEVEL, loadPDF, print, download, goToNextSearchMatch, goToPreviousSearchMatch, reloadDocument, calculateZoomLevel, removeChildren } from './utils';
+import { messages, close, download as downloadM, enablePanning, enableSelection, matchCase as matchCaseM, nextMatch, open, prevMatch, print as printM, search, zoomIn, zoomOut, popupBlocked, actualWidth, fitToWidth, fitToPage } from './messages';
+const zoomMin = 0.5;
+const zoomMax = 4;
+const zoomStep = 0.25;
+const zoomLevels = [
+    { id: 1, value: 1, text: 'ActualWidth', type: 'ActualWidth', locationString: actualWidth },
+    { id: 2, value: 1, text: 'FitToWidth', type: 'FitToWidth', locationString: fitToWidth },
+    { id: 3, value: 1, text: 'FitToPage', type: 'FitToPage', locationString: fitToPage },
+    { id: 4, value: 0.5, text: '50%', type: '' },
+    { id: 5, value: 0.75, text: '75%', type: '' },
+    { id: 6, value: 1, text: '100%', type: '' },
+    { id: 7, value: 1.25, text: '125%', type: '' },
+    { id: 8, value: 1.5, text: '150%', type: '' },
+    { id: 9, value: 2, text: '200%', type: '' },
+    { id: 10, value: 3, text: '300%', type: '' },
+    { id: 11, value: 4, text: '400%', type: '' }
+];
+const navigation = [
+    '.k-toolbar > button',
+    '.k-toolbar .k-combobox > input',
+    '.k-toolbar .k-button-group > button',
+    '.k-toolbar .k-pager > a',
+    '.k-toolbar .k-pager input'
+];
+/**
+ * Represents the [KendoReact PDFViewer component]({% slug api_pdf-viewer_pdfviewerprops %}).
+ */
+export const PDFViewer = React.forwardRef((props, ref) => {
+    validatePackage(packageMetadata);
+    const loc = useLocalization();
+    const pagesRef = React.useRef(null);
+    const [zoom, setZoom] = React.useState(DEFAULT_ZOOM_LEVEL);
+    const [zoomLevel, setZoomLevel] = React.useState(zoomLevels.find(z => z.value === DEFAULT_ZOOM_LEVEL));
+    const [loading, setLoading] = React.useState(true);
+    const [skip, setSkip] = React.useState(0);
+    const [pages, setPages] = React.useState([]);
+    const [doc, setDoc] = React.useState(null);
+    const [enabledSelection, setEnabledSelection] = React.useState(false);
+    const [showSearch, setShowSearch] = React.useState(false);
+    const [matches, setMatches] = React.useState(0);
+    const [currentMatch, setCurrentMatch] = React.useState(0);
+    const [matchCase, setMatchCase] = React.useState(false);
+    const [searchText, setSearchText] = React.useState('');
+    const refObj = React.useMemo(() => ({}), []);
+    const target = React.useRef(null);
+    const pdfViewerRef = React.useRef(null);
+    React.useImperativeHandle(target, () => ({
+        element: pdfViewerRef.current,
+        props,
+        pages,
+        document: doc
+    }), [pages, doc]);
+    React.useImperativeHandle(ref, () => target.current);
+    const triggerOnLoad = React.useCallback(() => {
+        if (props.onLoad) {
+            const loadEvent = { target: target.current };
+            props.onLoad.call(undefined, loadEvent);
+        }
+    }, [props.onLoad]);
+    const triggerOnDownload = React.useCallback((blob, fileName, saveOptions) => {
+        let handled = false;
+        if (props.onDownload) {
+            const downloadEvent = {
+                target: target.current,
+                blob,
+                fileName,
+                saveOptions
+            };
+            handled = props.onDownload.call(undefined, downloadEvent) || false;
+        }
+        return handled;
+    }, [props.onDownload]);
+    const initScroller = React.useCallback(() => {
+        var _a;
+        if (refObj.scroller) {
+            refObj.scroller.destroy();
+        }
+        refObj.scroller = new Scroller((_a = pagesRef.current) === null || _a === void 0 ? void 0 : _a.parentNode, {
+            filter: '.k-page',
+            events: {}
+        });
+        refObj.scroller.enablePanEventsTracking();
+    }, []);
+    const initSearch = React.useCallback((wrapper) => {
+        const pagesTextLayers = Array.from(wrapper.querySelectorAll('.k-text-layer'));
+        refObj.search = new SearchService({
+            textContainers: pagesTextLayers || [],
+            highlightClass: 'k-search-highlight',
+            highlightMarkClass: 'k-search-highlight-mark',
+            charClass: 'k-text-char'
+        });
+    }, []);
+    const done = React.useCallback(({ pdfPages, pdfDoc }) => {
+        setDoc(pdfDoc);
+        setPages(pdfPages);
+        initScroller();
+        setLoading(false);
+        triggerOnLoad();
+    }, []);
+    const error = React.useCallback((reason) => {
+        setLoading(false);
+        setDoc(null);
+        setPages([]);
+        if (props.onError) {
+            const errorEvent = {
+                error: typeof reason === 'string' ? { message: reason } : reason,
+                target: target.current
+            };
+            props.onError.call(undefined, errorEvent);
+        }
+    }, [props.onError]);
+    React.useEffect(() => {
+        if (pagesRef.current) {
+            if (props.url || props.data || props.arrayBuffer) {
+                setLoading(true);
+                removeChildren(pagesRef.current);
+                loadPDF({
+                    url: props.url,
+                    data: props.data,
+                    arrayBuffer: props.arrayBuffer,
+                    dom: pagesRef.current,
+                    zoom: DEFAULT_ZOOM_LEVEL,
+                    done,
+                    error
+                });
+            }
+            else {
+                setLoading(false);
+                removeChildren(pagesRef.current);
+                setDoc(null);
+                setPages([]);
+            }
+        }
+    }, [props.url, props.data, props.arrayBuffer, error]);
+    const reload = React.useCallback((pdfDoc, zoomLev = DEFAULT_ZOOM_LEVEL) => {
+        if (pagesRef.current) {
+            setLoading(true);
+            removeChildren(pagesRef.current);
+            reloadDocument({
+                pdfDoc,
+                zoom: zoomLev,
+                dom: pagesRef.current,
+                done: (pdfPages) => {
+                    setPages(pdfPages);
+                    setLoading(false);
+                },
+                error
+            });
+        }
+    }, [error]);
+    const onSearch = React.useCallback(() => {
+        setShowSearch(true);
+        initSearch(pagesRef.current);
+    }, []);
+    const onSearchTextChange = React.useCallback((e) => {
+        const text = e.value;
+        const currentMatches = refObj.search.search({ text, matchCase });
+        setCurrentMatch(currentMatches.length ? 1 : 0);
+        setMatches(currentMatches.length);
+        setSearchText(text);
+    }, [matchCase]);
+    const onMatchCaseClick = React.useCallback(() => {
+        const currentMatches = refObj.search.search({ text: searchText, matchCase: !matchCase });
+        setCurrentMatch(currentMatches.length ? 1 : 0);
+        setMatches(currentMatches.length);
+        setMatchCase(!matchCase);
+    }, [matchCase, searchText]);
+    const onNextMatch = React.useCallback(() => {
+        goToNextSearchMatch(refObj);
+        setCurrentMatch((currentMatch + 1) > matches ? 1 : (currentMatch + 1));
+    }, [currentMatch, matches]);
+    const onPrevMatch = React.useCallback(() => {
+        goToPreviousSearchMatch(refObj);
+        setCurrentMatch((currentMatch - 1) < 1 ? matches : (currentMatch - 1));
+    }, [currentMatch, matches]);
+    const onClose = React.useCallback(() => {
+        refObj.search.destroy();
+        setCurrentMatch(0);
+        setMatches(0);
+        setMatchCase(false);
+        setSearchText('');
+        setShowSearch(false);
+    }, []);
+    const onTextBoxKeyDown = React.useCallback((e) => {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            goToNextSearchMatch(refObj);
+            setCurrentMatch((currentMatch + 1) > matches ? 1 : (currentMatch + 1));
+        }
+        else if (e.key === 'Escape') {
+            onClose();
+        }
+    }, [currentMatch, matches]);
+    const onPageChange = React.useCallback((e) => {
+        if (pagesRef.current && pagesRef.current.parentNode instanceof HTMLDivElement) {
+            const page = pagesRef.current.querySelector('.k-page');
+            if (page instanceof HTMLDivElement) {
+                const top = (page.offsetHeight + page.offsetTop) * e.skip;
+                pagesRef.current.parentNode.scrollTo({ top, behavior: 'auto' });
+            }
+        }
+        setSkip(e.skip);
+    }, [skip]);
+    const onScroll = React.useCallback((e) => {
+        const targetEl = e.target;
+        const page = targetEl.querySelector('.k-page');
+        if (page) {
+            setSkip(Math.floor(targetEl.scrollTop / (page.offsetHeight + page.offsetTop)));
+        }
+    }, []);
+    const onZoomIn = React.useCallback(() => {
+        const newZoom = Math.min(zoom + zoomStep, zoomMax);
+        if (newZoom !== zoom && doc) {
+            setZoom(newZoom);
+            reload(doc, newZoom);
+        }
+    }, [zoom, doc]);
+    const onZoomOut = React.useCallback(() => {
+        const newZoom = Math.max(zoom - zoomStep, zoomMin);
+        if (newZoom !== zoom && doc) {
+            setZoom(newZoom);
+            reload(doc, newZoom);
+        }
+    }, [zoom, doc]);
+    const onZoomLevelChange = React.useCallback((e) => {
+        const item = e.value;
+        const newZoom = item ? calculateZoomLevel(item.value, item.type, zoom, pagesRef.current) : 1;
+        if (zoom !== newZoom && doc) {
+            setZoom(newZoom);
+            reload(doc, newZoom);
+        }
+        setZoomLevel(item);
+    }, [zoom, doc]);
+    const onTextSelection = React.useCallback(() => {
+        refObj.scroller.disablePanEventsTracking();
+        setEnabledSelection(true);
+    }, []);
+    const onPinning = React.useCallback(() => {
+        refObj.scroller.enablePanEventsTracking();
+        setEnabledSelection(false);
+    }, []);
+    const onDownload = React.useCallback(() => {
+        download({
+            url: props.url,
+            data: props.data,
+            arrayBuffer: props.arrayBuffer,
+            error
+        }, props.saveFileName, props.saveOptions, triggerOnDownload);
+    }, [props.url, props.data, props.arrayBuffer, error, props.saveFileName, props.saveOptions, triggerOnDownload]);
+    const onPrint = React.useCallback(() => {
+        setLoading(true);
+        const onError = (e) => {
+            error(typeof (e ? e.message || e : null) === 'string' ? e.message || e : loc.toLanguageString(popupBlocked, messages[popupBlocked]));
+        };
+        const onDone = () => {
+            setLoading(false);
+        };
+        print(pages, onDone, onError);
+    }, [pages, error]);
+    const onAdd = React.useCallback((e) => {
+        const st = e.newState;
+        if (st[0] && st[0].getRawFile) {
+            const file = st[0].getRawFile();
+            file.arrayBuffer().then((arrayBuffer) => {
+                if (pagesRef.current) {
+                    setLoading(true);
+                    removeChildren(pagesRef.current);
+                    loadPDF({
+                        arrayBuffer,
+                        dom: pagesRef.current,
+                        zoom: DEFAULT_ZOOM_LEVEL,
+                        done,
+                        error
+                    });
+                    setZoom(DEFAULT_ZOOM_LEVEL);
+                }
+            });
+        }
+    }, [error]);
+    const onFileOpen = React.useCallback((e) => {
+        const targetEl = e.target;
+        if (targetEl instanceof HTMLElement && targetEl.parentNode) {
+            const toolbarEl = targetEl.closest('.k-toolbar');
+            const input = toolbarEl && toolbarEl.querySelector('.k-upload input');
+            if (input) {
+                input.click();
+            }
+        }
+    }, []);
+    const noDocument = !doc;
+    const loader = (loading && React.createElement("div", { className: "k-loader-container k-loader-container-md k-loader-top" },
+        React.createElement("div", { className: "k-loader-container-overlay k-overlay-light" }),
+        React.createElement("div", { className: "k-loader-container-inner " },
+            React.createElement(Loader, { size: 'large' }))));
+    const toolbar = (React.createElement(Toolbar, { buttons: navigation },
+        React.createElement(Pager, { previousNext: true, type: 'input', skip: skip, take: 1, total: pages.length, info: false, onPageChange: onPageChange }),
+        React.createElement(ToolbarSpacer, null),
+        React.createElement(ButtonGroup, null,
+            React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(zoomIn, messages[zoomIn]), disabled: zoom === zoomMax || noDocument, onClick: onZoomIn, icon: 'zoom-in' }),
+            React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(zoomOut, messages[zoomOut]), disabled: zoom === zoomMin || noDocument, onClick: onZoomOut, icon: 'zoom-out' })),
+        React.createElement(ComboBox, { disabled: noDocument, data: (props.zoomLevels || zoomLevels).map(level => (Object.assign(Object.assign({}, level), { text: level.locationString
+                    ? loc.toLanguageString(level.locationString, messages[level.locationString])
+                    : level.text }))), dataItemKey: 'id', textField: 'text', value: noDocument ? null : zoomLevel, onChange: onZoomLevelChange }),
+        React.createElement(ButtonGroup, null,
+            React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(enableSelection, messages[enableSelection]), icon: 'cursor', disabled: noDocument, togglable: true, selected: enabledSelection && !noDocument, onClick: onTextSelection }),
+            React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(enablePanning, messages[enablePanning]), icon: 'hand', disabled: noDocument, togglable: true, selected: !enabledSelection && !noDocument, onClick: onPinning })),
+        React.createElement(ToolbarSpacer, null),
+        React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(search, messages[search]), icon: 'search', disabled: noDocument, onClick: onSearch }),
+        React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(open, messages[open]), icon: 'folder-open', onClick: onFileOpen }),
+        React.createElement("div", { style: { display: 'none' } },
+            React.createElement(Upload, { restrictions: { allowedExtensions: ['.pdf'] }, onAdd: onAdd, autoUpload: false, defaultFiles: [], multiple: false, accept: ".pdf,.PDF", withCredentials: false })),
+        React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(downloadM, messages[downloadM]), icon: 'download', disabled: noDocument, onClick: onDownload }),
+        React.createElement(Button, { className: 'k-toolbar-button', title: loc.toLanguageString(printM, messages[printM]), icon: 'print', disabled: noDocument, onClick: onPrint })));
+    const content = (React.createElement("div", { className: classNames('k-canvas k-pdf-viewer-canvas k-pos-relative k-overflow-auto', {
+            'k-enable-text-select': enabledSelection,
+            'k-enable-panning': !enabledSelection
+        }), onScroll: onScroll },
+        showSearch && (React.createElement("div", { className: 'k-search-panel k-pos-sticky k-top-center' },
+            React.createElement(TextBox, { value: searchText, onChange: onSearchTextChange, placeholder: loc.toLanguageString(search, messages[search]), autoFocus: true, onKeyDown: onTextBoxKeyDown, suffix: () => (React.createElement(InputSuffix, null,
+                    React.createElement(Button, { icon: "convert-lowercase", title: loc.toLanguageString(matchCaseM, messages[matchCaseM]), fillMode: "flat", togglable: true, selected: matchCase, onClick: onMatchCaseClick }))) }),
+            React.createElement("span", { className: "k-search-matches" },
+                React.createElement("span", null, currentMatch),
+                " of ",
+                React.createElement("span", null, matches)),
+            React.createElement(Button, { title: loc.toLanguageString(prevMatch, messages[prevMatch]), fillMode: 'flat', icon: 'arrow-up', disabled: matches === 0, onClick: onPrevMatch }),
+            React.createElement(Button, { title: loc.toLanguageString(nextMatch, messages[nextMatch]), fillMode: 'flat', icon: 'arrow-down', disabled: matches === 0, onClick: onNextMatch }),
+            React.createElement(Button, { title: loc.toLanguageString(close, messages[close]), fillMode: 'flat', icon: 'close', onClick: onClose }))),
+        React.createElement("div", { ref: pagesRef, className: 'k-pdf-viewer-pages' })));
+    return (React.createElement("div", { className: 'k-pdf-viewer', style: props.style, ref: pdfViewerRef },
+        props.onRenderLoader ? props.onRenderLoader.call(undefined, loader || null) : loader,
+        props.onRenderToolbar ? props.onRenderToolbar.call(undefined, toolbar) : toolbar,
+        props.onRenderContent ? props.onRenderContent.call(undefined, content) : content));
+});
+PDFViewer.displayName = 'KendoReactPDFViewer';
+PDFViewer.propTypes = {
+    url: PropTypes.string,
+    data: PropTypes.string,
+    arrayBuffer: PropTypes.any,
+    typedArray: PropTypes.any,
+    style: PropTypes.object,
+    saveFileName: PropTypes.string,
+    saveOptions: PropTypes.object,
+    zoomLevels: PropTypes.arrayOf(PropTypes.any),
+    onError: PropTypes.func,
+    onLoad: PropTypes.func,
+    onDownload: PropTypes.func,
+    onRenderToolbar: PropTypes.func,
+    onRenderContent: PropTypes.func,
+    onRenderLoader: PropTypes.func
+};

package/dist/es/main.d.ts

@@ -0,0 +1 @@
+export { PDFViewer, PDFViewerProps, PDFViewerHandle, LoadEvent, ErrorEvent, DownloadEvent } from './PDFViewer';

package/dist/es/main.js

@@ -0,0 +1 @@
+export { PDFViewer } from './PDFViewer';

package/dist/es/messages.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @hidden
+ */
+export declare const zoomIn = "pdfviewer.zoomIn";
+/**
+ * @hidden
+ */
+export declare const zoomOut = "pdfviewer.zoomOut";
+/**
+ * @hidden
+ */
+export declare const enableSelection = "pdfviewer.enableSelection";
+/**
+ * @hidden
+ */
+export declare const enablePanning = "pdfviewer.enablePanning";
+/**
+ * @hidden
+ */
+export declare const search = "pdfviewer.search";
+/**
+ * @hidden
+ */
+export declare const open = "pdfviewer.open";
+/**
+ * @hidden
+ */
+export declare const download = "pdfviewer.download";
+/**
+ * @hidden
+ */
+export declare const print = "pdfviewer.print";
+/**
+ * @hidden
+ */
+export declare const close = "pdfviewer.close";
+/**
+ * @hidden
+ */
+export declare const matchCase = "pdfviewer.matchCase";
+/**
+ * @hidden
+ */
+export declare const prevMatch = "pdfviewer.prevMatch";
+/**
+ * @hidden
+ */
+export declare const nextMatch = "pdfviewer.nextMatch";
+/**
+ * @hidden
+ */
+export declare const actualWidth = "pdfviewer.actualWidth";
+/**
+ * @hidden
+ */
+export declare const fitToWidth = "pdfviewer.fitToWidth";
+/**
+ * @hidden
+ */
+export declare const fitToPage = "pdfviewer.fitToPage";
+/**
+ * @hidden
+ */
+export declare const popupBlocked = "pdfviewer.popupBlocked";
+/**
+ * @hidden
+ */
+export declare const messages: {
+    "pdfviewer.zoomIn": string;
+    "pdfviewer.zoomOut": string;
+    "pdfviewer.enableSelection": string;
+    "pdfviewer.enablePanning": string;
+    "pdfviewer.search": string;
+    "pdfviewer.open": string;
+    "pdfviewer.download": string;
+    "pdfviewer.print": string;
+    "pdfviewer.close": string;
+    "pdfviewer.matchCase": string;
+    "pdfviewer.prevMatch": string;
+    "pdfviewer.nextMatch": string;
+    "pdfviewer.actualWidth": string;
+    "pdfviewer.fitToWidth": string;
+    "pdfviewer.fitToPage": string;
+    "pdfviewer.popupBlocked": string;
+};