@grapecity-software/gcdocs.pdfviewer 7.1.0

package/typings/Models/GcMeasurementTypes.d.ts

@@ -0,0 +1,29 @@
+export interface IGcPoint {
+    x: number;
+    y: number;
+}
+export interface IGcRect extends IGcPoint {
+    w: number;
+    h: number;
+}
+export interface IGcTextRect extends IGcRect {
+    angle: number;
+    str: string;
+    strPos: number[];
+    fontHeight: number;
+    fontDescent: number;
+    scale: any;
+    style: any;
+    font: string;
+    vertical: boolean;
+    monospace: boolean;
+    transform: number[];
+    dir: 'ltr' | 'rtl';
+    markedId?: string;
+}
+export declare class GcSelectionPoint implements IGcPoint {
+    constructor(x: number, y: number, pageIndex: number);
+    x: number;
+    y: number;
+    pageIndex: number;
+}

package/typings/Models/PluginTypes.d.ts

@@ -0,0 +1,23 @@
+//@ts-ignore
+import { PluginModel } from "@grapecity/viewer-core";
+import { DrillthroughAction, InteractivityAction } from "../GcPdfDocument";
+export type ReportEvent = PluginModel.ViewerEvent | {
+    type: "ItemClicked";
+    iStorePos: number;
+    a: InteractivityAction;
+};
+export type ReportAction = InteractivityAction | DrillthroughAction | {
+    Type: "print";
+} | {
+    Type: "download";
+} | {
+    Type: "save";
+} | {
+    Type: "rotate";
+} | {
+    Type: "text-selection";
+} | {
+    Type: "pan";
+} | {
+    Type: "doc-properties";
+};

package/typings/Models/ViewerTypes.d.ts

