@hmcts/media-viewer/index.d.ts

Media Viewer

import * as i0 from '@angular/core';
import { ElementRef, OnDestroy, OnInit, AfterContentInit, OnChanges, EventEmitter, SimpleChanges, QueryList, AfterViewChecked, ChangeDetectorRef, AfterViewInit, AfterContentChecked, PipeTransform } from '@angular/core';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Subject, Observable, Subscription } from 'rxjs';
import * as _ngrx_store from '@ngrx/store';
import { Action, Store } from '@ngrx/store';
import { PDFViewer, DownloadManager } from 'pdfjs-dist/web/pdf_viewer.mjs';
import { ArrayDataSource, SelectionModel } from '@angular/cdk/collections';
import * as i28 from '@angular/cdk/tree';
import { FlatTreeControl } from '@angular/cdk/tree';
import * as i29$1 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i25 from '@angular/common/http';
import { HttpClient } from '@angular/common/http';
import * as i6 from '@angular/common';
import { DatePipe } from '@angular/common';
import * as i10 from '@angular/cdk/overlay';
import { ConnectionPositionPair } from '@angular/cdk/overlay';
import * as i7 from '@angular/forms';
import { FormGroup, FormBuilder, UntypedFormControl, UntypedFormGroup, UntypedFormBuilder } from '@angular/forms';
import * as i8 from '@angular/router';
import * as i12 from 'rpx-xui-translation';
import * as i22 from '@angular/cdk/a11y';
import * as i26 from 'mutable-div';
import * as i27 from 'ngx-chips';
import * as i29 from '@swimlane/ngx-datatable';
import * as _ngrx_effects from '@ngrx/effects';
import { Actions } from '@ngrx/effects';

interface Outline {
    bold: boolean;
    color: Uint8ClampedArray;
    count: number | undefined;
    dest: string | Array<any> | null;
    italic: boolean;
    items: Outline[];
    newWindow: boolean | undefined;
    pageNumber?: number;
    title: string;
    unsafeUrl: string | undefined;
    url: string | null;
}

interface User {
    forename: string;
    surname: string;
    email: string;
}

interface ApiPersisted {
    id: string;
    createdBy: string;
    createdByDetails: User;
    createdDate: string;
    lastModifiedBy: string;
    lastModifiedByDetails: User;
    lastModifiedDate: string;
}

interface Rectangle extends ApiPersisted {
    annotationId: string;
    height: number;
    width: number;
    x: number;
    y: number;
}

interface RedactionSearch {
    page?: number;
    matchedIndex?: number;
    matchesCount?: number;
}
interface RedactRectangle {
    page?: number;
    matchedIndex?: number;
    rectangles?: Rectangle[];
}

declare class IcpEventService {
    enabled: BehaviorSubject<boolean>;
    sessionLaunch: Subject<void>;
    becomingPresenter: Subject<void>;
    stoppingPresenting: Subject<void>;
    leavingSession: BehaviorSubject<boolean>;
    sessionExitConfirmed: Subject<void>;
    participantsListVisible: BehaviorSubject<boolean>;
    constructor();
    launchSession: () => void;
    enable: () => void;
    becomePresenter: () => void;
    stopPresenting: () => void;
    leaveSession: () => void;
    confirmExit: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IcpEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IcpEventService>;
}

