@hmcts/media-viewer 4.1.10 → 4.2.0

package/index.d.ts

@@ -1,6 +1,2318 @@
+import * as i0 from '@angular/core';
+import { ElementRef, OnDestroy, AfterContentInit, OnChanges, EventEmitter, SimpleChanges, OnInit, 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 i27$1 from '@angular/cdk/tree';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import * as i28 from '@angular/cdk/drag-drop';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i23 from '@angular/common/http';
+import { HttpClient } from '@angular/common/http';
+import * as i5 from '@angular/common';
+import { DatePipe } from '@angular/common';
+import * as i10 from '@angular/cdk/overlay';
+import { ConnectionPositionPair } from '@angular/cdk/overlay';
+import * as i22 from '@angular/forms';
+import { FormGroup, FormBuilder, UntypedFormControl, UntypedFormGroup, UntypedFormBuilder } from '@angular/forms';
+import * as i11 from '@angular/router';
+import * as i29 from 'rpx-xui-translation';
+import * as i20 from '@angular/cdk/a11y';
+import * as i24 from 'mutable-div';
+import * as i25 from 'ngx-chips';
+import * as i27 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: Subject<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;
+    readonly type = "[Annotations] Save Annotation";
+    constructor(payload: Annotation);
+}
+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 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>;
+    private pdfWrapper;
+    private $subscription;
+    private viewerException;
+    showCommentsPanel: boolean;
+    showIcpParticipantsList: boolean;
+    enableGrabNDrag: boolean;
+    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;
+    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 commentService;
+    private elRef;
+    private cdr;
+    icpEventService: IcpEventService;
+    viewerRef: ElementRef;
+    url: any;
+    downloadFileName: string;
+    contentType: string;
+    showToolbar: boolean;
+    toolbarButtonOverrides: any;
+    height: string;
+    viewerHeight: string;
+    width: string;
+    mediaLoadStatus: EventEmitter<ResponseType>;
+    viewerException: EventEmitter<ViewerException>;
+    toolbarEventsOutput: EventEmitter<ToolbarEventService>;
+    unsavedChanges: EventEmitter<boolean>;
+    enableAnnotations: boolean;
+    annotationApiUrl: any;
+    enableRedactions: boolean;
+    enableICP: boolean;
+    multimediaPlayerEnabled: boolean;
+    enableRedactSearch: boolean;
+    caseId: string;
+    multimediaContent: boolean;
+    convertibleContent: boolean;
+    unsupportedContent: boolean;
+    documentTitle: string;
+    showCommentSummary: boolean;
+    annotationSet$: Observable<AnnotationSet | {}>;
+    hasScrollBar: boolean;
+    typeException: boolean;
+    hasDifferentPageSize$: Observable<boolean>;
+    documentId: string;
+    private $subscriptions;
+    private prevOffset;
+    constructor(store: Store<AnnotationSetState>, toolbarButtons: ToolbarButtonVisibilityService, toolbarEvents: ToolbarEventService, api: AnnotationApiService, commentService: CommentService, elRef: ElementRef, cdr: ChangeDetectorRef, icpEventService: IcpEventService);
+    ngAfterContentInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    needsConverting(): boolean;
+    isMultimedia(): boolean;
+    isSupported(): boolean;
+    onMediaLoad(status: ResponseType): void;
+    setToolbarButtons(): void;
+    onLoadException(exception: ViewerException): void;
+    onCommentChange(changes: boolean): void;
+    onDocumentTitleChange(title: string): void;
+    private extractDMStoreDocId;
+    detectOs(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MediaViewerComponent, "mv-media-viewer", never, { "url": { "alias": "url"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; "contentType": { "alias": "contentType"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "toolbarButtonOverrides": { "alias": "toolbarButtonOverrides"; "required": false; }; "height": { "alias": "height"; "required": false; }; "width": { "alias": "width"; "required": false; }; "enableAnnotations": { "alias": "enableAnnotations"; "required": false; }; "annotationApiUrl": { "alias": "annotationApiUrl"; "required": false; }; "enableRedactions": { "alias": "enableRedactions"; "required": false; }; "enableICP": { "alias": "enableICP"; "required": false; }; "multimediaPlayerEnabled": { "alias": "multimediaPlayerEnabled"; "required": false; }; "enableRedactSearch": { "alias": "enableRedactSearch"; "required": false; }; "caseId": { "alias": "caseId"; "required": false; }; }, { "mediaLoadStatus": "mediaLoadStatus"; "viewerException": "viewerException"; "toolbarEventsOutput": "toolbarEventsOutput"; "unsavedChanges": "unsavedChanges"; }, never, never, false, never>;
+}
+
+declare class ConvertibleContentViewerComponent implements OnInit, OnDestroy, OnChanges {
+    private store;
+    originalUrl: any;
+    downloadFileName: string;
+    height: any;
+    enableAnnotations: boolean;
+    enableRedactions: boolean;
+    annotationSet: AnnotationSet | null;
+    mediaLoadStatus: EventEmitter<ResponseType>;
+    viewerException: EventEmitter<ViewerException>;
+    documentTitle: EventEmitter<string>;
+    private $subscription;
+    convertedUrl: string;
+    constructor(store: Store<DocumentState>);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onMediaLoad(status: ResponseType): void;
+    onLoadException(exception: ViewerException): void;
+    onDocumentTitleChange(title: string): void;
+    private extractDMStoreDocId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConvertibleContentViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConvertibleContentViewerComponent, "mv-conversion-viewer", never, { "originalUrl": { "alias": "originalUrl"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; "height": { "alias": "height"; "required": false; }; "enableAnnotations": { "alias": "enableAnnotations"; "required": false; }; "enableRedactions": { "alias": "enableRedactions"; "required": false; }; "annotationSet": { "alias": "annotationSet"; "required": false; }; }, { "mediaLoadStatus": "mediaLoadStatus"; "viewerException": "viewerException"; "documentTitle": "documentTitle"; }, never, never, false, never>;
+}
+
+declare class GrabNDragDirective {
+    private el;
+    originalPosition: {
+        left: number;
+        top: number;
+    };
+    private pointerDown;
+    dragEnabled: boolean;
+    dragX: Element;
+    constructor(el: ElementRef);
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onWindowPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GrabNDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GrabNDragDirective, "[mvGrabNDrag]", never, { "dragEnabled": { "alias": "dragEnabled"; "required": false; }; "dragX": { "alias": "dragX"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RotationPersistDirective implements OnInit, OnDestroy {
+    private el;
+    private store;
+    readonly toolbarButtons: ToolbarButtonVisibilityService;
+    private toolbarEvents;
+    documentId: string;
+    rotation: number;
+    savedRotation: number;
+    $subscriptions: Subscription;
+    constructor(el: ElementRef, store: Store<DocumentState>, toolbarButtons: ToolbarButtonVisibilityService, toolbarEvents: ToolbarEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onMediaLoad(status: ResponseType): void;
+    private onRotate;
+    private saveRotation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RotationPersistDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RotationPersistDirective, "[mvRotationPersist]", never, {}, {}, never, never, false, never>;
+}
+
+declare class HighlightCreateService {
+    private toolBarEvents;
+    private store;
+    constructor(toolBarEvents: ToolbarEventService, store: Store<AnnotationSetState>);
+    saveAnnotation(rectangles: Rectangle[], page: number): 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;
+    $subscription: Subscription;
+    constructor(element: ElementRef<HTMLElement>, toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, highlightService: HighlightCreateService, store: Store<AnnotationSetState>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onMouseUp(mouseEvent: MouseEvent): void;
+    onPdfViewerClick(event: MouseEvent): void;
+    private getRectangles;
+    private createTextRectangle;
+    private removeEnhancedTextModeStyling;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightCreateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HighlightCreateDirective, "[mvCreateTextHighlight]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ConfirmActionDialogComponent implements AfterViewInit {
+    private icpEventService;
+    modalContainer: ElementRef;
+    constructor(icpEventService: IcpEventService);
+    ngAfterViewInit(): void;
+    onCancel(): void;
+    onConfirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmActionDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmActionDialogComponent, "mv-confirm-action", never, {}, {}, never, never, false, never>;
+}
+
+declare class RedactionComponent implements OnInit, OnDestroy {
+    private store;
+    private readonly viewerEvents;
+    private toolbarEvents;
+    zoom: number;
+    rotate: number;
+    redactionsPerPage$: Observable<any>;
+    selectedRedaction$: Observable<SelectionAnnotation | {}>;
+    rectangles: Rectangle[];
+    drawMode: boolean;
+    documentId: string;
+    private $subscription;
+    constructor(store: Store<State>, viewerEvents: ViewerEventService, toolbarEvents: ToolbarEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    markTextRedaction(highlight: any): void;
+    markBoxRedaction({ rectangles, page }: {
+        rectangles: any;
+        page: any;
+    }): void;
+    saveRedaction(page: number, rectangles: Rectangle[]): void;
+    onMarkerDelete(event: any): void;
+    selectRedaction(event: any): void;
+    onMarkerUpdate(redaction: Redaction): void;
+    downloadDocument({ blob, filename }: {
+        blob: any;
+        filename: any;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedactionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RedactionComponent, "mv-redactions", never, { "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BookmarkIconsComponent implements OnInit {
+    private store;
+    zoom: number;
+    rotate: number;
+    bookmarksPerPage$: Observable<BookmarksPerPage[]>;
+    bookmarks: Bookmark$1[];
+    documentId: string;
+    constructor(store: Store<State>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BookmarkIconsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BookmarkIconsComponent, "mv-bookmark-icons", never, { "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ParticipantsListComponent implements OnInit, OnDestroy {
+    private readonly toolbarEvents;
+    private store;
+    private readonly icpEventService;
+    subscription: Subscription;
+    participants$: Observable<IcpParticipant[]>;
+    presenter$: Observable<IcpParticipant>;
+    isPresenter$: Observable<boolean>;
+    showParticipantsList: boolean;
+    constructor(toolbarEvents: ToolbarEventService, store: Store<IcpState>, icpEventService: IcpEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantsListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParticipantsListComponent, "mv-participants-list", never, {}, {}, never, never, false, never>;
+}
+
+declare class SearchBarComponent implements OnInit, OnDestroy, AfterViewInit {
+    readonly toolbarButtons: ToolbarButtonVisibilityService;
+    readonly toolbarEvents: ToolbarEventService;
+    findInput: ElementRef<HTMLInputElement>;
+    findNext: ElementRef<HTMLAnchorElement>;
+    highlightAll: boolean;
+    matchCase: boolean;
+    wholeWord: boolean;
+    resultsText: string;
+    searchText: string;
+    resultCount: number;
+    private subscriptions;
+    advancedSearchVisible: boolean;
+    constructor(toolbarButtons: ToolbarButtonVisibilityService, toolbarEvents: ToolbarEventService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onWindowKeyDown(e: KeyboardEvent): void;
+    searchNext(): void;
+    searchPrev(): void;
+    search(): void;
+    private setSearchResultsCount;
+    onEscapeKeyPress(e: KeyboardEvent): void;
+    onEnterKeyPress(e: KeyboardEvent): void;
+    toggleAdvancedSearch(): void;
+    toggleSearchBar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchBarComponent, "mv-search-bar", never, {}, {}, never, never, false, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Number Helper Service
+ * */
+declare class NumberHelperService {
+    constructor();
+    isNumber(value: string | number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NumberHelperService>;
+}
+
+declare class MainToolbarComponent implements OnInit, OnDestroy, AfterViewInit {
+    readonly toolbarEvents: ToolbarEventService;
+    readonly toolbarButtons: ToolbarButtonVisibilityService;
+    private readonly cdr;
+    private readonly numberHelper;
+    private readonly icpEventService;
+    enableAnnotations: boolean;
+    enableRedactions: boolean;
+    enableICP: boolean;
+    contentType: any;
+    zoomSelect: ElementRef;
+    mvToolbarMain: ElementRef<HTMLElement>;
+    mvMenuItems: ElementRef<HTMLElement>;
+    private readonly subscriptions;
+    icpEnabled: boolean;
+    redactionEnabled: boolean;
+    showCommentsPanel: boolean;
+    redactAllInProgress: boolean;
+    pageNumber: number;
+    pageCount: number;
+    isDropdownMenuOpen: boolean;
+    isBookmarksOpen: boolean;
+    isIndexOpen: boolean;
+    isRedactOpen: boolean;
+    isCommentsOpen: boolean;
+    dropdownMenuPositions: ConnectionPositionPair[];
+    zoomScales: number[];
+    allButtonsWidth: number;
+    widthRequiredForBtn: {
+        [id: string]: number;
+    };
+    constructor(toolbarEvents: ToolbarEventService, toolbarButtons: ToolbarButtonVisibilityService, cdr: ChangeDetectorRef, numberHelper: NumberHelperService, icpEventService: IcpEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    onResize(): void;
+    onControlPrint(event: KeyboardEvent): void;
+    onClickHighlightToggle(): void;
+    onClickDrawToggle(): void;
+    toggleIndexSideBar(): void;
+    onToolBarOffSetChange(buttonId: string): "button-hidden-on-toolbar" | "button-hidden-on-dropdown";
+    toggleBookmarksSideBar(): void;
+    togglePresentBar(): void;
+    increasePageNumber(): void;
+    decreasePageNumber(): void;
+    onPageNumberInputChange(pageNumber: string): void;
+    private setCurrentPage;
+    rotate(rotation: number): void;
+    printFile(): void;
+    downloadFile(): void;
+    zoom(zoomFactor: string): void;
+    stepZoom(zoomFactor: number): void;
+    toggleCommentsPanel(): void;
+    toggleRedactBar(): void;
+    toggleGrabNDrag(): void;
+    isPdf(): boolean;
+    toggleSearchBar(): void;
+    toggleMoreOptions(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MainToolbarComponent, "mv-main-toolbar", never, { "enableAnnotations": { "alias": "enableAnnotations"; "required": false; }; "enableRedactions": { "alias": "enableRedactions"; "required": false; }; "enableICP": { "alias": "enableICP"; "required": false; }; "contentType": { "alias": "contentType"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RedactionToolbarComponent implements OnInit, OnDestroy {
+    readonly toolbarEventService: ToolbarEventService;
+    readonly toolbarButtons: ToolbarButtonVisibilityService;
+    private store;
+    showRedactSearch: boolean;
+    preview: boolean;
+    hasRedactions: boolean;
+    private subscriptions;
+    redactionAllInProgress: boolean;
+    constructor(toolbarEventService: ToolbarEventService, toolbarButtons: ToolbarButtonVisibilityService, store: Store<AnnotationSetState>);
+    ngOnInit(): void;
+    onRedactAllSearch(): void;
+    toggleTextRedactionMode(): void;
+    toggleDrawMode(): void;
+    togglePreview(): void;
+    unmarkAll(): void;
+    redact(): void;
+    toggleRedactBar(): void;
+    redactPage(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedactionToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RedactionToolbarComponent, "mv-redaction-toolbar", never, { "showRedactSearch": { "alias": "showRedactSearch"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IcpToolbarComponent implements OnInit, OnDestroy {
+    readonly toolbarEventService: ToolbarEventService;
+    private store;
+    readonly icpEventService: IcpEventService;
+    presenterName: string;
+    isPresenter: boolean;
+    private $subscription;
+    constructor(toolbarEventService: ToolbarEventService, store: Store<IcpState>, icpEventService: IcpEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    present(): void;
+    stopPresenting(): void;
+    leaveIcpSession(): void;
+    showParticipantsList(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IcpToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IcpToolbarComponent, "mv-icp-toolbar", never, {}, {}, never, never, false, never>;
+}
+
+declare class RedactionSearchBarComponent implements OnInit, OnDestroy {
+    private store;
+    readonly toolbarButtons: ToolbarButtonVisibilityService;
+    readonly toolbarEvents: ToolbarEventService;
+    readonly highlightService: HighlightCreateService;
+    findInput: ElementRef<HTMLInputElement>;
+    highlightAll: boolean;
+    matchCase: boolean;
+    wholeWord: boolean;
+    resultsText: string;
+    searchText: string;
+    resultCount: number;
+    redactElements: RedactRectangle[];
+    pageHeight: number;
+    pageWidth: number;
+    zoom: number;
+    rotate: number;
+    allPages: object;
+    redactAll: boolean;
+    openSearchModal: boolean;
+    redactAllInProgress: boolean;
+    redactAllText?: string;
+    searchType: SearchType;
+    inProgressText: string;
+    titleText: string;
+    private subscription;
+    private documentId;
+    advancedSearchVisible: boolean;
+    constructor(store: Store<State>, toolbarButtons: ToolbarButtonVisibilityService, toolbarEvents: ToolbarEventService, highlightService: HighlightCreateService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onWindowKeyDown(e: KeyboardEvent): void;
+    search(reset?: boolean): void;
+    modeText(): void;
+    private saveRedaction;
+    private existInRedactElements;
+    onCloseSearchModal(): void;
+    private setSearchResultsCount;
+    private redactAllSearched;
+    private redactAllSearchedTick;
+    private cleanUpPostSave;
+    private CreateRedactAllText;
+    onEscapeKeyPress(e: KeyboardEvent): void;
+    onEnterKeyPress(e: KeyboardEvent): void;
+    toggleSearchBar(): void;
+    private getRectangles;
+    private createTextRectangle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedactionSearchBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RedactionSearchBarComponent, "mv-redaction-search-bar", never, {}, {}, never, never, false, never>;
+}
+
+declare class HighlightToolbarComponent implements OnInit, OnDestroy {
+    readonly toolbarEventService: ToolbarEventService;
+    readonly toolbarButtons: ToolbarButtonVisibilityService;
+    private subscriptions;
+    redactionAllInProgress: boolean;
+    constructor(toolbarEventService: ToolbarEventService, toolbarButtons: ToolbarButtonVisibilityService);
+    ngOnInit(): void;
+    onAllSearch(): void;
+    onHighlight(): void;
+    onClickDrawToggle(): void;
+    onClose(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HighlightToolbarComponent, "mv-highlight-toolbar", never, {}, {}, never, never, false, never>;
+}
+
+declare class TooltipDismissDirective {
+    private el;
+    constructor(el: ElementRef);
+    onEscapeDismissTooltip(): void;
+    onShowTooltip(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDismissDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDismissDirective, ".mv-tooltip, [mvTooltipDismiss]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ToolbarModule, [typeof SearchBarComponent, typeof MainToolbarComponent, typeof RedactionToolbarComponent, typeof IcpToolbarComponent, typeof RedactionSearchBarComponent, typeof HighlightToolbarComponent, typeof TooltipDismissDirective], [typeof i5.CommonModule, typeof i22.FormsModule, typeof i10.OverlayModule, typeof i11.RouterModule, typeof i29.RpxTranslationModule], [typeof MainToolbarComponent, typeof SearchBarComponent, typeof RedactionToolbarComponent, typeof IcpToolbarComponent, typeof RedactionSearchBarComponent, typeof HighlightToolbarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ToolbarModule>;
+}
+
+declare class MetadataLayerComponent implements OnInit, OnDestroy {
+    private store;
+    private readonly highlightService;
+    private readonly toolbarEvents;
+    private readonly viewerEvents;
+    zoom: number;
+    rotate: number;
+    pages: any[];
+    annoPages$: Observable<any>;
+    drawMode: boolean;
+    highlightPage: number;
+    rectangles: Rectangle[];
+    private $subscriptions;
+    constructor(store: Store<AnnotationSetState>, highlightService: HighlightCreateService, toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    showContextToolbar(highlight: Highlight): void;
+    clearContextToolbar(): void;
+    createHighlight(): void;
+    createBookmark(rectangle: Rectangle): void;
+    saveAnnotation({ rectangles, page }: {
+        rectangles: Rectangle[];
+        page: any;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataLayerComponent, "mv-metadata-layer", never, { "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AnnotationViewComponent {
+    private readonly toolbarEvents;
+    private store;
+    set annotation(value: any);
+    anno: Annotation;
+    selected: boolean;
+    zoom: number;
+    rotate: number;
+    set selectedAnnoId(selectedId: {
+        annotationId: string;
+    });
+    pageHeight: number;
+    pageWidth: number;
+    update: EventEmitter<Annotation>;
+    delete: EventEmitter<Annotation>;
+    annotationClick: EventEmitter<SelectionAnnotation>;
+    container: ElementRef;
+    constructor(toolbarEvents: ToolbarEventService, store: Store<AnnotationSetState>);
+    onSelect(): void;
+    onRectangleUpdate(rectangle: Rectangle): void;
+    deleteHighlight(): void;
+    addOrEditComment(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnotationViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnotationViewComponent, "mv-annotation", never, { "annotation": { "alias": "annotation"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "selectedAnnoId": { "alias": "selectedAnnoId"; "required": false; }; "pageHeight": { "alias": "pageHeight"; "required": false; }; "pageWidth": { "alias": "pageWidth"; "required": false; }; }, { "update": "update"; "delete": "delete"; "annotationClick": "annotationClick"; }, never, never, false, never>;
+}
+
+declare class BoxHighlightCreateComponent implements OnInit, OnDestroy {
+    private readonly toolbarEvents;
+    private readonly highlightService;
+    page: number;
+    pageHeight: number;
+    pageWidth: number;
+    rotate: number;
+    zoom: number;
+    container: {
+        top: number;
+        left: number;
+    };
+    saveSelection: EventEmitter<{
+        rectangles: Rectangle[];
+        page: number;
+    }>;
+    highlight: ElementRef;
+    drawStartX: number;
+    drawStartY: number;
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+    display: string;
+    drawMode: boolean;
+    defaultHeight: string;
+    defaultWidth: string;
+    position: string;
+    backgroundColor: string;
+    wholePage: boolean;
+    private subscriptions;
+    constructor(toolbarEvents: ToolbarEventService, highlightService: HighlightCreateService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    initHighlight(event: MouseEvent): void;
+    updateHighlight(event: MouseEvent): void;
+    createHighlight(): void;
+    private resetHighlight;
+    private highlightPage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BoxHighlightCreateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BoxHighlightCreateComponent, "mv-box-highlight-create", never, { "page": { "alias": "page"; "required": false; }; "pageHeight": { "alias": "pageHeight"; "required": false; }; "pageWidth": { "alias": "pageWidth"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "container": { "alias": "container"; "required": false; }; }, { "saveSelection": "saveSelection"; }, never, never, false, never>;
+}
+
+declare class AnnotationSetComponent implements OnInit {
+    private store;
+    private readonly commentService;
+    page: number;
+    annotations: Annotation[];
+    zoom: number;
+    rotate: number;
+    pageHeight: number;
+    pageWidth: number;
+    selectedAnnotation$: Observable<SelectionAnnotation>;
+    constructor(store: Store<AnnotationSetState>, commentService: CommentService);
+    ngOnInit(): void;
+    onAnnotationUpdate(annotation: Annotation): void;
+    onAnnotationDelete(annotation: Annotation): void;
+    selectAnnotation(selectedAnnotation: SelectionAnnotation): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnotationSetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnotationSetComponent, "mv-annotation-set", never, { "page": { "alias": "page"; "required": false; }; "annotations": { "alias": "annotations"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "pageHeight": { "alias": "pageHeight"; "required": false; }; "pageWidth": { "alias": "pageWidth"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RectangleComponent implements OnChanges, AfterViewInit, OnDestroy {
+    private readonly toolbarEvents;
+    private readonly highlightService;
+    color: String;
+    zoom: number;
+    rotate: number;
+    editable: boolean;
+    pageHeight: number;
+    pageWidth: number;
+    selectEvent: EventEmitter<Rectangle>;
+    updateEvent: EventEmitter<Rectangle>;
+    viewRect: ElementRef;
+    private subscriptions;
+    _selected: boolean;
+    enableGrabNDrag: boolean;
+    height: number;
+    width: number;
+    top: number;
+    left: number;
+    _annoRect: Rectangle;
+    set annoRect(annoRect: Rectangle);
+    get annoRect(): Rectangle;
+    constructor(toolbarEvents: ToolbarEventService, highlightService: HighlightCreateService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    set selected(selected: boolean);
+    get selected(): boolean;
+    onClick(): void;
+    onUpdate(viewRect: any): void;
+    adjustForRotation(rotation: number): void;
+    hasRectangleChanged(viewRect: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RectangleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RectangleComponent, "mv-anno-rectangle", never, { "color": { "alias": "color"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "pageHeight": { "alias": "pageHeight"; "required": false; }; "pageWidth": { "alias": "pageWidth"; "required": false; }; "annoRect": { "alias": "annoRect"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "selectEvent": "selectEvent"; "updateEvent": "updateEvent"; }, never, never, false, never>;
+}
+
+declare class CommentSetHeaderComponent implements OnInit, OnDestroy {
+    private store;
+    private commentService;
+    toolbarEvents: ToolbarEventService;
+    readonly icpEventService: IcpEventService;
+    showCommentSummary: boolean;
+    isHidden: boolean;
+    readonly showCommentSummaryDialog: EventEmitter<any>;
+    marginToComment: boolean;
+    tabs: {
+        isFiltered?: boolean;
+        label: string;
+    }[];
+    tabSelected: string;
+    isFiltered: boolean;
+    navigationList: Annotation[];
+    $subscriptions: Subscription;
+    constructor(store: Store<State>, commentService: CommentService, toolbarEvents: ToolbarEventService, icpEventService: IcpEventService);
+    ngOnInit(): void;
+    toggleCommentsSummary(): void;
+    selectTab(tab: string): void;
+    toggleCommentsPanel(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentSetHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentSetHeaderComponent, "mv-comment-set-header", never, { "showCommentSummary": { "alias": "showCommentSummary"; "required": false; }; "isHidden": { "alias": "isHidden"; "required": false; }; }, { "showCommentSummaryDialog": "showCommentSummaryDialog"; }, never, never, false, never>;
+}
+
+declare class CommentSearchComponent implements AfterViewInit, OnDestroy {
+    private store;
+    annotations: Annotation[];
+    searchInput: ElementRef<HTMLInputElement>;
+    searchString: string;
+    searchResults: Annotation[];
+    searchIndex: number;
+    constructor(store: Store<AnnotationSetState>);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    searchComments(searchText: string): void;
+    clearSearch(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentSearchComponent, "mv-comment-search", never, { "annotations": { "alias": "annotations"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TextHighlightDirective implements AfterViewChecked {
+    private element;
+    textToHighlight: string;
+    constructor(element: ElementRef<HTMLElement>);
+    ngAfterViewChecked(): void;
+    highlightInputText(textToHighlight: string): void;
+    resetHighlight(): void;
+    private highlightPattern;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextHighlightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextHighlightDirective, "[mvTextHighlight]", never, { "textToHighlight": { "alias": "textToHighlight"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class CtxToolbarComponent implements OnChanges {
+    readonly defaultHeight: any;
+    readonly defaultWidth: any;
+    zoom: any;
+    rotate: any;
+    pageHeight: number;
+    pageWidth: number;
+    canHighlight: boolean;
+    canBookmark: boolean;
+    canComment: boolean;
+    canDelete: boolean;
+    createHighlightEvent: EventEmitter<any>;
+    deleteHighlightEvent: EventEmitter<any>;
+    addOrEditCommentEvent: EventEmitter<any>;
+    createBookmarkEvent: EventEmitter<Rectangle>;
+    rectangle: Rectangle;
+    _rectangles: Rectangle[];
+    top: number;
+    left: number;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    set rectangles(rectangles: Rectangle[]);
+    get rectangles(): Rectangle[];
+    createHighlight(): void;
+    deleteHighlight(): void;
+    addOrEditComment(): void;
+    createBookmark(): void;
+    setRectangle(): void;
+    popupTop(): any;
+    popupLeft(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CtxToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CtxToolbarComponent, "mv-ctx-toolbar", never, { "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "pageHeight": { "alias": "pageHeight"; "required": false; }; "pageWidth": { "alias": "pageWidth"; "required": false; }; "canHighlight": { "alias": "canHighlight"; "required": false; }; "canBookmark": { "alias": "canBookmark"; "required": false; }; "canComment": { "alias": "canComment"; "required": false; }; "canDelete": { "alias": "canDelete"; "required": false; }; "rectangles": { "alias": "rectangles"; "required": false; }; }, { "createHighlightEvent": "createHighlightEvent"; "deleteHighlightEvent": "deleteHighlightEvent"; "addOrEditCommentEvent": "addOrEditCommentEvent"; "createBookmarkEvent": "createBookmarkEvent"; }, never, never, false, never>;
+}
+
+declare class CommentsNavigateComponent implements OnChanges {
+    private store;
+    readonly toolbarEvents: ToolbarEventService;
+    annotationList: Annotation[];
+    autoSelect: boolean;
+    navigationList: any[];
+    index: number;
+    constructor(store: Store<AnnotationSetState>, toolbarEvents: ToolbarEventService);
+    ngOnChanges(changes: SimpleChanges): void;
+    initNavigationList(): void;
+    sortComments(mappedCommentA: any, mappedCommentB: any): number;
+    nextItem(): void;
+    prevItem(): void;
+    upperRectangle(rectangles: Rectangle[]): {
+        x: number;
+        y: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentsNavigateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentsNavigateComponent, "mv-comments-navigate", never, { "annotationList": { "alias": "annotationList"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TextareaAutoExpandDirective implements AfterContentChecked {
+    private el;
+    constructor(el: ElementRef);
+    ngAfterContentChecked(): void;
+    onMouseDown(): void;
+    adjustHeight(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaAutoExpandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextareaAutoExpandDirective, "[mvTextAreaAutoExpand]", never, {}, {}, never, never, false, never>;
+}
+
+declare class CommentsSummaryComponent implements OnInit, OnDestroy {
+    private store;
+    private readonly printService;
+    private readonly toolbarEvents;
+    private fb;
+    title: string;
+    contentType: string;
+    container: ElementRef;
+    commentsTable: ElementRef;
+    comments$: Observable<any>;
+    filtersFg: FormGroup;
+    private $subscriptions;
+    allTags$: Observable<{
+        key: string;
+        length: number;
+    }[]>;
+    showFilters: boolean;
+    hasFilter: boolean;
+    fromFilterValid: boolean;
+    toFilterValid: boolean;
+    constructor(store: Store<AnnotationSetState>, printService: PrintService, toolbarEvents: ToolbarEventService, fb: FormBuilder);
+    ngOnInit(): void;
+    buildCheckBoxForm(): void;
+    onClearFilters(): void;
+    onFilter(): void;
+    onFiltersToggle(): void;
+    onClose(): void;
+    onPrint(): void;
+    navigateToPage(pageNumber: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentsSummaryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentsSummaryComponent, "mv-comments-summary", never, { "title": { "alias": "title"; "required": false; }; "contentType": { "alias": "contentType"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TagsComponent {
+    private tagsServices;
+    tagItems: TagsModel[];
+    userId: string;
+    editable: boolean;
+    annoId: string;
+    validators: (((control: UntypedFormControl) => {
+        minLength: boolean;
+    }) | ((control: UntypedFormControl) => {
+        maxLength20: boolean;
+    }))[];
+    errorMessages: {
+        [id: string]: string;
+    };
+    constructor(tagsServices: TagsServices);
+    onUpdateTags(value: any): void;
+    requestAutocompleteItems: (text: string) => Observable<any[]>;
+    private minLength;
+    private maxLength20;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagsComponent, "mv-tags", never, { "tagItems": { "alias": "tagItems"; "required": false; }; "userId": { "alias": "userId"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "annoId": { "alias": "annoId"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * A moment timezone pipe to support parsing based on time zone abbreviations
+ * covers all cases of offset variation due to daylight saving.
+ *
+ * Same API as DatePipe with additional timezone abbreviation support
+ * Official date pipe dropped support for abbreviations names from Angular V5
  */
-/// <amd-module name="@hmcts/media-viewer" />
-export * from './public_api';
-//# sourceMappingURL=hmcts-media-viewer.d.ts.map
+declare class MomentDatePipe extends DatePipe implements PipeTransform {
+    transform(value: string | Date, format?: string, timezone?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MomentDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MomentDatePipe, "momentDate", false>;
+}
+
+declare class CommentFilterComponent implements OnInit, OnDestroy {
+    private store;
+    private fb;
+    tagGroup: UntypedFormGroup;
+    $subscriptions: Subscription;
+    filter$: Observable<string[]>;
+    allTags$: Observable<any>;
+    searchValue: string;
+    isPreview: boolean;
+    constructor(store: Store<State>, fb: UntypedFormBuilder);
+    ngOnInit(): void;
+    buildFrom(): void;
+    onClearFilters(): void;
+    ngOnDestroy(): void;
+    onRemoveFilter(tagName: any): void;
+    onToggleFilterView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentFilterComponent, "mv-comment-filter", never, {}, {}, never, never, false, never>;
+}
+
+declare class FilterPipe implements PipeTransform {
+    transform(items: any[], searchText: string, fieldName: string): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "filter", false>;
+}
+
+declare class UnsnakePipe implements PipeTransform {
+    transform(items: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsnakePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UnsnakePipe, "unsnake", false>;
+}
+
+declare class GovUkDateComponent {
+    config: {
+        id: string;
+        legend: string;
+    };
+    errorMessage: {
+        isInvalid: boolean;
+        messages: string[];
+    };
+    formGroup: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GovUkDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GovUkDateComponent, "mv-gov-uk-date", never, { "config": { "alias": "config"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GovUkErrorMessageComponent {
+    constructor();
+    config: {
+        id: string;
+    };
+    errorMessage: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GovUkErrorMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GovUkErrorMessageComponent, " mv-gov-uk-error-message", never, { "config": { "alias": "config"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GovUkFieldsetComponent {
+    config: {
+        legend: string;
+        classes: string;
+        id: string;
+        hint: string;
+        key: string;
+    };
+    isHeading: boolean;
+    errorMessage: string[];
+    setDescribedBy(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GovUkFieldsetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GovUkFieldsetComponent, "mv-gov-uk-fieldset", never, { "config": { "alias": "config"; "required": false; }; "isHeading": { "alias": "isHeading"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class GovUkLabelComponent {
+    constructor();
+    config: {
+        label: string;
+        name: string;
+        id: string;
+        isPageHeading: any;
+        classes: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<GovUkLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GovUkLabelComponent, "mv-gov-label", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SharedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedModule, [typeof GovUkDateComponent, typeof GovUkErrorMessageComponent, typeof GovUkFieldsetComponent, typeof GovUkLabelComponent], [typeof i5.CommonModule, typeof i22.FormsModule, typeof i22.ReactiveFormsModule, typeof i5.CommonModule, typeof i11.RouterModule], [typeof GovUkDateComponent, typeof GovUkErrorMessageComponent, typeof GovUkFieldsetComponent, typeof GovUkLabelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedModule>;
+}
+
+declare class AnnotationsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnotationsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnnotationsModule, [typeof MetadataLayerComponent, typeof AnnotationViewComponent, typeof BoxHighlightCreateComponent, typeof AnnotationSetComponent, typeof RectangleComponent, typeof CommentComponent, typeof CommentSetHeaderComponent, typeof CommentSearchComponent, typeof TextHighlightDirective, typeof CtxToolbarComponent, typeof CommentSetComponent, typeof CommentsNavigateComponent, typeof TextareaAutoExpandDirective, typeof CommentsSummaryComponent, typeof TagsComponent, typeof MomentDatePipe, typeof CommentFilterComponent, typeof FilterPipe, typeof UnsnakePipe], [typeof i20.A11yModule, typeof i5.CommonModule, typeof i22.FormsModule, typeof i23.HttpClientModule, typeof i24.MutableDivModule, typeof i25.TagInputModule, typeof i11.RouterModule, typeof i22.ReactiveFormsModule, typeof i27.NgxDatatableModule, typeof SharedModule, typeof i29.RpxTranslationModule], [typeof AnnotationViewComponent, typeof BoxHighlightCreateComponent, typeof AnnotationSetComponent, typeof CommentSetComponent, typeof CommentSetHeaderComponent, typeof CommentSearchComponent, typeof CommentsSummaryComponent, typeof TagsComponent, typeof CommentFilterComponent, typeof MomentDatePipe, typeof FilterPipe, typeof UnsnakePipe, typeof MetadataLayerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnnotationsModule>;
+}
+
+declare class MediaViewerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaViewerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MediaViewerModule, [typeof PdfViewerComponent, typeof SideBarComponent, typeof BookmarksComponent, typeof OutlineItemComponent, typeof ImageViewerComponent, typeof UnsupportedViewerComponent, typeof MultimediaPlayerComponent, typeof MediaViewerComponent, typeof ConvertibleContentViewerComponent, typeof GrabNDragDirective, typeof RotationPersistDirective, typeof HighlightCreateDirective, typeof ConfirmActionDialogComponent, typeof RedactionComponent, typeof BookmarkIconsComponent, typeof ParticipantsListComponent], [typeof i5.CommonModule, typeof i23.HttpClientModule, typeof ToolbarModule, typeof AnnotationsModule, typeof i25.TagInputModule, typeof i22.FormsModule, typeof i22.ReactiveFormsModule, typeof i11.RouterModule, typeof _ngrx_store.StoreFeatureModule, typeof _ngrx_effects.EffectsFeatureModule, typeof i24.MutableDivModule, typeof i27$1.CdkTreeModule, typeof i28.DragDropModule, typeof i29.RpxTranslationModule], [typeof MediaViewerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MediaViewerModule>;
+}
+
+declare const getAnnotationsSetState: _ngrx_store.MemoizedSelector<object, AnnotationSetState, (s1: State) => AnnotationSetState>;
+declare const getAnnotationEntities: _ngrx_store.MemoizedSelector<object, {
+    [id: string]: any;
+}, (s1: AnnotationSetState) => {
+    [id: string]: any;
+}>;
+declare const getSet: _ngrx_store.MemoizedSelector<object, any, (s1: AnnotationSetState) => any>;
+declare const getDocumentIdSetId: _ngrx_store.MemoizedSelector<object, {
+    documentId: any;
+    annotationSetId: any;
+}, (s1: any) => {
+    documentId: any;
+    annotationSetId: any;
+}>;
+declare const getAnnotationSet: _ngrx_store.MemoizedSelector<object, any, (s1: {
+    [id: string]: any;
+}, s2: any) => any>;
+declare const getSelectedAnnotation: _ngrx_store.MemoizedSelector<object, SelectionAnnotation, (s1: AnnotationSetState) => SelectionAnnotation>;
+declare const getCommentEntities: _ngrx_store.MemoizedSelector<object, {
+    [id: string]: Comment;
+}, (s1: AnnotationSetState) => {
+    [id: string]: Comment;
+}>;
+declare const getPageEntities: _ngrx_store.MemoizedSelector<object, {
+    [id: string]: Annotation[];
+}, (s1: AnnotationSetState) => {
+    [id: string]: Annotation[];
+}>;
+declare const getComponentSearchQueries: _ngrx_store.MemoizedSelector<object, {
+    commentSearch: string;
+}, (s1: AnnotationSetState) => {
+    commentSearch: string;
+}>;
+declare const getComponentSearchText: _ngrx_store.MemoizedSelector<object, string, (s1: {
+    commentSearch: string;
+}) => string>;
+declare const getCommentSummaryFilters: _ngrx_store.MemoizedSelector<object, {
+    hasFilter: boolean;
+    filters: Filters;
+}, (s1: AnnotationSetState) => {
+    hasFilter: boolean;
+    filters: Filters;
+}>;
+declare const getAnnoPerPage: _ngrx_store.MemoizedSelector<object, any[], (s1: {
+    [id: string]: DocumentPages;
+}, s2: {
+    [id: string]: Annotation[];
+}, s3: {
+    [id: string]: Annotation[];
+}) => any[]>;
+declare const getCommentsArray: _ngrx_store.MemoizedSelector<object, {
+    page: any;
+    pages: {
+        [id: string]: DocumentPages;
+    };
+    annotationId: string;
+    content: string;
+    tags: TagsModel[];
+    pageHeight: number;
+    selected: boolean;
+    editable: boolean;
+    id: string;
+    createdBy: string;
+    createdByDetails: User;
+    createdDate: string;
+    lastModifiedBy: string;
+    lastModifiedByDetails: User;
+    lastModifiedDate: string;
+}[], (s1: {
+    [id: string]: Comment;
+}, s2: {
+    [id: string]: DocumentPages;
+}, s3: {
+    [id: string]: any;
+}, s4: {
+    [id: string]: string[];
+}) => {
+    page: any;
+    pages: {
+        [id: string]: DocumentPages;
+    };
+    annotationId: string;
+    content: string;
+    tags: TagsModel[];
+    pageHeight: number;
+    selected: boolean;
+    editable: boolean;
+    id: string;
+    createdBy: string;
+    createdByDetails: User;
+    createdDate: string;
+    lastModifiedBy: string;
+    lastModifiedByDetails: User;
+    lastModifiedDate: string;
+}[]>;
+declare const getCommentSummary: _ngrx_store.MemoizedSelector<object, string[] | {
+    page: number;
+    user: string;
+    date: string;
+    tags: TagsModel[];
+    comment: string;
+}[], (s1: {
+    page: any;
+    pages: {
+        [id: string]: DocumentPages;
+    };
+    annotationId: string;
+    content: string;
+    tags: TagsModel[];
+    pageHeight: number;
+    selected: boolean;
+    editable: boolean;
+    id: string;
+    createdBy: string;
+    createdByDetails: User;
+    createdDate: string;
+    lastModifiedBy: string;
+    lastModifiedByDetails: User;
+    lastModifiedDate: string;
+}[], s2: {
+    hasFilter: boolean;
+    filters: Filters;
+}) => string[] | {
+    page: number;
+    user: string;
+    date: string;
+    tags: TagsModel[];
+    comment: string;
+}[]>;
+declare const getFilteredAnnotations: _ngrx_store.MemoizedSelector<object, any[], (s1: {
+    [id: string]: any;
+}, s2: {
+    [id: string]: string[];
+}) => any[]>;
+
+declare class AnnotationEffects {
+    private actions$;
+    private annotationApiService;
+    constructor(actions$: Actions, annotationApiService: AnnotationApiService);
+    loadAnnotation$: rxjs.Observable<LoadAnnotationSetSucess | LoadAnnotationSetFail> & _ngrx_effects.CreateEffectMetadata;
+    postAnnotation$: rxjs.Observable<LoadAnnotationSetFail | SaveAnnotationSuccess> & _ngrx_effects.CreateEffectMetadata;
+    deleteAnnotation$: rxjs.Observable<DeleteAnnotationSuccess | DeleteAnnotationFail> & _ngrx_effects.CreateEffectMetadata;
+    saveAnnotationSet$: rxjs.Observable<SaveAnnotationSetSuccess | SaveAnnotationSetFail> & _ngrx_effects.CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnotationEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnnotationEffects>;
+}
+
+export { ADD_OR_EDIT_COMMENT, APPLY_COMMENT_SUMMARY_FILTER, AddOrEditComment, AnnotationApiService, AnnotationEffects, AnnotationSetComponent, AnnotationViewComponent, AnnotationsModule, ApplyCommentSymmaryFilter, BoxHighlightCreateComponent, CLEAR_COMMENT_SUMMARY_FILTER, ClearCommentSummaryFilters, CommentFilterComponent, CommentSearchComponent, CommentSetComponent, CommentSetHeaderComponent, CommentsSummaryComponent, DELETE_ANNOTATION, DELETE_ANNOTATION_FAIL, DELETE_ANNOTATION_SUCCESS, DeleteAnnotation, DeleteAnnotationFail, DeleteAnnotationSuccess, FilterPipe, HighlightToolbarComponent, IcpToolbarComponent, LOAD_ANNOTATION_SET, LOAD_ANNOTATION_SET_FAIL, LOAD_ANNOTATION_SET_SUCCESS, LoadAnnotationSet, LoadAnnotationSetFail, LoadAnnotationSetSucess, MainToolbarComponent, MediaViewerComponent, MediaViewerModule, MetadataLayerComponent, MomentDatePipe, RedactionSearchBarComponent, RedactionToolbarComponent, ResponseType, SAVE_ANNOTATION, SAVE_ANNOTATION_FAIL, SAVE_ANNOTATION_SET, SAVE_ANNOTATION_SET_FAIL, SAVE_ANNOTATION_SET_SUCCESS, SAVE_ANNOTATION_SUCCESS, SEARCH_COMMENT, SELECT_ANNOTATION, SaveAnnotation, SaveAnnotationFail, SaveAnnotationSet, SaveAnnotationSetFail, SaveAnnotationSetSuccess, SaveAnnotationSuccess, SearchBarComponent, SearchComment, SelectedAnnotation, TagsComponent, ToolbarButtonVisibilityService, ToolbarModule, UnsnakePipe, ViewerException, commentSearchQ, getAnnoEnt, getAnnoPageEnt, getAnnoPerPage, getAnnoSet, getAnnotationEntities, getAnnotationSet, getAnnotationsSetState, getCommentEntities, getCommentEnts, getCommentSummary, getCommentSummaryFilters, getCommentsArray, getComponentSearchQueries, getComponentSearchText, getDocumentIdSetId, getFilteredAnnotations, getPageEntities, getSelectedAnno, getSelectedAnnotation, getSet, getSummaryFilters, initialState, reducer };
+export type { AnnotationSetState, AnnotationsActions, ExceptionDetail };
+//# sourceMappingURL=index.d.ts.map