@@ -0,0 +1,279 @@
+import { GcSelectionPoint } from "./GcMeasurementTypes";
+export type SignatureInfo = {
+    contactInfo: string;
+    location: string;
+    signerName: string;
+    reason: string;
+    signatureField: string;
+};
+export type FieldAppearanceRenderingType = "Custom" | "Web" | "Predefined";
+export type DocumentInitParameters = {
+    url?: string | URL;
+    data?: any | Array<number> | string;
+    httpHeaders?: Object;
+    initialData?: any;
+    length?: number;
+    range?: any;
+    rangeChunkSize?: number;
+    worker?: any;
+    verbosity?: number;
+    docBaseUrl?: string;
+    cMapUrl?: string;
+    cMapPacked?: boolean;
+    CMapReaderFactory?: Object;
+    useSystemFonts?: boolean;
+    standardFontDataUrl?: string;
+    StandardFontDataFactory?: Object;
+    useWorkerFetch?: boolean;
+    stopAtErrors?: boolean;
+    maxImageSize?: number;
+    isEvalSupported?: boolean;
+    disableFontFace?: boolean;
+    fontExtraProperties?: boolean;
+    enableXfa?: boolean;
+    ownerDocument?: any;
+    disableRange?: boolean;
+    disableStream?: boolean;
+    disableAutoFetch?: boolean;
+    pdfBug?: boolean;
+};
+export type OpenParameters = {
+    headers: {
+        [header: string]: string;
+    };
+    withCredentials: boolean;
+    password: string;
+    friendlyPdfUrl?: string;
+} & DocumentInitParameters;
+export type OptionalContentConfig = {
+    creator: null | string;
+    name: null | string;
+    getGroup(id: string): OptionalContentGroup;
+    getGroups(): {
+        [id: string]: OptionalContentGroup;
+    };
+    getOrder(): {
+        name: string | null;
+        order: string[];
+    }[];
+    isVisible(groupOrId: string | OptionalContentGroup): any;
+    setVisibility(id: string, visible: boolean): any;
+    viewScale: number;
+};
+export type OptionalContentGroup = {
+    id: string;
+    name: string;
+    type: "OCG" | string;
+    visible: boolean;
+    exportState?: "ON" | "OFF";
+    viewState?: "ON" | "OFF";
+    printState?: "ON" | "OFF";
+    creatorInfo?: {
+        Creator: string;
+        Subtype: string;
+    };
+    intent?: "View" | "Design";
+    zoom?: {
+        min?: number;
+        max?: number;
+    };
+};
+export type StructTreeNode = {
+    role: "Root" | string;
+    children: Array<StructTreeNode | StructTreeContent>;
+};
+export type StructTreeContent = {
+    id: string;
+    type: "content" | "object";
+    actualText: string | undefined;
+};
+export type ViewerFeatureName = 'JavaScript' | 'AllAttachments' | 'FileAttachments' | 'SoundAttachments' | 'RichMediaAttachments' | 'DragAndDrop' | 'SubmitForm' | 'Print';
+export type StampCategory = {
+    id?: string;
+    name: string;
+    stampImages?: string[];
+    stampImageUrls?: string[];
+    isDynamic?: boolean;
+    dpi?: number;
+};
+export interface IPageViewport {
+    offsetX: number;
+    offsetY: number;
+    rotation: number;
+    scale: number;
+    transform: number;
+    viewBox: number[];
+    width: number;
+    height: number;
+}
+export interface IGcPageView {
+    viewport: IPageViewport;
+    ensureFullyLoaded(): Promise<IGcPageView>;
+    ensureSelectionPainter(): Promise<any>;
+    ensureAnnotationLayerRendered(): Promise<any>;
+    pageIndex: number;
+    width: number;
+    height: number;
+    renderingId: string;
+    renderingState: any;
+    outputScale: any;
+    scale: number;
+    rotation: number;
+    annotationLayerDirty?: boolean;
+}
+export interface IGcVisiblePage {
+    id: number;
+    view: IGcPageView;
+    x: number;
+    y: number;
+    percent: number;
+}
+export interface IGcVisiblePagesInfo {
+    first: IGcVisiblePage;
+    last: IGcVisiblePage;
+    views: IGcVisiblePage[];
+}
+export interface IGcSelectionCopier {
+    showTextMarkupContextMenu(event: MouseEvent | TouchEvent, coords?: {
+        clientX: number;
+        clientY: number;
+    }): boolean;
+    showCustomContextMenu(event: MouseEvent | TouchEvent, coords?: {
+        clientX: number;
+        clientY: number;
+    }): boolean;
+    copySelectedText(): boolean;
+    printSelectedText(): any;
+    resetAll(): any;
+    resetPage(pageIndex: number): any;
+    beginUpdatePages(): any;
+    endUpdatePages(): any;
+    beginUpdatePage(pageIndex: number): any;
+    endUpdatePage(): any;
+    getSelectedText(): any;
+    lastCaretPos: GcSelectionPoint;
+    lastMousePos: GcSelectionPoint;
+    notifyCaretPositionChanged(x: number, y: number, pageIndex: number): any;
+    notifyViewerFocused(viewer: any): any;
+    onNativeContextMenuStart(): any;
+    onNativeContextMenuEnd(): any;
+    hasSelectedText: boolean;
+    currentSelectionBox: null | {
+        pageIndex: number;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        paintedBoxes: {
+            pageIndex: number;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            angle: number;
+            dir: "ltr" | "rtl";
+            vertical: boolean;
+        }[];
+    };
+}
+export type SaveSettings = {
+    format?: "PDF" | "PNG";
+    pages?: string;
+    reload?: boolean;
+    saveMode?: "Auto" | "Default" | "Linearized" | "IncrementalUpdate";
+    saveModificationsOnly?: boolean;
+    sign?: SignatureInfo;
+    progressTitle?: string;
+    progressMessage?: string;
+    zoomFactor?: number;
+};
+export type PageViewport = {
+    viewBox: number[];
+    width: number;
+    height: number;
+    scale: number;
+    rotation: number;
+    offsetX: number;
+    offsetY: number;
+    transform: number[];
+    clone(args: Partial<PageViewport>): PageViewport;
+    convertToViewportPoint(x: number, y: number): number[];
+    convertToViewportRectangle(rect: number[]): number[];
+    convertToPdfPoint(x: any, y: any): number[];
+};
+export type ViewerPreferences = {
+    hideToolbar?: boolean;
+    hideMenubar?: boolean;
+    hideWindowUI?: boolean;
+    fitWindow?: boolean;
+    centerWindow?: boolean;
+    displayDocTitle?: boolean;
+    nonFullScreenPageMode?: PageMode;
+    openAction?: OpenAction;
+    pageMode?: PageMode;
+    pageLayout?: PageLayout;
+};
+export type PageMode = "UseAttachments" | "UseOC" | "UseOutlines" | "UseThumbs" | "UseNone" | "";
+export type PageLayout = "SinglePage" | "";
+export type OpenAction = {
+    dest: number[];
+};
+export type BusEventName = "outlineloaded" | "attachmentsloaded" | "namedaction" | "pagemode" | "fileattachmentannotation" | "pagerendered" | "pagecancelled" | "scalechange" | "pagesinit" | "pagesloaded" | "documentchanged" | "rotationchanging" | "updateviewarea" | "undostorechanged" | "annotationeditstarted" | "annotationeditdone" | "show-custom-layout" | "hide-custom-layout" | "unselectannotation" | "annotation-bounds-change" | "pagechange" | "mousemodechange" | "request-answer" | "textlayerready" | "textselectionchanged" | "viewersizechanged" | "articlebeadnavigate" | "error" | "open" | "pagelabels" | "documentload";
+export interface IGCEventBus {
+    on(eventName: BusEventName, listener: Function): any;
+    off(eventName: BusEventName, listener: Function): any;
+    dispatch(eventName: BusEventName, ...rest: any[]): any;
+}
+export type KeyboardShortcutTool = "zoomin" | "zoomout" | "zoom_pagesize" | "zoom_clientsize" | "select_all" | "rotate" | "pan" | "holdToPan" | "selection" | "open" | "search" | "print" | "move_caret_left" | "move_caret_right" | "move_caret_up" | "move_caret_down" | "move_caret_document_start" | "move_caret_document_end" | "move_caret_sequence_start" | "move_caret_sequence_end" | "confirm-ok" | "confirm-cancel" | "scrollUp" | "scrollDown" | "search";
+export type KeyboardShortcutDefinition = {
+    keyCode?: number;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    tool?: KeyboardShortcutTool | Function;
+};
+export type JsCancelEventArgs = {
+    cancel?: boolean;
+    jsCode: string;
+    targetAnnotation: any;
+    executor: any;
+};
+export type JsEventArgs = {
+    jsCode: string;
+    targetAnnotation: any;
+    executor: any;
+};
+export type JsExecutionConfig = {
+    disable?: boolean;
+    before?: (args: JsCancelEventArgs) => void;
+    after?: (args: JsEventArgs) => void;
+    repaintWhenDone?: boolean;
+    repaintOnStep?: boolean;
+};
+export type DocumentListItem = {
+    name: string;
+    path: string;
+    title: string;
+    previewContent?: string;
+};
+export type SubmitFormOptions = {
+    fields?: string[];
+    refs?: string[];
+    include?: boolean;
+    includeNoValueFields?: boolean;
+    exportFormat?: boolean;
+    getMethod?: boolean;
+    submitCoordinates?: boolean;
+    submitUsingGet?: boolean;
+    xFDF?: boolean;
+    submitPDF?: boolean;
+    canonicalFormat?: boolean;
+};
+export type ScrollPageIntoViewOptions = ScrollIntoViewOptions & {
+    behavior?: ScrollBehavior;
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+    scrollMode?: 'always' | 'if-needed';
+    visibilityThreshold?: number;
+};