interface SearchOperation {
    searchTerm: string;
    highlightAll: boolean;
    matchCase: boolean;
    wholeWord: boolean;
    previous: boolean;
    reset: boolean;
}
interface SearchResultsCount {
    current: number;
    total: number;
    isPrevious: boolean;
}
declare enum SearchType {
    Redact = "Redact",
    Highlight = "Highlight"
}
interface SearchMode {
    modeType: SearchType;
    isOpen: boolean;
}
declare class ToolbarEventService {
    private icpEventService;
    constructor(icpEventService: IcpEventService);
    readonly highlightModeSubject: BehaviorSubject<boolean>;
    readonly highlightToolbarSubject: BehaviorSubject<boolean>;
    readonly drawModeSubject: BehaviorSubject<boolean>;
    readonly rotateSubject: Subject<number>;
    readonly searchSubject: Subject<SearchOperation>;
    readonly searchResultsCountSubject: Subject<SearchResultsCount>;
    readonly zoomSubject: Subject<number>;
    readonly stepZoomSubject: Subject<number>;
    readonly zoomValueSubject: BehaviorSubject<number>;
    readonly pageCountSubject: Subject<number>;
    readonly printSubject: Subject<void>;
    readonly downloadSubject: Subject<void>;
    readonly setCurrentPageSubject: Subject<number>;
    readonly setCurrentPageInputValueSubject: BehaviorSubject<number>;
    readonly changePageByDeltaSubject: Subject<number>;
    readonly showCommentSummary: BehaviorSubject<boolean>;
    readonly grabNDrag: BehaviorSubject<boolean>;
    readonly saveRotationSubject: Subject<void>;
    readonly redactionMode: BehaviorSubject<boolean>;
    readonly redactionPreview: Subject<boolean>;
    readonly applyRedactToDocument: Subject<void>;
    readonly clearAllRedactMarkers: Subject<void>;
    readonly redactWholePage: Subject<void>;
    readonly redactionSerachSubject: Subject<RedactionSearch>;
    readonly redactAllInProgressSubject: BehaviorSubject<boolean>;
    readonly openRedactionSearch: BehaviorSubject<SearchMode>;
    readonly sidebarOpen: BehaviorSubject<boolean>;
    readonly sidebarOutlineView: BehaviorSubject<boolean>;
    readonly searchBarHidden: BehaviorSubject<boolean>;
    readonly commentsPanelVisible: BehaviorSubject<boolean>;
    /**
     * Reset the stateful behaviour subjects
     */
    reset(): void;
    toggleHighlightMode(): void;
    toggleDrawMode(): void;
    toggleHighlightToolbar(): void;
    rotate(angle: number): void;
    search(phrase: SearchOperation): void;
    getSearchResultsCount(): Observable<SearchResultsCount>;
    zoom(value: number): void;
    stepZoom(value: number): void;
    getZoomValue(): Observable<number>;
    getPageCount(): Observable<number>;
    print(): void;
    download(): void;
    setPage(value: number): void;
    incrementPage(value: number): void;
    getCurrentPageNumber(): Observable<number>;
    getShowCommentSummary(): Observable<boolean>;
    toggleCommentsSummary(value: boolean): void;
    saveRotation(): void;
    toggleGrabNDrag(): void;
    toggleSideBar(toggle: boolean): void;
    toggleSideBarView(toggle: boolean): void;
    toggleRedactionMode(): void;
    toggleRedactionPreview(viewMode: boolean): void;
    unmarkAll(): void;
    applyRedactionToDocument(): void;
    redactPage(): void;
    toggleCommentsPanel(isVisible: boolean): void;
    toggleParticipantsList(isVisible: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ToolbarEventService>;
}

interface DocumentState {
    convertedDocument: {
        url: string;
        error: string;
    };
    documentId: string;
    pdfPosition: PdfPosition;
    pages: {
        [id: string]: DocumentPages;
    };
    hasDifferentPageSize: boolean;
    rotation: number;
    rotationLoaded: boolean;
    loaded: boolean;
    loading: boolean;
}
interface DocumentPages {
    numberOfPages: number;
    styles: {
        left: number;
        height: number;
        width: number;
    };
    scaleRotation: {
        scale: string;
        rotation: string;
    };
    viewportScale: number;
}
interface PdfPosition {
    pageNumber: number;
    scale: number;
    top: number;
    left: number;
    rotation: number;
}

declare class PdfJsWrapper {
    private readonly pdfViewer;
    private readonly downloadManager;
    private readonly toolbarEvents;
    readonly documentLoadInit: Subject<string>;
    readonly documentLoadProgress: Subject<DocumentLoadProgress>;
    readonly documentLoaded: Subject<any>;
    readonly outlineLoaded: Subject<Outline[]>;
    readonly documentLoadFailed: Subject<Error>;
    readonly pageRendered: Subject<PageEvent[]>;
    readonly positionUpdated: Subject<{
        location: PdfPosition;
    }>;
    private zoomValue;
    private documentTitle;
    private documentOutline;
    redactionPages: {
        start: number;
        end: number;
    }[];
    constructor(pdfViewer: PDFViewer, downloadManager: DownloadManager, toolbarEvents: ToolbarEventService, documentLoadInit: Subject<string>, documentLoadProgress: Subject<DocumentLoadProgress>, documentLoaded: Subject<any>, outlineLoaded: Subject<Outline[]>, documentLoadFailed: Subject<Error>, pageRendered: Subject<PageEvent[]>, positionUpdated: Subject<{
        location: PdfPosition;
    }>);
    sendSearchDetails(event: any): void;
    drawMissingPages(e: any): void;
    onRedactionModeChanged(redactionMode: boolean): void;
    private emitDocumentInfo;
    loadDocument(documentUrl: string): Promise<void>;
    private createLoadingTask;
    private setOutlinePageNumbers;
    private setNestedOutlinePageNumbers;
    private getOutlinePageNumber;
    downloadFile(url: string, filename: string): void;
    setPageNumber(pageNumber: number): void;
    getPageNumber(): number;
    changePageNumber(numPages: number): void;
    search(operation: SearchOperation): void;
    clearSearch(): void;
    navigateTo(destination: string | any[]): void;
    nativeNavigate(destination: string | any[]): void;
    setZoom(zoomValue: number): void;
    stepZoom(zoomValue: number): void;
    private getZoomValue;
    rotate(rotation: number): number;
    resetRotation(rotation: number): number;
    getNormalisedPagesRotation(): number;
    getCurrentPDFZoomValue(): number;
    setCurrentPDFTitle(title: string): void;
    getCurrentPDFTitle(): string;
}
interface DocumentLoadProgress {
    loaded: number;
    total: number;
}
interface PageEvent {
    div: object;
    scale: number;
    rotation: number;
    id: string;
    viewportScale: number;
}

declare class PdfJsWrapperFactory {
    private readonly toolbarEvents;
    private linkService;
    private eventBus;
    private pdfJsWrapper;
    constructor(toolbarEvents: ToolbarEventService);
    create(container: ElementRef): PdfJsWrapper;
    pdfWrapper(): PdfJsWrapper;
    static ɵfac: i0.ɵɵFactoryDeclaration<PdfJsWrapperFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PdfJsWrapperFactory>;
}

interface TagsModel {
    name: string;
    label: string;
    color?: string;
    id?: string;
}

interface Comment extends ApiPersisted {
    annotationId: string;
    content: string;
    tags: TagsModel[];
    page: number;
    pages: object;
    pageHeight: number;
    selected: boolean;
    editable: boolean;
}

interface Annotation extends ApiPersisted {
    annotationSetId?: string;
    annotationId?: string;
    page?: number;
    color?: string;
    comments?: Comment[];
    rectangles?: Rectangle[];
    type?: string;
    tags: TagsModel[];
    redactionId?: string;
}

interface AnnotationSet extends ApiPersisted {
    documentId: string;
    annotations: Annotation[];
}

declare class PrintService {
    printDocumentNatively(url: string): void;
    printElementNatively(element: HTMLElement, width: number, height: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrintService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PrintService>;
}

declare enum ResponseType {
    SUCCESS = "SUCCESS",
    FAILURE = "FAILURE",
    UNSUPPORTED = "UNSUPPORTED"
}
interface ExceptionDetail {
    httpResponseCode?: string;
    message?: string;
}
declare class ViewerException {
    exceptionType?: string;
    detail?: ExceptionDetail;
    constructor(exceptionType?: string, detail?: ExceptionDetail);
}

declare class ToolbarButtonVisibilityService {
    showPrint: boolean;
    showDownload: boolean;
    showNavigation: boolean;
    showZoom: boolean;
    showRotate: boolean;
    showPresentationMode: boolean;
    showRedact: boolean;
    showOpenFile: boolean;
    showBookmark: boolean;
    showHighlightButton: boolean;
    showDrawButton: boolean;
    showSearchBar: boolean;
    showSidebar: boolean;
    showCommentSummary: boolean;
    showGrabNDragButton: boolean;
    showSaveRotationButton: boolean;
    /**
     * Reset the visibility of all buttons to false then set the value from the options
     */
    setup(options: Partial<ToolbarButtonVisibilityService>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarButtonVisibilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ToolbarButtonVisibilityService>;
}

interface SelectionAnnotation {
    annotationId: string;
    editable: boolean;
    selected: boolean;
}

interface Filters {
    tagFilters?: {
        [key: string]: any;
    };
    dateRangeFrom?: number | null;
    dateRangeTo?: number | null;
}

declare const LOAD_ANNOTATION_SET = "[Annotations] Load Annotation Set";
declare const LOAD_ANNOTATION_SET_SUCCESS = "[Annotations] Load Annotation Set Success";
declare const LOAD_ANNOTATION_SET_FAIL = "[Annotations] Load Annotation Set Fail";
declare const SAVE_ANNOTATION_SET = "[Annotations] Save Annotation Set";
declare const SAVE_ANNOTATION_SET_SUCCESS = "[Annotations] Save Annotation Set Success";
declare const SAVE_ANNOTATION_SET_FAIL = "[Annotations] Save Annotation Set Fail";
declare const SAVE_ANNOTATION = "[Annotations] Save Annotation";
declare const SAVE_ANNOTATION_SUCCESS = "[Annotations] Save Annotation Success";
declare const SAVE_ANNOTATION_FAIL = "[Annotations] Save Annotation Fail";
declare const ADD_OR_EDIT_COMMENT = "[Annotations] Add or Edit Comment";
declare const DELETE_ANNOTATION = "[Annotations] Delete Annotation";
declare const DELETE_ANNOTATION_SUCCESS = "[Annotations] Delete Annotation Success";
declare const DELETE_ANNOTATION_FAIL = "[Annotations] Delete Annotation Fail";
declare const SELECT_ANNOTATION = "[Annotations] Select Annotation";
declare const SEARCH_COMMENT = "[Comments] Search Comments";
declare const APPLY_COMMENT_SUMMARY_FILTER = "[Comments] Apply Comment Summary Filter";
declare const CLEAR_COMMENT_SUMMARY_FILTER = "[Comments] Clear Comment Summary Filter";
declare class LoadAnnotationSet implements Action {
    payload: string;
    readonly type = "[Annotations] Load Annotation Set";
    constructor(payload: string);
}
declare class SaveAnnotationSet implements Action {
    payload: AnnotationSet;
    readonly type = "[Annotations] Save Annotation Set";
    constructor(payload: AnnotationSet);
}
declare class LoadAnnotationSetSucess implements Action {
    payload: {
        status: number;
        body: AnnotationSet;
    };
    readonly type = "[Annotations] Load Annotation Set Success";
    constructor(payload: {
        status: number;
        body: AnnotationSet;
    });
}
declare class SaveAnnotationSetSuccess implements Action {
    payload: AnnotationSet;
    readonly type = "[Annotations] Save Annotation Set Success";
    constructor(payload: AnnotationSet);
}
declare class LoadAnnotationSetFail implements Action {
    payload: {
        status: number;
        body: any;
    };
    readonly type = "[Annotations] Load Annotation Set Fail";
    constructor(payload: {
        status: number;
        body: any;
    });
}
declare class SaveAnnotationSetFail implements Action {
    payload: {
        status: number;
        body: any;
    };
    readonly type = "[Annotations] Save Annotation Set Fail";
    constructor(payload: {
        status: number;
        body: any;
    });
}
declare class SaveAnnotation implements Action {
    payload: Annotation;
    autoSelect?: boolean;
    readonly type = "[Annotations] Save Annotation";
    constructor(payload: Annotation, autoSelect?: boolean);
}
declare class SaveAnnotationSuccess implements Action {
    payload: any;
    readonly type = "[Annotations] Save Annotation Success";
    constructor(payload: any);
}
declare class SaveAnnotationFail implements Action {
    payload: Error;
    readonly type = "[Annotations] Save Annotation Fail";
    constructor(payload: Error);
}
declare class AddOrEditComment implements Action {
    payload: Comment;
    readonly type = "[Annotations] Add or Edit Comment";
    constructor(payload: Comment);
}
declare class DeleteAnnotation implements Action {
    payload: string;
    readonly type = "[Annotations] Delete Annotation";
    constructor(payload: string);
}
declare class DeleteAnnotationSuccess implements Action {
    payload: string;
    readonly type = "[Annotations] Delete Annotation Success";
    constructor(payload: string);
}
declare class DeleteAnnotationFail implements Action {
    payload: Error;
    readonly type = "[Annotations] Delete Annotation Fail";
    constructor(payload: Error);
}
declare class SelectedAnnotation implements Action {
    payload: SelectionAnnotation;
    readonly type = "[Annotations] Select Annotation";
    constructor(payload: SelectionAnnotation);
}
declare class SearchComment implements Action {
    payload: string;
    readonly type = "[Comments] Search Comments";
    constructor(payload: string);
}
declare class ApplyCommentSymmaryFilter implements Action {
    payload: Filters;
    readonly type = "[Comments] Apply Comment Summary Filter";
    constructor(payload: Filters);
}
declare class ClearCommentSummaryFilters implements Action {
    readonly type = "[Comments] Clear Comment Summary Filter";
}
type AnnotationsActions = LoadAnnotationSet | LoadAnnotationSetSucess | LoadAnnotationSetFail | SaveAnnotation | SaveAnnotationSuccess | SaveAnnotationFail | SaveAnnotationSetSuccess | AddOrEditComment | DeleteAnnotation | DeleteAnnotationSuccess | DeleteAnnotationFail | SelectedAnnotation | SearchComment | ApplyCommentSymmaryFilter | ClearCommentSummaryFilters;

interface AnnotationSetState {
    annotationSet: any;
    annotationEntities: {
        [id: string]: any;
    };
    annotationPageEntities: {
        [id: string]: Annotation[];
    };
    commentEntities: {
        [id: string]: Comment;
    };
    selectedAnnotation: SelectionAnnotation;
    commentSearchQueries: {
        commentSearch: string;
    };
    commentSummaryFilters: {
        hasFilter: boolean;
        filters: Filters;
    };
    loaded: boolean;
    loading: boolean;
}
declare const initialState: AnnotationSetState;
declare function reducer(state: AnnotationSetState, action: AnnotationsActions): AnnotationSetState;
declare const getAnnoSet: (state: AnnotationSetState) => any;
declare const getCommentEnts: (state: AnnotationSetState) => {
    [id: string]: Comment;
};
declare const getAnnoPageEnt: (state: AnnotationSetState) => {
    [id: string]: Annotation[];
};
declare const getAnnoEnt: (state: AnnotationSetState) => {
    [id: string]: any;
};
declare const getSelectedAnno: (state: AnnotationSetState) => SelectionAnnotation;
declare const commentSearchQ: (state: AnnotationSetState) => {
    commentSearch: string;
};
declare const getSummaryFilters: (state: AnnotationSetState) => {
    hasFilter: boolean;
    filters: Filters;
};

interface TagsState {
    tagNameEnt: {
        [id: string]: string[];
    };
    filteredComments: {
        [id: string]: string[];
    };
    filteredPageEntities: {
        [id: string]: Annotation[];
    };
    annotations: Annotation[];
    formFilterState: {
        [id: string]: boolean;
    };
    filters: string[];
}

interface Bookmark$1 {
    id: string;
    documentId: string;
    name: string;
    pageNumber: number;
    xCoordinate: number;
    yCoordinate: number;
    children: any[];
    previous: string;
    index: number;
}
interface BookmarksPerPage {
    bookmark: {
        [id: string]: Bookmark$1;
    };
    styles: {
        left: number;
        height: number;
        width: number;
    };
}

interface BookmarksState {
    bookmarks: Bookmark$1[];
    bookmarkEntities: {
        [id: string]: Bookmark$1;
    };
    bookmarkPageEntities: {
        [id: string]: any;
    };
    editableBookmark: string;
    loaded: boolean;
    loading: boolean;
    scrollTop?: number;
}

interface Redaction {
    redactionId?: string;
    documentId?: string;
    page?: number;
    rectangles?: Rectangle[];
}

interface RedactionState {
    redactionEntities: {
        [id: string]: Redaction;
    };
    redactionPageEntities: {
        [id: string]: any;
    };
    selectedRedaction: SelectionAnnotation | {};
    redactedDocumentInfo: {
        blob: Blob;
        filename: string;
    };
    documentId: string;
}

interface IcpState {
    session: IcpSession;
    presenter: IcpParticipant;
    client: IcpParticipant;
    participants: IcpParticipant[];
}
interface IcpSession {
    sessionId: string;
    documentId: string;
    caseId: string;
    dateOfHearing: Date;
    connectionUrl: string;
}
interface IcpParticipant {
    id: string;
    username: string;
}
interface IcpScreenUpdate {
    pdfPosition: PdfPosition;
    document: string;
}

interface State {
    document: DocumentState;
    annotations: AnnotationSetState;
    tags: TagsState;
    bookmarks: BookmarksState;
    redactions: RedactionState;
    icp: IcpState;
}

interface Highlight {
    page: number;
    rectangles: Rectangle[];
}
declare class ViewerEventService {
    readonly textHighlight: Subject<Highlight>;
    readonly boxHighlight: Subject<Highlight>;
    readonly ctxToolbarCleared: Subject<void>;
    readonly navigationEvent: Subject<any[]>;
    readonly navigationEventICP: Subject<any[]>;
    constructor();
    textSelected(selectionData: Highlight): void;
    boxSelected(selectionData: Highlight): void;
    clearCtxToolbar(): void;
    goToDestination(destination: any[]): void;
    goToDestinationICP(destination: any[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ViewerEventService>;
}

declare enum IcpEvents {
    SESSION_JOINED = "IcpClientJoinedSession",
    CLIENT_DISCONNECTED = "IcpClientDisconnectedFromSession",
    NEW_PARTICIPANT_JOINED = "IcpNewParticipantJoinedSession",
    REMOVE_PARTICIPANT = "IcpRemoveParticipantFromList",
    PARTICIPANTS_UPDATED = "IcpParticipantsListUpdated",
    UPDATE_PRESENTER = "IcpNewPresenterStartsPresenting",
    PRESENTER_UPDATED = "IcpPresenterUpdated",
    UPDATE_SCREEN = "IcpUpdateScreen",
    SCREEN_UPDATED = "IcpScreenUpdated",
    SESSION_JOIN = "IcpClientJoinSession",
    SESSION_LEAVE = "IcpClientLeaveSession"
}

declare class SocketService implements OnDestroy {
    private socket;
    subscription: Subscription;
    connected$: BehaviorSubject<boolean>;
    sessionJoined$: Subject<void>;
    presenterUpdated$: Subject<void>;
    clientDisconnected$: Subject<void>;
    participantUpdated$: Subject<void>;
    newParticipantJoined$: Subject<void>;
    screenUpdated$: Subject<void>;
    constructor();
    ngOnDestroy(): void;
    connect(url: string, session: IcpSession): void;
    connected(): Observable<boolean>;
    join(session: any): void;
    leave(session: any): void;
    emit(event: string, data: any): void;
    listen(event: IcpEvents): Observable<any>;
    messageEventHandller(eventName: string, data: any): void;
    getSocketClient(url: string): Observable<WebSocket>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SocketService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SocketService>;
}

declare class IcpUpdateService {
    private socket;
    session: IcpSession;
    constructor(socket: SocketService);
    private joinSessionSubscription;
    joinSession(username: string, session: IcpSession, token: string): rxjs.Observable<any>;
    leaveSession(): void;
    newParticipantJoined(): rxjs.Observable<any>;
    clientDisconnected(): rxjs.Observable<any>;
    removeParticipant(participantId: any): void;
    participantListUpdated(): rxjs.Observable<any>;
    updatePresenter(presenter: IcpParticipant): void;
    presenterUpdated(): rxjs.Observable<any>;
    updateScreen(screen: IcpScreenUpdate): void;
    screenUpdated(): rxjs.Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IcpUpdateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IcpUpdateService>;
}

declare class IcpPresenterService {
    private readonly toolbarEvents;
    private readonly socketService;
    private store;
    session: IcpSession;
    presenter: IcpParticipant;
    pdfPosition: PdfPosition;
    $subscription: Subscription;
    constructor(toolbarEvents: ToolbarEventService, socketService: IcpUpdateService, store: Store<IcpState>);
    update(isPresenter: boolean): void;
    subscribe(): void;
    unsubscribe(): void;
    onPositionUpdate(pdfPosition: PdfPosition): void;
    onNewParticipantJoined(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IcpPresenterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IcpPresenterService>;
}

declare class IcpFollowerService {
    private readonly toolbarEvents;
    private readonly viewerEvents;
    private readonly socketService;
    private store;
    session: IcpSession;
    private previousRotation;
    $subscription: Subscription;
    constructor(toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, socketService: IcpUpdateService, store: Store<IcpState>);
    update(isFollower: boolean): void;
    subscribe(): void;
    unsubscribe(): void;
    followScreenUpdate({ pdfPosition }: {
        pdfPosition: any;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IcpFollowerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IcpFollowerService>;
}

declare class IcpService implements OnDestroy {
    private readonly toolbarEvents;
    private readonly viewerEvents;
    private readonly socketService;
    private readonly presenterSubscriptions;
    private readonly followerSubscriptions;
    private store;
    private readonly icpEventService;
    caseId: string;
    client: IcpParticipant;
    presenter: IcpParticipant;
    isPresenter: boolean;
    documentId: string;
    subscription: Subscription;
    sessionSubscription: Subscription;
    constructor(toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, socketService: IcpUpdateService, presenterSubscriptions: IcpPresenterService, followerSubscriptions: IcpFollowerService, store: Store<IcpState>, icpEventService: IcpEventService);
    ngOnDestroy(): void;
    launchSession(): void;
    setUpSessionSubscriptions(): void;
    unsubscribeSession(): void;
    leavePresentation(): void;
    stopPresenting(): void;
    becomePresenter(): void;
    clientDisconnected(client: any): void;
    removeParticipant(participantId: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IcpService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IcpService>;
}

declare class HighlightCreateService {
    private toolBarEvents;
    private store;
    constructor(toolBarEvents: ToolbarEventService, store: Store<AnnotationSetState>);
    saveAnnotation(rectangles: Rectangle[], page: number, annotationId?: string): void;
    saveAnnotationSet(searchRectangles: RedactRectangle[]): void;
    applyRotation(pageHeight: any, pageWidth: any, offsetHeight: any, offsetWidth: any, offsetTop: any, offsetLeft: any, rotate: any, zoom: any): any;
    resetHighlight(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightCreateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HighlightCreateService>;
}

declare class HighlightCreateDirective implements OnInit, OnDestroy {
    private element;
    private toolbarEvents;
    private viewerEvents;
    private highlightService;
    private store;
    pageHeight: number;
    pageWidth: number;
    zoom: number;
    rotate: number;
    allPages: object;
    private $subscriptions;
    constructor(element: ElementRef<HTMLElement>, toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, highlightService: HighlightCreateService, store: Store<AnnotationSetState>);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private focusWithoutScrolling;
    onMouseUp(mouseEvent: MouseEvent): void;
    onKeyboardSelectionConfirmed(): void;
    private getCurrentPageFromSelection;
    private getRectanglesFromSelection;
    onPdfViewerClick(event: MouseEvent): void;
    private getRectangles;
    private createTextRectangle;
    private removeEnhancedTextModeStyling;
    private setPageProperties;
    private processClientRects;
    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightCreateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HighlightCreateDirective, "[mvCreateTextHighlight]", never, {}, {}, never, never, false, never>;
}

declare class PdfViewerComponent implements AfterContentInit, OnChanges, OnDestroy {
    private store;
    private icpStore;
    private readonly pdfJsWrapperFactory;
    private readonly printService;
    readonly toolbarEvents: ToolbarEventService;
    private readonly viewerEvents;
    private icpService;
    readonly toolbarButtons: ToolbarButtonVisibilityService;
    private readonly icpEventService;
    mediaLoadStatus: EventEmitter<ResponseType>;
    pdfViewerException: EventEmitter<ViewerException>;
    documentTitle: EventEmitter<string>;
    downloadUrl: string;
    url: string;
    downloadFileName: string;
    enableAnnotations: boolean;
    enableRedactions: boolean;
    enableICP: boolean;
    annotationSet: AnnotationSet | null;
    enableRedactSearch: AnnotationSet | null;
    height: string;
    pageHeights: any[];
    rotation: number;
    zoom: number;
    caseId: string;
    highlightMode: Observable<boolean>;
    drawMode: BehaviorSubject<boolean>;
    documentOutline: Outline[];
    loadingDocument: boolean;
    loadingDocumentProgress: number;
    errorMessage: string;
    hasDifferentPageSize: boolean;
    viewerContainer: ElementRef<HTMLDivElement>;
    pdfViewer: ElementRef<HTMLDivElement>;
    highlightCreateDirective: HighlightCreateDirective;
    private pdfWrapper;
    private $subscription;
    private viewerException;
    showCommentsPanel: boolean;
    showIcpParticipantsList: boolean;
    enableGrabNDrag: boolean;
    showSelectionStartCursor: boolean;
    selectionStartCursorX: number;
    selectionStartCursorY: number;
    showSelectionEndCursor: boolean;
    selectionEndCursorX: number;
    selectionEndCursorY: number;
    constructor(store: Store<AnnotationSetState>, icpStore: Store<IcpState>, pdfJsWrapperFactory: PdfJsWrapperFactory, printService: PrintService, toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, icpService: IcpService, toolbarButtons: ToolbarButtonVisibilityService, icpEventService: IcpEventService);
    ngAfterContentInit(): Promise<void>;
    ngOnChanges(changes: SimpleChanges): Promise<void>;
    resetRotation(): void;
    ngOnDestroy(): void;
    private loadDocument;
    private onDocumentLoadProgress;
    private onDocumentLoaded;
    private onDocumentLoadFailed;
    private updatePages;
    set searchBarHidden(hidden: boolean);
    toggleCommentsSummary(): void;
    private rotateDocument;
    private initDocumentProgress;
    private setZoom;
    private stepZoom;
    setPageHeights(): void;
    calculateZoomValue(zoomValue: any, increment?: number): number;
    private goToDestination;
    private goToDestinationICP;
    getCurrentPageNumber(): number;
    onKeyboardTextSelectionConfirmed(): void;
    onKeyboardTextSelectionCancelled(): void;
    onSelectionStartCursorChanged(position: {
        x: number;
        y: number;
        visible: boolean;
    }): void;
    onSelectionEndCursorChanged(position: {
        x: number;
        y: number;
        visible: boolean;
    }): void;
    onViewerContainerFocusIn(event: FocusEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PdfViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PdfViewerComponent, "mv-pdf-viewer", never, { "downloadUrl": { "alias": "downloadUrl"; "required": false; }; "url": { "alias": "url"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; "enableAnnotations": { "alias": "enableAnnotations"; "required": false; }; "enableRedactions": { "alias": "enableRedactions"; "required": false; }; "enableICP": { "alias": "enableICP"; "required": false; }; "annotationSet": { "alias": "annotationSet"; "required": false; }; "enableRedactSearch": { "alias": "enableRedactSearch"; "required": false; }; "height": { "alias": "height"; "required": false; }; "caseId": { "alias": "caseId"; "required": false; }; "searchBarHidden": { "alias": "searchBarHidden"; "required": false; }; }, { "mediaLoadStatus": "mediaLoadStatus"; "pdfViewerException": "pdfViewerException"; "documentTitle": "documentTitle"; }, never, never, false, never>;
}

interface Bookmark {
    id: string;
    documentId: string;
    name: string;
    pageNumber: number;
    xCoordinate: number;
    yCoordinate: number;
    zoom: number;
    parent: string;
    previous: string;
    children: Bookmark[];
    index: number;
}
interface BookmarkNode {
    id: string;
    name: string;
    children: string[];
}

declare class BookmarksComponent implements OnInit, OnDestroy, OnChanges {
    private store;
    set bookmarkNodes(value: Bookmark[]);
    get bookmarkNodes(): Bookmark[];
    zoom: number;
    rotate: number;
    parentScrollTop: number;
    goToDestination: EventEmitter<any[]>;
    treeHasChanged: EventEmitter<boolean>;
    private _bookmarkNodes;
    datasource: ArrayDataSource<Bookmark>;
    treeControl: FlatTreeControl<Bookmark>;
    hoveredNode: Bookmark;
    hoverHtmlElement: HTMLElement;
    expansionModel: SelectionModel<Bookmark>;
    isDraggingOn: boolean;
    isUserdragging: boolean;
    expandTimeout: any;
    expandDelay: number;
    dragNodeInsertToParent: boolean;
    pageLookup: {
        [pageId: number]: DocumentPages;
    };
    editableBookmark: string;
    BOOKMARK_CHAR_LIMIT: number;
    dragNode: any;
    dragNodeExpandOverWaitTimeMs: number;
    dragNodeExpandOverNode: any;
    dragNodeExpandOverTime: number;
    dragNodeExpandOverArea: number;
    options: {
        allowDrag: boolean;
        allowDrop: boolean;
    };
    $subscription: Subscription;
    private sortMode;
    private readonly _customSort;
    private readonly _positionSort;
    constructor(store: Store<BookmarksState | AnnotationSetState>);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    editBookmark(id: any): void;
    onAddBookmarkClick(): void;
    deleteBookmark2(node: Bookmark): void;
    updateBookmark(bookmark: Bookmark, name: any): void;
    goToBookmark(bookmark: Bookmark): void;
    get customSort(): string;
    get positionSort(): string;
    sort(mode: string): void;
    private sortBookmarks;
    private positionSortBookmarks;
    private customSortBookmarks;
    private scaledY;
    hasChild: (_: number, node: Bookmark) => boolean;
    getNode(bookmarks: any, parentId: any): any;
    drop(event: CdkDragDrop<Bookmark>): void;
    private getSiblingFromAllSibliings;
    dragStart(): void;
    dragEnd(): void;
    dragHover(event: any, node: Bookmark): void;
    dragHoverEnd(event: any, node: Bookmark): void;
    onNodeExpand(node: Bookmark): "toggle-children-wrapper-expanded" | "toggle-children-wrapper-collapsed";
    visibleNodes(bookmarks: Bookmark[]): Bookmark[];
    findNodeSiblings(arr: Array<any>, id: string): Array<any>;
    rebuildTreeForData(data: any): void;
    isToNodeChildOfFromNode(fromNodeChildren: Bookmark[], toNode: Bookmark): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BookmarksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BookmarksComponent, "mv-bookmarks", never, { "bookmarkNodes": { "alias": "bookmarkNodes"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "parentScrollTop": { "alias": "parentScrollTop"; "required": false; }; }, { "goToDestination": "goToDestination"; "treeHasChanged": "treeHasChanged"; }, never, never, false, never>;
}

declare class SideBarComponent implements OnInit, OnChanges, OnDestroy {
    private viewerEvents;
    private store;
    private readonly toolbarEvents;
    annotationsEnabled: boolean;
    outline: Outline;
    url: string;
    zoom: number;
    rotate: number;
    currentPageNumber: number;
    bookmarks: BookmarksComponent;
    treeChanged: boolean;
    selectedView: string;
    bookmarkNodes$: Observable<BookmarkNode[]>;
    scrollTop: any;
    sidebarOpen: any;
    private subscriptions;
    sidebarDiv: any;
    constructor(viewerEvents: ViewerEventService, store: Store<BookmarksState>, toolbarEvents: ToolbarEventService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    onScroll(event: any): void;
    goToDestination(destination: any[]): void;
    hasTreeChanged(value: boolean): void;
    toggleSidebarView(sidebarView: string): void;
    isViewedItem(current: Outline, next: Outline): boolean;
    findEndPage(next: Outline): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<SideBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideBarComponent, "mv-side-bar", never, { "annotationsEnabled": { "alias": "annotationsEnabled"; "required": false; }; "outline": { "alias": "outline"; "required": false; }; "url": { "alias": "url"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "currentPageNumber": { "alias": "currentPageNumber"; "required": false; }; }, {}, never, never, false, never>;
}

declare class OutlineItemComponent implements OnInit {
    outline: Outline;
    currentPageNumber: number;
    isCurrentSection: boolean;
    endPage: number;
    navigationEvent: EventEmitter<any>;
    showOutlineItems: boolean;
    ngOnInit(): void;
    goToDestination(destination: any): void;
    toggleOutline(): void;
    isViewedItem(current: Outline, next: Outline): boolean;
    findEndPage(next: Outline): number;
    showHighlightOutlineCss(): "highlightedOutlineItem" | "outlineItem";
    static ɵfac: i0.ɵɵFactoryDeclaration<OutlineItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OutlineItemComponent, "mv-outline-item", never, { "outline": { "alias": "outline"; "required": false; }; "currentPageNumber": { "alias": "currentPageNumber"; "required": false; }; "isCurrentSection": { "alias": "isCurrentSection"; "required": false; }; "endPage": { "alias": "endPage"; "required": false; }; }, { "navigationEvent": "navigationEvent"; }, never, never, false, never>;
}

declare class ViewerUtilService {
    private http;
    constructor(http: HttpClient);
    validateFile(url: string): rxjs.Observable<Object>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerUtilService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ViewerUtilService>;
}

declare class ImageViewerComponent implements OnInit, OnDestroy, OnChanges {
    private store;
    private readonly printService;
    private readonly viewerUtilService;
    readonly toolbarEvents: ToolbarEventService;
    readonly toolbarButtons: ToolbarButtonVisibilityService;
    private viewerEvents;
    url: string;
    downloadFileName: string;
    enableAnnotations: boolean;
    annotationSet: AnnotationSet | null;
    height: string;
    mediaLoadStatus: EventEmitter<ResponseType>;
    imageViewerException: EventEmitter<ViewerException>;
    errorMessage: string;
    img: ElementRef;
    rotation: number;
    zoom: number;
    private subscriptions;
    private viewerException;
    private response;
    showCommentsPanel: boolean;
    enableGrabNDrag: boolean;
    imageHeight: number;
    imageWidth: number;
    imageLeft: number;
    imageTop: number;
    constructor(store: Store<AnnotationSetState>, printService: PrintService, viewerUtilService: ViewerUtilService, toolbarEvents: ToolbarEventService, toolbarButtons: ToolbarButtonVisibilityService, viewerEvents: ViewerEventService);
    ngOnInit(): void;
    onImageViewerClick(event: MouseEvent): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private rotateImage;
    private setZoom;
    private stepZoom;
    private download;
    setZoomValue(zoomValue: any): Promise<unknown>;
    calculateZoomValue(zoomValue: any, increment?: number): number;
    onLoadError(url: any): void;
    onLoad(img: any): void;
    initAnnoPage(img: any): void;
    toggleCommentsSummary(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageViewerComponent, "mv-image-viewer", never, { "url": { "alias": "url"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; "enableAnnotations": { "alias": "enableAnnotations"; "required": false; }; "annotationSet": { "alias": "annotationSet"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, { "mediaLoadStatus": "mediaLoadStatus"; "imageViewerException": "imageViewerException"; }, never, never, false, never>;
}

declare class UnsupportedViewerComponent implements OnInit, OnDestroy {
    readonly toolbarEvents: ToolbarEventService;
    private readonly viewerUtilService;
    url: string;
    downloadFileName: string;
    typeException: boolean;
    loadStatus: EventEmitter<ResponseType>;
    unsupportedViewerException: EventEmitter<ViewerException>;
    downloadLink: ElementRef;
    private subscriptions;
    private viewerException;
    constructor(toolbarEvents: ToolbarEventService, viewerUtilService: ViewerUtilService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnsupportedViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UnsupportedViewerComponent, "mv-unsupported-viewer", never, { "url": { "alias": "url"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; "typeException": { "alias": "typeException"; "required": false; }; }, { "loadStatus": "loadStatus"; "unsupportedViewerException": "unsupportedViewerException"; }, never, never, false, never>;
}

declare class MultimediaPlayerComponent implements OnInit, OnChanges, OnDestroy {
    readonly toolbarEvents: ToolbarEventService;
    url: string;
    downloadFileName: string;
    multimediaOn: boolean;
    loadStatus: EventEmitter<ResponseType>;
    downloadLink: ElementRef;
    videoPlayer: ElementRef;
    playbackMsg: string;
    private subscription;
    constructor(toolbarEvents: ToolbarEventService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    reloadVideo(): void;
    onSuccess(): void;
    onError(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultimediaPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultimediaPlayerComponent, "mv-multimedia-player", never, { "url": { "alias": "url"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; "multimediaOn": { "alias": "multimediaOn"; "required": false; }; }, { "loadStatus": "loadStatus"; }, never, never, false, never>;
}

declare class AnnotationApiService {
    private readonly httpClient;
    annotationApiUrl: string;
    private annotationSetBaseUrl;
    private annotationBaseUrl;
    constructor(httpClient: HttpClient);
    getAnnotationSet(documentId: string): Observable<any>;
    postAnnotationSet(body: Partial<AnnotationSet>): Observable<AnnotationSet>;
    getComments(annotationSet: Observable<AnnotationSet>): Observable<Comment[]>;
    /**
     * Sort the annotations in the response by page and then y position of their first rectangle
     */
    private sortAnnotations;
    private extractComments;
    deleteAnnotation(annotationId: string): Observable<null>;
    postAnnotation(annotation: Partial<Annotation>): Observable<Annotation>;
    get annotationSetsFullUrl(): string;
    get annotationFullsUrl(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnnotationApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AnnotationApiService>;
}

declare class TagsServices {
    private http;
    tagItems: {
        [id: string]: TagsModel[];
    };
    constructor(http: HttpClient);
    getAllTags(createdBy: string): Observable<TagsModel[]>;
    getNewTags(annoid: string): TagsModel[];
    updateTagItems(items: Array<TagsModel>, annoId: string): void;
    private snakeCase;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagsServices, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TagsServices>;
}

declare class CommentComponent implements OnInit, OnDestroy, AfterContentInit {
    private store;
    private readonly commentService;
    private tagsServices;
    CHAR_LIMIT: number;
    lastUpdate: string;
    originalComment: string;
    fullComment: string;
    author: User;
    createdBy: string;
    editor: User;
    _comment: Comment;
    _editable: boolean;
    _rectangle: any;
    totalPrevPagesHeight: number;
    rectTop: any;
    rectLeft: any;
    pageHeight: number;
    hasUnsavedChanges: boolean;
    selected: boolean;
    searchString: string;
    tagItems: TagsModel[];
    marginToComment$: Observable<boolean>;
    commentClick: EventEmitter<SelectionAnnotation>;
    renderComments: EventEmitter<Comment>;
    delete: EventEmitter<Comment>;
    updated: EventEmitter<{
        comment: Comment;
        tags: TagsModel[];
    }>;
    changes: EventEmitter<boolean>;
    rotate: number;
    zoom: number;
    index: number;
    page: number;
    form: ElementRef;
    editableComment: ElementRef<HTMLElement>;
    private subscriptions;
    constructor(store: Store<AnnotationSetState>, commentService: CommentService, tagsServices: TagsServices);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    set comment(comment: Comment);
    get comment(): Comment;
    set annotation(annotation: Annotation);
    get editable(): boolean;
    onCommentChange(updatedComment: any): void;
    deleteOrCancel(): void;
    editOrSave(): void;
    onCommentClick(): void;
    reRenderComments(): void;
    get commentTop(): number;
    get height(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommentComponent, "mv-anno-comment", never, { "rotate": { "alias": "rotate"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "index": { "alias": "index"; "required": false; }; "page": { "alias": "page"; "required": false; }; "comment": { "alias": "comment"; "required": false; }; "annotation": { "alias": "annotation"; "required": false; }; }, { "commentClick": "commentClick"; "renderComments": "renderComments"; "delete": "delete"; "updated": "updated"; "changes": "changes"; }, never, never, false, never>;
}

declare class CommentSetRenderService {
    redrawComponents(commentComponents: CommentComponent[], pageHeights: any[], rotate: number, zoom: number): void;
    sortComponents(commentComponents: CommentComponent[], pageHeights: any[], rotate: number, zoom: number): CommentComponent[];
    private adjustIfOverlapping;
    private processSort;
    private onSameLine;
    private top;
    private height;
    private difference;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentSetRenderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CommentSetRenderService>;
}

declare class CommentSetComponent implements OnInit, OnDestroy, OnChanges {
    private store;
    private readonly commentService;
    private readonly renderService;
    private readonly toolbarEvents;
    annotationSet: AnnotationSet;
    zoom: number;
    rotate: number;
    height: number;
    pageHeights: any[];
    contentScrollTop: number;
    comments: Comment[];
    tags: TagsModel[];
    private subscriptions;
    comments$: Observable<Annotation[]>;
    annoEntities$: Observable<{
        [id: string]: Annotation;
    }>;
    container: ElementRef<HTMLDivElement>;
    panel: ElementRef<HTMLDivElement>;
    commentComponents: QueryList<CommentComponent>;
    showCommentsPanel: boolean;
    constructor(store: Store<AnnotationSetState>, commentService: CommentService, renderService: CommentSetRenderService, toolbarEvents: ToolbarEventService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    onSelect(annotationId: SelectionAnnotation): void;
    onCommentDelete(comment: Comment): void;
    redrawComments(): void;
    private rotateDocument;
    onCommentUpdate(payload: {
        comment: Comment;
        tags: TagsModel[];
    }): void;
    onAnnotationUpdate(annotation: Annotation): void;
    onContainerClick(e: any): void;
    clearSelection(): void;
    allCommentsSaved(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentSetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommentSetComponent, "mv-comment-set", never, { "annotationSet": { "alias": "annotationSet"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "height": { "alias": "height"; "required": false; }; "pageHeights": { "alias": "pageHeights"; "required": false; }; "contentScrollTop": { "alias": "contentScrollTop"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CommentService {
    readonly unsavedChanges: Subject<boolean>;
    readonly marginToCommentEmitter: BehaviorSubject<boolean>;
    commentSetComponent: CommentSetComponent;
    setCommentSet(commentSetComponent: any): void;
    onCommentChange(changes: boolean): void;
    getUnsavedChanges(): Observable<boolean>;
    hasUnsavedComments(annotation: Annotation): boolean;
    updateUnsavedCommentsStatus(annotation: Annotation, hasUnsavedChanges: boolean): void;
    getComment(annotation: Annotation): CommentComponent;
    resetCommentSet(): void;
    allCommentsSaved(): void;
    createMarginToCommentEvent(margin: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CommentService>;
}

declare class MediaViewerComponent implements OnChanges, OnDestroy, AfterContentInit, AfterViewChecked {
    private store;
    readonly toolbarButtons: ToolbarButtonVisibilityService;
    readonly toolbarEvents: ToolbarEventService;
    private readonly api;
    private readonly comment