package/typings/Password/GcPdfPasswordDialog.d.ts

@@ -0,0 +1,31 @@
+/// <reference path="../vendor/i18next.d.ts" />
+//@ts-ignore
+import { i18n } from 'i18next';
+/// <reference path="../vendor/react/react.d.ts" />
+//@ts-ignore
+import React, { Component, FormEvent } from 'react';
+import PdfReportPlugin from '../plugin';
+export type GcPdfPasswordDialogState = {
+    inputValue: string;
+    lastShowReason: number;
+};
+export declare class GcPdfPasswordDialog extends Component<any, GcPdfPasswordDialogState> {
+    rootElement: HTMLDivElement;
+    _updateCallback: any;
+    _wrongPasswordMessage: HTMLSpanElement;
+    _cancelCallback: any;
+    _plugin: PdfReportPlugin;
+    constructor(props: any);
+    get inputElement(): HTMLInputElement;
+    get wrongPassword(): HTMLElement;
+    onFormSubmit(event: FormEvent<HTMLFormElement>): boolean;
+    get isVisible(): boolean;
+    submitPassword(): void;
+    cancel(): void;
+    show(plugin: PdfReportPlugin, updateCallback: any, cancelCallback: any, reason?: any): void;
+    hide(): void;
+    onInputChange(e: any): void;
+    onKeyUp(e: any): void;
+    get in17n(): i18n | undefined;
+    render(): React.JSX.Element;
+}

package/typings/PdfDocumentViewer/PdfDocumentViewer.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="../vendor/react/react.d.ts" />
+//@ts-ignore
+import React, { Component } from 'react';
+export declare class PdfDocumentViewer extends Component<any, any> {
+    private _rightSidebarElement;
+    private _pdfPaneOuterElement;
+    constructor(props: any, state: any);
+    render(): React.JSX.Element;
+    get pdfPaneOuterElement(): HTMLDivElement | null;
+    get rightSidebarElement(): HTMLDivElement | null;
+}

package/typings/PdfOrganizer/PdfOrganizerDialog.d.ts

@@ -0,0 +1,83 @@
+/// <reference path="../vendor/react/react.d.ts" />
+//@ts-ignore
+import React, { Component, KeyboardEvent } from 'react';
+import GcPdfViewer from "..";
+//@ts-ignore
+import { DropdownItem } from '@grapecity/core-ui';
+/// <reference path="../vendor/i18next.d.ts" />
+//@ts-ignore
+import { i18n } from 'i18next';
+import { PdfOrganizerDialogProps, PdfOrganizerModel, RangeInfo } from './types';
+import { SaveSettings } from '../Models/ViewerTypes';
+import { ExternalPdfManager } from '../Core/ExternalPdfManager';
+export declare class PdfOrganizerDialog extends Component<PdfOrganizerDialogProps, PdfOrganizerModel> {
+    static readonly ROOT_ID_PREFIX: string;
+    static readonly MAX_RANGE_EMPTY_PAGES_COUNT: number;
+    private _hidePromise?;
+    private _resolve?;
+    private _thumbsPromiseQueue;
+    private _viewer;
+    state: {
+        enabled: boolean;
+        showModal: boolean;
+        isChanged: boolean;
+        ranges: RangeInfo[];
+        workInProgress: boolean;
+    };
+    private _fileInput?;
+    private _externalPdfManager;
+    private _dialogContentElem;
+    private _addRangeDropdown;
+    private _mounted;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    get externalPdfManager(): ExternalPdfManager;
+    get fileInput(): HTMLInputElement;
+    get ranges(): RangeInfo[];
+    selectPdfFileForMerge(): void;
+    addRange(startIndex: number, endIndex: number, fileId: string, fileName: string, filePagesCount: number, angle?: number): void;
+    removeRange(rangeIndex: number): void;
+    cloneRange(rangeIndex: number): void;
+    splitRangeByPages(rangeIndex: number): void;
+    movePagesRange(sourceRangeIndex: number, moveIndex: number): void;
+    rotateRange(rangeIndex: number, angleDeg: number): void;
+    getSaveSettings(downloadOnly?: boolean): SaveSettings;
+    show(viewer: GcPdfViewer): Promise<void>;
+    fillRangesByPageSizeOrOrient(ranges: RangeInfo[], startIndex?: number): RangeInfo[];
+    applyChanges(closeDialog?: boolean): Promise<boolean>;
+    downloadChangedDocument(): Promise<void>;
+    hide(): void;
+    setDirtyValue(rangeIndex: number, dirtyValue: string): void;
+    resetDirtyValue(rangeIndex: number): void;
+    applyDirtyValue(rangeIndex: number, resetOnError?: boolean): void;
+    render(): React.JSX.Element | null;
+    get isDirty(): boolean;
+    getRangeInfoTitle(range: RangeInfo): string;
+    renderRanges(): JSX.Element | null;
+    confirmRanges(ranges: RangeInfo[], newRangesCount: number): boolean;
+    addRanges(type: "PageSizeOrOrient" | "AllPages" | "SinglePages" | "EmptyPage" | "Odd" | "Even" | "Custom", customPages?: string): void;
+    getAddRangeDDItems(): DropdownItem[];
+    findCustomRangeInput(event: any): HTMLInputElement;
+    onCustomRangeInputKeyDown(event: KeyboardEvent<HTMLInputElement>): void;
+    onRangeInputKeyDown(event: KeyboardEvent<HTMLInputElement>, rangeIndex: number): void;
+    applyCustomRangeValue(event: any): void;
+    renderRangeActions(): JSX.Element | null;
+    private _dragStartInfo?;
+    private _waitTouchStartTimeout;
+    private _pointerupHandler;
+    private _pointerMoveHandler;
+    private _targetRangeElem;
+    private _targetRangeIndex;
+    private _rangesElementToReplace;
+    private _targetPlaceElement;
+    private _onPagesRangePointerDown;
+    private _activatePagesRangeDrag;
+    private _removeInternalEventListeners;
+    clearRanges(): void;
+    private _onPdfPicked;
+    private loadThumbImages;
+    clearThumbsQueue(): void;
+    enqueueThumbImage(div: HTMLElement, fileId: string, pageIndex: number, rangeAngle: number): void;
+    private _resolveHidePromise;
+    get in17n(): i18n;
+}

package/typings/PdfOrganizer/types.d.ts

@@ -0,0 +1,17 @@
+export type PdfOrganizerDialogProps = {};
+export type PdfOrganizerModel = {
+    enabled: boolean;
+    showModal: boolean;
+    isChanged: boolean;
+    workInProgress?: boolean;
+    ranges: RangeInfo[];
+};
+export type RangeInfo = {
+    fileId?: string;
+    fileName?: string;
+    filePagesCount: number;
+    startIndex: number;
+    endIndex: number;
+    dirtyValue?: string;
+    angle?: number;
+};

package/typings/Polyfills/ArrayPolyfills.d.ts

@@ -0,0 +1 @@
+declare function arrayFrom(arr: any, callbackFn: any, thisArg: any): any[];

package/typings/Print/GcPdfPrintProgress.d.ts

@@ -0,0 +1,17 @@
+/// <reference path="../vendor/react/react.d.ts" />
+//@ts-ignore
+import React, { Component } from 'react';
+export declare class GcPdfPrintProgress extends Component<any, {
+    percentage: number;
+    maxValue: number;
+}> {
+    rootElement: HTMLDivElement;
+    _cancel: any;
+    constructor(props: any);
+    set maxValue(max: number);
+    set value(val: number);
+    cancel(): void;
+    show(cancelCallback: any): void;
+    hide(): void;
+    render(): React.JSX.Element | null;
+}

package/typings/Print/GcPdfPrintService.d.ts

@@ -0,0 +1,7 @@
+export declare class GcPdfPrintService {
+    private readonly _viewer;
+    private readonly _docViewer;
+    constructor(_viewer: any, _docViewer: any);
+    print(): void;
+    printWithProgressDialog(): void;
+}

package/typings/Properties/DocumentInformation.d.ts

@@ -0,0 +1,22 @@
+export type DocumentInformation = {
+    Author?: string;
+    FileName: string;
+    FileSizeBytes: number;
+    CreationDate?: string;
+    Creator?: string;
+    IsAcroFormPresent?: boolean;
+    IsCollectionPresent?: boolean;
+    IsLinearized?: boolean;
+    IsXFAPresent?: boolean;
+    Keywords: string;
+    ModDate?: string;
+    PDFFormatVersion?: string;
+    Producer?: string;
+    Subject?: string;
+    Title?: string;
+    PagesCount?: number;
+    PageSizeInches?: {
+        width: number;
+        height: number;
+    };
+};

package/typings/Properties/PropertiesDialog.d.ts

@@ -0,0 +1,39 @@
+/// <reference path="../vendor/react/react.d.ts" />
+//@ts-ignore
+import React, { Component, MouseEvent } from 'react';
+import { DocumentInformation } from './DocumentInformation';
+import { DocumentSecuritySummary } from '../Security/DocumentSecuritySummary';
+/// <reference path="../vendor/i18next.d.ts" />
+//@ts-ignore
+import { i18n } from 'i18next';
+export type PropertiesDialogProps = {
+    i18n: i18n;
+};
+export declare class PropertiesDialog extends Component<PropertiesDialogProps, DocumentInformation> {
+    private _windowResizeHandler?;
+    createTabsMetaData(): void;
+    rootElement: HTMLDivElement;
+    constructor(props: any);
+    get isVisible(): boolean;
+    close(): void;
+    shouldComponentUpdate(): boolean;
+    show(metaDataPromise: Promise<DocumentInformation>, permissionsPromise: Promise<DocumentSecuritySummary>): void;
+    hide(): void;
+    onWindowSizeChanged(): void;
+    onMouseUp(e: any): boolean;
+    render(): React.JSX.Element;
+    showTab(e: MouseEvent): void;
+    _showTabInternal(className: string): void;
+    _fillElements(fieldNames: ({
+        key: string;
+        label?: string;
+        value?: string;
+        optional?: boolean;
+        noLabel?: boolean;
+        legend?: string;
+        fields?: any[];
+    })[], state: any): JSX.Element[];
+    readFonts(val: any, descKey: string): any;
+    readDocSecurity(summary: DocumentSecuritySummary): JSX.Element;
+    readPermissions(summary: DocumentSecuritySummary): JSX.Element;
+}

package/typings/ReplyTool/AuthorLabel.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../vendor/react/react.d.ts" />
+//@ts-ignore
+import { Component } from "react";
+import { AuthorLabelModel, AuthorLabelProps } from "./types";
+export declare class AuthorLabel extends Component<AuthorLabelProps, AuthorLabelModel> {
+    constructor(props: AuthorLabelProps);
+    render(): JSX.Element[];
+}

package/typings/ReplyTool/ReplyTool.d.ts

@@ -0,0 +1,90 @@
+/// <reference path="../vendor/react/react.d.ts" />
+//@ts-ignore
+import React, { Component, KeyboardEvent } from 'react';
+import { AnnotationBase, TextAnnotation } from "../Annotations/AnnotationTypes";
+import PdfReportPlugin from '../plugin';
+/// <reference path="../vendor/i18next.d.ts" />
+//@ts-ignore
+import { i18n } from 'i18next';
+import { ReplyToolModel } from './types';
+import { GcEditableTextBehavior } from '../Utils/GcEditableTextBehavior';
+export type ReplyToolProps = {
+    coordinatesOrigin: 'TopLeft' | 'BottomLeft';
+    plugin: PdfReportPlugin;
+    navigatePage: (pageIndex: number) => void;
+    navigateAnnotation: (pageIndex: number, annotation: AnnotationBase, params?: {
+        preserveExpanded?: boolean;
+        preserveFocused?: boolean;
+        toggle?: boolean;
+    }) => void;
+    addAnnotation: (pageIndex: number, annotation: AnnotationBase) => Promise<{
+        pageIndex: number;
+        annotation: AnnotationBase;
+    }>;
+    updateAnnotation: (pageIndex: number, annotation: AnnotationBase, skipExpand: boolean) => Promise<{
+        pageIndex: number;
+        annotation: AnnotationBase;
+    }>;
+    updateAnnotations: (pageIndex: number, annotations: AnnotationBase[]) => Promise<{
+        pageIndex: number;
+        annotations: AnnotationBase[];
+    }>;
+    removeAnnotation: (pageIndex: number, id: string) => void;
+};
+export declare class ReplyTool extends Component<ReplyToolProps, ReplyToolModel> {
+    _outerElement: HTMLElement;
+    in17n: i18n;
+    _editableTextBehavior?: GcEditableTextBehavior;
+    _selectedNode: any;
+    _selectedNodePageIndex: number;
+    private _initialized;
+    private _mounted;
+    private _onAfterAddAnnotationUnreg;
+    private _activateInlineEditorAnnotationId?;
+    constructor(props: any);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    get viewer(): import("..").GcPdfViewer;
+    get eventBus(): import("../Models/ViewerTypes").IGCEventBus;
+    initialize(): void;
+    uninitialize(): void;
+    scrollItemContentIntoView(annotationId: string | HTMLElement): void;
+    render(): React.JSX.Element;
+    private _hideReplyEditor;
+    canEditAuthor(node: TextAnnotation): boolean;
+    canAddReply(node: TextAnnotation): boolean;
+    canDeleteReply(node: TextAnnotation): boolean;
+    canStatusReply(node: TextAnnotation): boolean;
+    canEditText(node: AnnotationBase): boolean;
+    private get replyToolSettings();
+    protected _renderComments(pageIndex: number, annotations: AnnotationBase[], expandedPageIndex: number, selectedAnnotationId: string): JSX.Element | null;
+    onTextLabelRendered(text: string, safeText: string, placeholder: string, isRichContents: boolean, span: HTMLSpanElement | null | undefined, pageIndex: number, node: TextAnnotation): void;
+    getNodeContents(node: TextAnnotation, annotations: AnnotationBase[]): {
+        text: string;
+        safeText: string;
+        isRichContents: boolean;
+        isEmpty: boolean;
+        emptyLabel: string;
+        placeholder: string;
+    };
+    renderNoteItemMenu(pageIndex: number, node: TextAnnotation): JSX.Element;
+    onAuthorLabelClick: (pageIndex: number, node: TextAnnotation, isSelected: boolean) => () => void;
+    _onNoteTextLabelClick: (pageIndex: number, node: TextAnnotation, isSelected: boolean) => () => void;
+    _showInlineTextEditor(textLabel: HTMLElement, pageIndex: number, node: TextAnnotation, propertyKey: 'contents' | 'title'): void;
+    forceUpdateInternal(): void;
+    _disposeEditableTextBehavior(): void;
+    _onNoteItemClick: (pageIndex: number, node: AnnotationBase) => () => boolean;
+    selectItemInternal(pageIndex: number, node: AnnotationBase): void;
+    unselectItemInternal(pageIndex: number, node: AnnotationBase): void;
+    _onPageButtonClick(pageIndex: number): void;
+    _onReplyPlaceholderClick(pageIndex: number, node: AnnotationBase): boolean;
+    _onCancelReplyClick(): boolean;
+    _onPostReplyClick(pageIndex: number, node: TextAnnotation): boolean;
+    _onItemKeyDown(event: KeyboardEvent<any>, pageIndex: number, node: AnnotationBase): Promise<void>;
+    findNextSibling(forward: boolean, fallbackToFirst?: boolean): void;
+    selectNextItem(forward: boolean, fallbackToFirst?: boolean): boolean;
+    activateElement(firstChildToFocus: HTMLElement): void;
+    execDeleteAction(pageIndex: number, node: AnnotationBase): Promise<void>;
+    private _cancelReplyInternal;
+    private _postReplyInternal;
+}