@hmcts/media-viewer 4.2.42-CME-776-dart-angular-20 → 4.2.42

package/index.d.ts

@@ -1,28 +1,45 @@
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, AfterContentInit, OnChanges, EventEmitter, ElementRef, SimpleChanges, AfterViewChecked, AfterViewInit, QueryList, AfterContentChecked, PipeTransform } from '@angular/core';
+import { ElementRef, OnDestroy, OnInit, AfterContentInit, OnChanges, EventEmitter, SimpleChanges, QueryList, AfterViewChecked, ChangeDetectorRef, AfterViewInit, AfterContentChecked, PipeTransform } from '@angular/core';
 import * as rxjs from 'rxjs';
 import { BehaviorSubject, Subject, Observable, Subscription } from 'rxjs';
+import * as _ngrx_store from '@ngrx/store';
+import { Action, Store } from '@ngrx/store';
+import { PDFViewer, DownloadManager } from 'pdfjs-dist/web/pdf_viewer.mjs';
 import { ArrayDataSource, SelectionModel } from '@angular/cdk/collections';
 import * as i28 from '@angular/cdk/tree';
 import { FlatTreeControl } from '@angular/cdk/tree';
 import * as i29$1 from '@angular/cdk/drag-drop';
 import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i25 from '@angular/common/http';
+import { HttpClient } from '@angular/common/http';
 import * as i6 from '@angular/common';
 import { DatePipe } from '@angular/common';
-import * as i25 from '@angular/common/http';
 import * as i10 from '@angular/cdk/overlay';
 import { ConnectionPositionPair } from '@angular/cdk/overlay';
 import * as i7 from '@angular/forms';
-import { FormGroup, UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { FormGroup, FormBuilder, UntypedFormControl, UntypedFormGroup, UntypedFormBuilder } from '@angular/forms';
 import * as i8 from '@angular/router';
 import * as i12 from 'rpx-xui-translation';
 import * as i22 from '@angular/cdk/a11y';
 import * as i26 from 'mutable-div';
 import * as i27 from 'ngx-chips';
 import * as i29 from '@swimlane/ngx-datatable';
-import * as _ngrx_store from '@ngrx/store';
-import { Action } from '@ngrx/store';
 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;
@@ -48,41 +65,6 @@ interface Rectangle extends ApiPersisted {
     y: number;
 }
 
-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[];
-}
-
 interface RedactionSearch {
     page?: number;
     matchedIndex?: number;
@@ -94,6 +76,25 @@ interface RedactRectangle {
     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;
@@ -117,6 +118,7 @@ interface SearchMode {
 }
 declare class ToolbarEventService {
     private icpEventService;
+    constructor(icpEventService: IcpEventService);
     readonly highlightModeSubject: BehaviorSubject<boolean>;
     readonly highlightToolbarSubject: BehaviorSubject<boolean>;
     readonly drawModeSubject: BehaviorSubject<boolean>;
@@ -183,6 +185,159 @@ declare class ToolbarEventService {
     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",
@@ -223,99 +378,525 @@ declare class ToolbarButtonVisibilityService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ToolbarButtonVisibilityService>;
 }
 
-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 SelectionAnnotation {
+    annotationId: string;
+    editable: boolean;
+    selected: boolean;
 }
 
-declare class HighlightCreateDirective implements OnInit, OnDestroy {
-    private element;
-    private toolbarEvents;
-    private viewerEvents;
-    private highlightService;
-    private store;
-    pageHeight: number;
-    pageWidth: number;
-    zoom: number;
-    rotate: number;
-    allPages: object;
-    private $subscriptions;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    private focusWithoutScrolling;
-    onMouseUp(mouseEvent: MouseEvent): void;
-    onKeyboardSelectionConfirmed(): void;
-    private getCurrentPageFromSelection;
-    private getRectanglesFromSelection;
-    onPdfViewerClick(event: MouseEvent): void;
-    private getRectangles;
-    private getSelectionRectangles;
-    private createTextRectangle;
-    private removeEnhancedTextModeStyling;
-    private setPageProperties;
-    private processClientRects;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightCreateDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<HighlightCreateDirective, "[mvCreateTextHighlight]", never, {}, {}, never, never, false, never>;
+interface Filters {
+    tagFilters?: {
+        [key: string]: any;
+    };
+    dateRangeFrom?: number | null;
+    dateRangeTo?: number | null;
 }
 
-declare class PdfViewerComponent implements AfterContentInit, OnChanges, OnDestroy {
-    private store;
-    private icpStore;
-    private readonly pdfJsWrapperFactory;
-    private readonly printService;
-    readonly toolbarEvents: ToolbarEventService;
-    private readonly viewerEvents;
-    private icpService;
-    readonly toolbarButtons: ToolbarButtonVisibilityService;
-    private readonly icpEventService;
-    mediaLoadStatus: EventEmitter<ResponseType>;
-    pdfViewerException: EventEmitter<ViewerException>;
-    documentTitle: EventEmitter<string>;
-    downloadUrl: string;
-    url: string;
-    downloadFileName: string;
-    enableAnnotations: boolean;
-    enableRedactions: boolean;
-    enableICP: boolean;
-    annotationSet: AnnotationSet | null;
-    enableRedactSearch: AnnotationSet | null;
-    height: string;
-    pageHeights: any[];
-    rotation: number;
-    zoom: number;
-    caseId: string;
-    highlightMode: Observable<boolean>;
-    drawMode: BehaviorSubject<boolean>;
-    documentOutline: Outline[];
-    loadingDocument: boolean;
-    loadingDocumentProgress: number;
-    errorMessage: string;
-    hasDifferentPageSize: boolean;
-    viewerContainer: ElementRef<HTMLDivElement>;
-    pdfViewer: ElementRef<HTMLDivElement>;
-    highlightCreateDirective: HighlightCreateDirective;
-    private pdfWrapper;
-    private $subscription;
-    private viewerException;
-    showCommentsPanel: boolean;
-    showIcpParticipantsList: boolean;
-    enableGrabNDrag: boolean;
-    showSelectionStartCursor: boolean;
-    selectionStartCursorX: number;
-    selectionStartCursorY: number;
+declare const LOAD_ANNOTATION_SET = "[Annotations] Load Annotation Set";
+declare const LOAD_ANNOTATION_SET_SUCCESS = "[Annotations] Load Annotation Set Success";
+declare const LOAD_ANNOTATION_SET_FAIL = "[Annotations] Load Annotation Set Fail";
+declare const SAVE_ANNOTATION_SET = "[Annotations] Save Annotation Set";
+declare const SAVE_ANNOTATION_SET_SUCCESS = "[Annotations] Save Annotation Set Success";
+declare const SAVE_ANNOTATION_SET_FAIL = "[Annotations] Save Annotation Set Fail";
+declare const SAVE_ANNOTATION = "[Annotations] Save Annotation";
+declare const SAVE_ANNOTATION_SUCCESS = "[Annotations] Save Annotation Success";
+declare const SAVE_ANNOTATION_FAIL = "[Annotations] Save Annotation Fail";
+declare const ADD_OR_EDIT_COMMENT = "[Annotations] Add or Edit Comment";
+declare const DELETE_ANNOTATION = "[Annotations] Delete Annotation";
+declare const DELETE_ANNOTATION_SUCCESS = "[Annotations] Delete Annotation Success";
+declare const DELETE_ANNOTATION_FAIL = "[Annotations] Delete Annotation Fail";
+declare const SELECT_ANNOTATION = "[Annotations] Select Annotation";
+declare const SEARCH_COMMENT = "[Comments] Search Comments";
+declare const APPLY_COMMENT_SUMMARY_FILTER = "[Comments] Apply Comment Summary Filter";
+declare const CLEAR_COMMENT_SUMMARY_FILTER = "[Comments] Clear Comment Summary Filter";
+declare class LoadAnnotationSet implements Action {
+    payload: string;
+    readonly type = "[Annotations] Load Annotation Set";
+    constructor(payload: string);
+}
+declare class SaveAnnotationSet implements Action {
+    payload: AnnotationSet;
+    readonly type = "[Annotations] Save Annotation Set";
+    constructor(payload: AnnotationSet);
+}
+declare class LoadAnnotationSetSucess implements Action {
+    payload: {
+        status: number;
+        body: AnnotationSet;
+    };
+    readonly type = "[Annotations] Load Annotation Set Success";
+    constructor(payload: {
+        status: number;
+        body: AnnotationSet;
+    });
+}
+declare class SaveAnnotationSetSuccess implements Action {
+    payload: AnnotationSet;
+    readonly type = "[Annotations] Save Annotation Set Success";
+    constructor(payload: AnnotationSet);
+}
+declare class LoadAnnotationSetFail implements Action {
+    payload: {
+        status: number;
+        body: any;
+    };
+    readonly type = "[Annotations] Load Annotation Set Fail";
+    constructor(payload: {
+        status: number;
+        body: any;
+    });
+}
+declare class SaveAnnotationSetFail implements Action {
+    payload: {
+        status: number;
+        body: any;
+    };
+    readonly type = "[Annotations] Save Annotation Set Fail";
+    constructor(payload: {
+        status: number;
+        body: any;
+    });
+}
+declare class SaveAnnotation implements Action {
+    payload: Annotation;
+    autoSelect?: boolean;
+    readonly type = "[Annotations] Save Annotation";
+    constructor(payload: Annotation, autoSelect?: boolean);
+}
+declare class SaveAnnotationSuccess implements Action {
+    payload: any;
+    readonly type = "[Annotations] Save Annotation Success";
+    constructor(payload: any);
+}
+declare class SaveAnnotationFail implements Action {
+    payload: Error;
+    readonly type = "[Annotations] Save Annotation Fail";
+    constructor(payload: Error);
+}
+declare class AddOrEditComment implements Action {
+    payload: Comment;
+    readonly type = "[Annotations] Add or Edit Comment";
+    constructor(payload: Comment);
+}
+declare class DeleteAnnotation implements Action {
+    payload: string;
+    readonly type = "[Annotations] Delete Annotation";
+    constructor(payload: string);
+}
+declare class DeleteAnnotationSuccess implements Action {
+    payload: string;
+    readonly type = "[Annotations] Delete Annotation Success";
+    constructor(payload: string);
+}
+declare class DeleteAnnotationFail implements Action {
+    payload: Error;
+    readonly type = "[Annotations] Delete Annotation Fail";
+    constructor(payload: Error);
+}
+declare class SelectedAnnotation implements Action {
+    payload: SelectionAnnotation;
+    readonly type = "[Annotations] Select Annotation";
+    constructor(payload: SelectionAnnotation);
+}
+declare class SearchComment implements Action {
+    payload: string;
+    readonly type = "[Comments] Search Comments";
+    constructor(payload: string);
+}
+declare class ApplyCommentSymmaryFilter implements Action {
+    payload: Filters;
+    readonly type = "[Comments] Apply Comment Summary Filter";
+    constructor(payload: Filters);
+}
+declare class ClearCommentSummaryFilters implements Action {
+    readonly type = "[Comments] Clear Comment Summary Filter";
+}
+type AnnotationsActions = LoadAnnotationSet | LoadAnnotationSetSucess | LoadAnnotationSetFail | SaveAnnotation | SaveAnnotationSuccess | SaveAnnotationFail | SaveAnnotationSetSuccess | AddOrEditComment | DeleteAnnotation | DeleteAnnotationSuccess | DeleteAnnotationFail | SelectedAnnotation | SearchComment | ApplyCommentSymmaryFilter | ClearCommentSummaryFilters;
+
+interface AnnotationSetState {
+    annotationSet: any;
+    annotationEntities: {
+        [id: string]: any;
+    };
+    annotationPageEntities: {
+        [id: string]: Annotation[];
+    };
+    commentEntities: {
+        [id: string]: Comment;
+    };
+    selectedAnnotation: SelectionAnnotation;
+    commentSearchQueries: {
+        commentSearch: string;
+    };
+    commentSummaryFilters: {
+        hasFilter: boolean;
+        filters: Filters;
+    };
+    loaded: boolean;
+    loading: boolean;
+}
+declare const initialState: AnnotationSetState;
+declare function reducer(state: AnnotationSetState, action: AnnotationsActions): AnnotationSetState;
+declare const getAnnoSet: (state: AnnotationSetState) => any;
+declare const getCommentEnts: (state: AnnotationSetState) => {
+    [id: string]: Comment;
+};
+declare const getAnnoPageEnt: (state: AnnotationSetState) => {
+    [id: string]: Annotation[];
+};
+declare const getAnnoEnt: (state: AnnotationSetState) => {
+    [id: string]: any;
+};
+declare const getSelectedAnno: (state: AnnotationSetState) => SelectionAnnotation;
+declare const commentSearchQ: (state: AnnotationSetState) => {
+    commentSearch: string;
+};
+declare const getSummaryFilters: (state: AnnotationSetState) => {
+    hasFilter: boolean;
+    filters: Filters;
+};
+
+interface TagsState {
+    tagNameEnt: {
+        [id: string]: string[];
+    };
+    filteredComments: {
+        [id: string]: string[];
+    };
+    filteredPageEntities: {
+        [id: string]: Annotation[];
+    };
+    annotations: Annotation[];
+    formFilterState: {
+        [id: string]: boolean;
+    };
+    filters: string[];
+}
+
+interface Bookmark$1 {
+    id: string;
+    documentId: string;
+    name: string;
+    pageNumber: number;
+    xCoordinate: number;
+    yCoordinate: number;
+    children: any[];
+    previous: string;
+    index: number;
+}
+interface BookmarksPerPage {
+    bookmark: {
+        [id: string]: Bookmark$1;
+    };
+    styles: {
+        left: number;
+        height: number;
+        width: number;
+    };
+}
+
+interface BookmarksState {
+    bookmarks: Bookmark$1[];
+    bookmarkEntities: {
+        [id: string]: Bookmark$1;
+    };
+    bookmarkPageEntities: {
+        [id: string]: any;
+    };
+    editableBookmark: string;
+    loaded: boolean;
+    loading: boolean;
+    scrollTop?: number;
+}
+
+interface Redaction {
+    redactionId?: string;
+    documentId?: string;
+    page?: number;
+    rectangles?: Rectangle[];
+}
+
+interface RedactionState {
+    redactionEntities: {
+        [id: string]: Redaction;
+    };
+    redactionPageEntities: {
+        [id: string]: any;
+    };
+    selectedRedaction: SelectionAnnotation | {};
+    redactedDocumentInfo: {
+        blob: Blob;
+        filename: string;
+    };
+    documentId: string;
+}
+
+interface IcpState {
+    session: IcpSession;
+    presenter: IcpParticipant;
+    client: IcpParticipant;
+    participants: IcpParticipant[];
+}
+interface IcpSession {
+    sessionId: string;
+    documentId: string;
+    caseId: string;
+    dateOfHearing: Date;
+    connectionUrl: string;
+}
+interface IcpParticipant {
+    id: string;
+    username: string;
+}
+interface IcpScreenUpdate {
+    pdfPosition: PdfPosition;
+    document: string;
+}
+
+interface State {
+    document: DocumentState;
+    annotations: AnnotationSetState;
+    tags: TagsState;
+    bookmarks: BookmarksState;
+    redactions: RedactionState;
+    icp: IcpState;
+}
+
+interface Highlight {
+    page: number;
+    rectangles: Rectangle[];
+}
+declare class ViewerEventService {
+    readonly textHighlight: Subject<Highlight>;
+    readonly boxHighlight: Subject<Highlight>;
+    readonly ctxToolbarCleared: Subject<void>;
+    readonly navigationEvent: Subject<any[]>;
+    readonly navigationEventICP: Subject<any[]>;
+    constructor();
+    textSelected(selectionData: Highlight): void;
+    boxSelected(selectionData: Highlight): void;
+    clearCtxToolbar(): void;
+    goToDestination(destination: any[]): void;
+    goToDestinationICP(destination: any[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewerEventService>;
+}
+
+declare enum IcpEvents {
+    SESSION_JOINED = "IcpClientJoinedSession",
+    CLIENT_DISCONNECTED = "IcpClientDisconnectedFromSession",
+    NEW_PARTICIPANT_JOINED = "IcpNewParticipantJoinedSession",
+    REMOVE_PARTICIPANT = "IcpRemoveParticipantFromList",
+    PARTICIPANTS_UPDATED = "IcpParticipantsListUpdated",
+    UPDATE_PRESENTER = "IcpNewPresenterStartsPresenting",
+    PRESENTER_UPDATED = "IcpPresenterUpdated",
+    UPDATE_SCREEN = "IcpUpdateScreen",
+    SCREEN_UPDATED = "IcpScreenUpdated",
+    SESSION_JOIN = "IcpClientJoinSession",
+    SESSION_LEAVE = "IcpClientLeaveSession"
+}
+
+declare class SocketService implements OnDestroy {
+    private socket;
+    subscription: Subscription;
+    connected$: BehaviorSubject<boolean>;
+    sessionJoined$: Subject<void>;
+    presenterUpdated$: Subject<void>;
+    clientDisconnected$: Subject<void>;
+    participantUpdated$: Subject<void>;
+    newParticipantJoined$: Subject<void>;
+    screenUpdated$: Subject<void>;
+    constructor();
+    ngOnDestroy(): void;
+    connect(url: string, session: IcpSession): void;
+    connected(): Observable<boolean>;
+    join(session: any): void;
+    leave(session: any): void;
+    emit(event: string, data: any): void;
+    listen(event: IcpEvents): Observable<any>;
+    messageEventHandller(eventName: string, data: any): void;
+    getSocketClient(url: string): Observable<WebSocket>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SocketService>;
+}
+
+declare class IcpUpdateService {
+    private socket;
+    session: IcpSession;
+    constructor(socket: SocketService);
+    private joinSessionSubscription;
+    joinSession(username: string, session: IcpSession, token: string): rxjs.Observable<any>;
+    leaveSession(): void;
+    newParticipantJoined(): rxjs.Observable<any>;
+    clientDisconnected(): rxjs.Observable<any>;
+    removeParticipant(participantId: any): void;
+    participantListUpdated(): rxjs.Observable<any>;
+    updatePresenter(presenter: IcpParticipant): void;
+    presenterUpdated(): rxjs.Observable<any>;
+    updateScreen(screen: IcpScreenUpdate): void;
+    screenUpdated(): rxjs.Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IcpUpdateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IcpUpdateService>;
+}
+
+declare class IcpPresenterService {
+    private readonly toolbarEvents;
+    private readonly socketService;
+    private store;
+    session: IcpSession;
+    presenter: IcpParticipant;
+    pdfPosition: PdfPosition;
+    $subscription: Subscription;
+    constructor(toolbarEvents: ToolbarEventService, socketService: IcpUpdateService, store: Store<IcpState>);
+    update(isPresenter: boolean): void;
+    subscribe(): void;
+    unsubscribe(): void;
+    onPositionUpdate(pdfPosition: PdfPosition): void;
+    onNewParticipantJoined(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IcpPresenterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IcpPresenterService>;
+}
+
+declare class IcpFollowerService {
+    private readonly toolbarEvents;
+    private readonly viewerEvents;
+    private readonly socketService;
+    private store;
+    session: IcpSession;
+    private previousRotation;
+    $subscription: Subscription;
+    constructor(toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, socketService: IcpUpdateService, store: Store<IcpState>);
+    update(isFollower: boolean): void;
+    subscribe(): void;
+    unsubscribe(): void;
+    followScreenUpdate({ pdfPosition }: {
+        pdfPosition: any;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IcpFollowerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IcpFollowerService>;
+}
+
+declare class IcpService implements OnDestroy {
+    private readonly toolbarEvents;
+    private readonly viewerEvents;
+    private readonly socketService;
+    private readonly presenterSubscriptions;
+    private readonly followerSubscriptions;
+    private store;
+    private readonly icpEventService;
+    caseId: string;
+    client: IcpParticipant;
+    presenter: IcpParticipant;
+    isPresenter: boolean;
+    documentId: string;
+    subscription: Subscription;
+    sessionSubscription: Subscription;
+    constructor(toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, socketService: IcpUpdateService, presenterSubscriptions: IcpPresenterService, followerSubscriptions: IcpFollowerService, store: Store<IcpState>, icpEventService: IcpEventService);
+    ngOnDestroy(): void;
+    launchSession(): void;
+    setUpSessionSubscriptions(): void;
+    unsubscribeSession(): void;
+    leavePresentation(): void;
+    stopPresenting(): void;
+    becomePresenter(): void;
+    clientDisconnected(client: any): void;
+    removeParticipant(participantId: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IcpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IcpService>;
+}
+
+declare class HighlightCreateService {
+    private toolBarEvents;
+    private store;
+    constructor(toolBarEvents: ToolbarEventService, store: Store<AnnotationSetState>);
+    saveAnnotation(rectangles: Rectangle[], page: number, annotationId?: string): void;
+    saveAnnotationSet(searchRectangles: RedactRectangle[]): void;
+    applyRotation(pageHeight: any, pageWidth: any, offsetHeight: any, offsetWidth: any, offsetTop: any, offsetLeft: any, rotate: any, zoom: any): any;
+    resetHighlight(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightCreateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HighlightCreateService>;
+}
+
+declare class HighlightCreateDirective implements OnInit, OnDestroy {
+    private element;
+    private toolbarEvents;
+    private viewerEvents;
+    private highlightService;
+    private store;
+    pageHeight: number;
+    pageWidth: number;
+    zoom: number;
+    rotate: number;
+    allPages: object;
+    private $subscriptions;
+    constructor(element: ElementRef<HTMLElement>, toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService, highlightService: HighlightCreateService, store: Store<AnnotationSetState>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private focusWithoutScrolling;
+    onMouseUp(mouseEvent: MouseEvent): void;
+    onKeyboardSelectionConfirmed(): void;
+    private getCurrentPageFromSelection;
+    private getRectanglesFromSelection;
+    onPdfViewerClick(event: MouseEvent): void;
+    private getRectangles;
+    private getSelectionRectangles;
+    private createTextRectangle;
+    private removeEnhancedTextModeStyling;
+    private setPageProperties;
+    private processClientRects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightCreateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HighlightCreateDirective, "[mvCreateTextHighlight]", never, {}, {}, never, never, false, never>;
+}
+
+declare class PdfViewerComponent implements AfterContentInit, OnChanges, OnDestroy {
+    private store;
+    private icpStore;
+    private readonly pdfJsWrapperFactory;
+    private readonly printService;
+    readonly toolbarEvents: ToolbarEventService;
+    private readonly viewerEvents;
+    private icpService;
+    readonly toolbarButtons: ToolbarButtonVisibilityService;
+    private readonly icpEventService;
+    mediaLoadStatus: EventEmitter<ResponseType>;
+    pdfViewerException: EventEmitter<ViewerException>;
+    documentTitle: EventEmitter<string>;
+    downloadUrl: string;
+    url: string;
+    downloadFileName: string;
+    enableAnnotations: boolean;
+    enableRedactions: boolean;
+    enableICP: boolean;
+    annotationSet: AnnotationSet | null;
+    enableRedactSearch: AnnotationSet | null;
+    height: string;
+    pageHeights: any[];
+    rotation: number;
+    zoom: number;
+    caseId: string;
+    highlightMode: Observable<boolean>;
+    drawMode: BehaviorSubject<boolean>;
+    documentOutline: Outline[];
+    loadingDocument: boolean;
+    loadingDocumentProgress: number;
+    errorMessage: string;
+    hasDifferentPageSize: boolean;
+    viewerContainer: ElementRef<HTMLDivElement>;
+    pdfViewer: ElementRef<HTMLDivElement>;
+    highlightCreateDirective: HighlightCreateDirective;
+    private pdfWrapper;
+    private $subscription;
+    private viewerException;
+    showCommentsPanel: boolean;
+    showIcpParticipantsList: boolean;
+    enableGrabNDrag: boolean;
+    showSelectionStartCursor: boolean;
+    selectionStartCursorX: number;
+    selectionStartCursorY: number;
     showSelectionEndCursor: boolean;
     selectionEndCursorX: number;
     selectionEndCursorY: number;
-    constructor();
+    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;
@@ -353,7 +934,7 @@ declare class PdfViewerComponent implements AfterContentInit, OnChanges, OnDestr
     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$1 {
+interface Bookmark {
     id: string;
     documentId: string;
     name: string;
@@ -363,7 +944,7 @@ interface Bookmark$1 {
     zoom: number;
     parent: string;
     previous: string;
-    children: Bookmark$1[];
+    children: Bookmark[];
     index: number;
 }
 interface BookmarkNode {
@@ -372,58 +953,21 @@ interface BookmarkNode {
     children: string[];
 }
 
-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 BookmarksComponent implements OnInit, OnDestroy, OnChanges {
     private store;
-    set bookmarkNodes(value: Bookmark$1[]);
-    get bookmarkNodes(): Bookmark$1[];
+    set bookmarkNodes(value: Bookmark[]);
+    get bookmarkNodes(): Bookmark[];
     zoom: number;
     rotate: number;
     parentScrollTop: number;
     goToDestination: EventEmitter<any[]>;
     treeHasChanged: EventEmitter<boolean>;
     private _bookmarkNodes;
-    datasource: ArrayDataSource<Bookmark$1>;
-    treeControl: FlatTreeControl<Bookmark$1>;
-    hoveredNode: Bookmark$1;
+    datasource: ArrayDataSource<Bookmark>;
+    treeControl: FlatTreeControl<Bookmark>;
+    hoveredNode: Bookmark;
     hoverHtmlElement: HTMLElement;
-    expansionModel: SelectionModel<Bookmark$1>;
+    expansionModel: SelectionModel<Bookmark>;
     isDraggingOn: boolean;
     isUserdragging: boolean;
     expandTimeout: any;
@@ -447,14 +991,15 @@ declare class BookmarksComponent implements OnInit, OnDestroy, OnChanges {
     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$1): void;
-    updateBookmark(bookmark: Bookmark$1, name: any): void;
-    goToBookmark(bookmark: Bookmark$1): 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;
@@ -462,19 +1007,19 @@ declare class BookmarksComponent implements OnInit, OnDestroy, OnChanges {
     private positionSortBookmarks;
     private customSortBookmarks;
     private scaledY;
-    hasChild: (_: number, node: Bookmark$1) => boolean;
+    hasChild: (_: number, node: Bookmark) => boolean;
     getNode(bookmarks: any, parentId: any): any;
-    drop(event: CdkDragDrop<Bookmark$1>): void;
+    drop(event: CdkDragDrop<Bookmark>): void;
     private getSiblingFromAllSibliings;
     dragStart(): void;
     dragEnd(): void;
-    dragHover(event: any, node: Bookmark$1): void;
-    dragHoverEnd(event: any, node: Bookmark$1): void;
-    onNodeExpand(node: Bookmark$1): "toggle-children-wrapper-expanded" | "toggle-children-wrapper-collapsed";
-    visibleNodes(bookmarks: Bookmark$1[]): Bookmark$1[];
+    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$1[], toNode: Bookmark$1): boolean;
+    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>;
 }
@@ -497,6 +1042,7 @@ declare class SideBarComponent implements OnInit, OnChanges, OnDestroy {
     sidebarOpen: any;
     private subscriptions;
     sidebarDiv: any;
+    constructor(viewerEvents: ViewerEventService, store: Store<BookmarksState>, toolbarEvents: ToolbarEventService);
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngOnDestroy(): void;
@@ -527,6 +1073,14 @@ declare class OutlineItemComponent implements OnInit {
     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;
@@ -554,6 +1108,7 @@ declare class ImageViewerComponent implements OnInit, OnDestroy, OnChanges {
     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;
@@ -582,50 +1137,198 @@ declare class UnsupportedViewerComponent implements OnInit, OnDestroy {
     unsupportedViewerException: EventEmitter<ViewerException>;
     downloadLink: ElementRef;
     private subscriptions;
-    private viewerException;
-    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;
+    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;
-    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>;
+    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 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>;
+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 {
@@ -670,7 +1373,7 @@ declare class MediaViewerComponent implements OnChanges, OnDestroy, AfterContent
     private $subscriptions;
     private prevOffset;
     private currentRegionIndex;
-    constructor();
+    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;
@@ -709,6 +1412,7 @@ declare class ConvertibleContentViewerComponent implements OnInit, OnDestroy, On
     documentTitle: EventEmitter<string>;
     private $subscription;
     convertedUrl: string;
+    constructor(store: Store<DocumentState>);
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngOnDestroy(): void;
@@ -729,6 +1433,7 @@ declare class GrabNDragDirective {
     private pointerDown;
     dragEnabled: boolean;
     dragX: Element;
+    constructor(el: ElementRef);
     onPointerDown(event: PointerEvent): void;
     onPointerMove(event: PointerEvent): void;
     onWindowPointerUp(): void;
@@ -745,6 +1450,7 @@ declare class RotationPersistDirective implements OnInit, OnDestroy {
     rotation: number;
     savedRotation: number;
     $subscriptions: Subscription;
+    constructor(el: ElementRef, store: Store<DocumentState>, toolbarButtons: ToolbarButtonVisibilityService, toolbarEvents: ToolbarEventService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     onMediaLoad(status: ResponseType): void;
@@ -792,7 +1498,7 @@ declare class KeyboardTextHighlightDirective implements OnDestroy {
     private lastValidEndNode;
     private lastValidEndOffset;
     private static lastInteractionWasKeyboard;
-    constructor();
+    constructor(elementRef: ElementRef<HTMLElement>);
     private static onGlobalKeyDown;
     private static onGlobalMouseDown;
     ngOnDestroy(): void;
@@ -818,6 +1524,7 @@ declare class KeyboardTextHighlightDirective implements OnDestroy {
 declare class ConfirmActionDialogComponent implements AfterViewInit {
     private icpEventService;
     modalContainer: ElementRef;
+    constructor(icpEventService: IcpEventService);
     ngAfterViewInit(): void;
     onCancel(): void;
     onConfirm(): void;
@@ -825,19 +1532,6 @@ declare class ConfirmActionDialogComponent implements AfterViewInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmActionDialogComponent, "mv-confirm-action", never, {}, {}, never, never, false, never>;
 }
 
-interface SelectionAnnotation {
-    annotationId: string;
-    editable: boolean;
-    selected: boolean;
-}
-
-interface Redaction {
-    redactionId?: string;
-    documentId?: string;
-    page?: number;
-    rectangles?: Rectangle[];
-}
-
 declare class RedactionComponent implements OnInit, OnDestroy {
     private store;
     private readonly viewerEvents;
@@ -850,6 +1544,7 @@ declare class RedactionComponent implements OnInit, OnDestroy {
     drawMode: boolean;
     documentId: string;
     private $subscription;
+    constructor(store: Store<State>, viewerEvents: ViewerEventService, toolbarEvents: ToolbarEventService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     markTextRedaction(highlight: any): void;
@@ -869,58 +1564,19 @@ declare class RedactionComponent implements OnInit, OnDestroy {
     static ɵcmp: i0.ɵɵComponentDeclaration<RedactionComponent, "mv-redactions", never, { "zoom": { "alias": "zoom"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; }, {}, never, never, false, never>;
 }
 
-interface Bookmark {
-    id: string;
-    documentId: string;
-    name: string;
-    pageNumber: number;
-    xCoordinate: number;
-    yCoordinate: number;
-    children: any[];
-    previous: string;
-    index: number;
-}
-interface BookmarksPerPage {
-    bookmark: {
-        [id: string]: Bookmark;
-    };
-    styles: {
-        left: number;
-        height: number;
-        width: number;
-    };
-}
-
 declare class BookmarkIconsComponent implements OnInit {
     private store;
     zoom: number;
     rotate: number;
     bookmarksPerPage$: Observable<BookmarksPerPage[]>;
-    bookmarks: Bookmark[];
+    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>;
 }
 
-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;
-}
-
 declare class ParticipantsListComponent implements OnInit, OnDestroy {
     private readonly toolbarEvents;
     private store;
@@ -930,6 +1586,7 @@ declare class ParticipantsListComponent implements OnInit, OnDestroy {
     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>;
@@ -949,6 +1606,7 @@ declare class SearchBarComponent implements OnInit, OnDestroy, AfterViewInit {
     resultCount: number;
     private subscriptions;
     advancedSearchVisible: boolean;
+    constructor(toolbarButtons: ToolbarButtonVisibilityService, toolbarEvents: ToolbarEventService);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
@@ -965,6 +1623,23 @@ declare class SearchBarComponent implements OnInit, OnDestroy, AfterViewInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<SearchBarComponent, "mv-search-bar", never, {}, {}, never, never, false, never>;
 }
 
+/**
+ * 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 ToolbarFocusService {
+    focusToolbarButton(toolbarSelector: string, buttonId?: string, delay?: number): void;
+    private focusWithoutScrolling;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFocusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToolbarFocusService>;
+}
+
 declare class MainToolbarComponent implements OnInit, OnDestroy, AfterViewInit {
     readonly toolbarEvents: ToolbarEventService;
     readonly toolbarButtons: ToolbarButtonVisibilityService;
@@ -998,6 +1673,7 @@ declare class MainToolbarComponent implements OnInit, OnDestroy, AfterViewInit {
     widthRequiredForBtn: {
         [id: string]: number;
     };
+    constructor(toolbarEvents: ToolbarEventService, toolbarButtons: ToolbarButtonVisibilityService, cdr: ChangeDetectorRef, numberHelper: NumberHelperService, icpEventService: IcpEventService, toolbarFocusService: ToolbarFocusService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     ngAfterViewInit(): void;
@@ -1048,6 +1724,7 @@ declare class RedactionToolbarComponent implements OnInit, OnDestroy {
     hasRedactions: boolean;
     private subscriptions;
     redactionAllInProgress: boolean;
+    constructor(toolbarEventService: ToolbarEventService, toolbarButtons: ToolbarButtonVisibilityService, store: Store<AnnotationSetState>, toolbarFocusService: ToolbarFocusService);
     ngOnInit(): void;
     onRedactAllSearch(): void;
     toggleTextRedactionMode(): void;
@@ -1072,6 +1749,7 @@ declare class IcpToolbarComponent implements OnInit, OnDestroy {
     presenterName: string;
     isPresenter: boolean;
     private $subscription;
+    constructor(toolbarEventService: ToolbarEventService, store: Store<IcpState>, icpEventService: IcpEventService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     present(): void;
@@ -1082,17 +1760,6 @@ declare class IcpToolbarComponent implements OnInit, OnDestroy {
     static ɵcmp: i0.ɵɵComponentDeclaration<IcpToolbarComponent, "mv-icp-toolbar", never, {}, {}, never, never, false, never>;
 }
 
-declare class HighlightCreateService {
-    private toolBarEvents;
-    private store;
-    saveAnnotation(rectangles: Rectangle[], page: number, annotationId?: string): void;
-    saveAnnotationSet(searchRectangles: RedactRectangle[]): void;
-    applyRotation(pageHeight: any, pageWidth: any, offsetHeight: any, offsetWidth: any, offsetTop: any, offsetLeft: any, rotate: any, zoom: any): any;
-    resetHighlight(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightCreateService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<HighlightCreateService>;
-}
-
 declare class RedactionSearchBarComponent implements OnInit, OnDestroy {
     private store;
     readonly toolbarButtons: ToolbarButtonVisibilityService;
@@ -1121,6 +1788,7 @@ declare class RedactionSearchBarComponent implements OnInit, OnDestroy {
     private subscription;
     private documentId;
     advancedSearchVisible: boolean;
+    constructor(store: Store<State>, toolbarButtons: ToolbarButtonVisibilityService, toolbarEvents: ToolbarEventService, highlightService: HighlightCreateService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     onWindowKeyDown(e: KeyboardEvent): void;
@@ -1150,6 +1818,7 @@ declare class HighlightToolbarComponent implements OnInit, OnDestroy {
     private readonly toolbarFocusService;
     private subscriptions;
     redactionAllInProgress: boolean;
+    constructor(toolbarEventService: ToolbarEventService, toolbarButtons: ToolbarButtonVisibilityService, toolbarFocusService: ToolbarFocusService);
     ngOnInit(): void;
     onAllSearch(): void;
     onHighlight(): void;
@@ -1166,6 +1835,7 @@ declare class HighlightToolbarComponent implements OnInit, OnDestroy {
 
 declare class TooltipDismissDirective {
     private el;
+    constructor(el: ElementRef);
     onEscapeDismissTooltip(): void;
     onShowTooltip(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDismissDirective, never>;
@@ -1234,6 +1904,7 @@ declare class KeyboardNavDirective implements OnInit, OnDestroy {
     private currentFocusIndex;
     private mutationObserver;
     private isUsingArrowKeys;
+    constructor(elementRef: ElementRef<HTMLElement>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     private setupMutationObserver;
@@ -1263,11 +1934,6 @@ declare class ToolbarModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<ToolbarModule>;
 }
 
-interface Highlight {
-    page: number;
-    rectangles: Rectangle[];
-}
-
 declare class CtxToolbarComponent implements OnChanges {
     readonly defaultHeight: any;
     readonly defaultWidth: any;
@@ -1320,6 +1986,7 @@ declare class MetadataLayerComponent implements OnInit, OnDestroy {
     highlightPage: number;
     rectangles: Rectangle[];
     private $subscriptions;
+    constructor(store: Store<AnnotationSetState>, highlightService: HighlightCreateService, toolbarEvents: ToolbarEventService, viewerEvents: ViewerEventService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     showContextToolbar(highlight: Highlight): void;
@@ -1359,7 +2026,7 @@ declare class AnnotationViewComponent implements OnDestroy {
     ctxToolbar: ElementRef<HTMLElement>;
     private lastFocusedRectangle;
     private nextTabTarget;
-    constructor();
+    constructor(toolbarEvents: ToolbarEventService, store: Store<AnnotationSetState>);
     ngOnDestroy(): void;
     private setShowToolbar;
     onSelect(): void;
@@ -1409,7 +2076,7 @@ declare class KeyboardBoxDrawDirective implements OnDestroy {
     private currentWidth;
     private currentHeight;
     private static lastInteractionWasKeyboard;
-    constructor();
+    constructor(elementRef: ElementRef<HTMLElement>);
     private static onGlobalKeyDown;
     private static onGlobalMouseDown;
     ngOnDestroy(): void;
@@ -1471,6 +2138,7 @@ declare class BoxHighlightCreateComponent implements OnInit, OnDestroy {
     cursorY: number;
     showCursor: boolean;
     private subscriptions;
+    constructor(toolbarEvents: ToolbarEventService, highlightService: HighlightCreateService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     private isElementInViewport;
@@ -1500,6 +2168,7 @@ declare class AnnotationSetComponent implements OnInit {
     pageHeight: number;
     pageWidth: number;
     selectedAnnotation$: Observable<SelectionAnnotation>;
+    constructor(store: Store<AnnotationSetState>, commentService: CommentService);
     ngOnInit(): void;
     onAnnotationUpdate(annotation: Annotation): void;
     onAnnotationDelete(annotation: Annotation): void;
@@ -1523,7 +2192,7 @@ declare class KeyboardBoxMoveDirective implements OnDestroy {
     private moveSubject;
     private moveSubscription;
     private isMoving;
-    constructor();
+    constructor(elementRef: ElementRef<HTMLElement>);
     ngOnDestroy(): void;
     onKeyDown(event: KeyboardEvent): void;
     private moveBox;
@@ -1560,6 +2229,7 @@ declare class RectangleComponent implements OnChanges, AfterViewInit, OnDestroy
     _annoRect: Rectangle;
     set annoRect(annoRect: Rectangle);
     get annoRect(): Rectangle;
+    constructor(toolbarEvents: ToolbarEventService, highlightService: HighlightCreateService);
     ngOnChanges(changes: SimpleChanges): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
@@ -1578,62 +2248,6 @@ declare class RectangleComponent implements OnChanges, AfterViewInit, OnDestroy
     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; }; "rectangleTabIndex": { "alias": "rectangleTabIndex"; "required": false; }; "annoRect": { "alias": "annoRect"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "selectEvent": "selectEvent"; "updateEvent": "updateEvent"; "deleteEvent": "deleteEvent"; "keyboardMovingChange": "keyboardMovingChange"; "tabToToolbar": "tabToToolbar"; }, never, never, false, never>;
 }
 
-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;
-    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 CommentSetHeaderComponent implements OnInit, OnDestroy {
     private store;
     private commentService;
@@ -1651,6 +2265,7 @@ declare class CommentSetHeaderComponent implements OnInit, OnDestroy {
     isFiltered: boolean;
     navigationList: Annotation[];
     $subscriptions: Subscription;
+    constructor(store: Store<State>, commentService: CommentService, toolbarEvents: ToolbarEventService, icpEventService: IcpEventService);
     ngOnInit(): void;
     toggleCommentsSummary(): void;
     selectTab(tab: string): void;
@@ -1667,6 +2282,7 @@ declare class CommentSearchComponent implements AfterViewInit, OnDestroy {
     searchString: string;
     searchResults: Annotation[];
     searchIndex: number;
+    constructor(store: Store<AnnotationSetState>);
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     searchComments(searchText: string): void;
@@ -1674,58 +2290,17 @@ declare class CommentSearchComponent implements AfterViewInit, OnDestroy {
     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;
-    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 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();
-    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 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 CommentsNavigateComponent implements OnChanges {
@@ -1735,6 +2310,7 @@ declare class CommentsNavigateComponent implements OnChanges {
     autoSelect: boolean;
     navigationList: any[];
     index: number;
+    constructor(store: Store<AnnotationSetState>, toolbarEvents: ToolbarEventService);
     ngOnChanges(changes: SimpleChanges): void;
     initNavigationList(): void;
     sortComments(mappedCommentA: any, mappedCommentB: any): number;
@@ -1750,6 +2326,7 @@ declare class CommentsNavigateComponent implements OnChanges {
 
 declare class TextareaAutoExpandDirective implements AfterContentChecked {
     private el;
+    constructor(el: ElementRef);
     ngAfterContentChecked(): void;
     onMouseDown(): void;
     adjustHeight(): void;
@@ -1777,6 +2354,7 @@ declare class CommentsSummaryComponent implements OnInit, OnDestroy {
     hasFilter: boolean;
     fromFilterValid: boolean;
     toFilterValid: boolean;
+    constructor(store: Store<AnnotationSetState>, printService: PrintService, toolbarEvents: ToolbarEventService, fb: FormBuilder);
     ngOnInit(): void;
     buildCheckBoxForm(): void;
     onClearFilters(): void;
@@ -1804,6 +2382,7 @@ declare class TagsComponent {
     errorMessages: {
         [id: string]: string;
     };
+    constructor(tagsServices: TagsServices);
     onUpdateTags(value: any): void;
     requestAutocompleteItems: (text: string) => Observable<any[]>;
     private minLength;
@@ -1834,6 +2413,7 @@ declare class CommentFilterComponent implements OnInit, OnDestroy {
     allTags$: Observable<any>;
     searchValue: string;
     isPreview: boolean;
+    constructor(store: Store<State>, fb: UntypedFormBuilder);
     ngOnInit(): void;
     buildFrom(): void;
     onClearFilters(): void;
@@ -1868,254 +2448,6 @@ declare class MediaViewerModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<MediaViewerModule>;
 }
 
-declare class AnnotationApiService {
-    private readonly httpClient;
-    annotationApiUrl: string;
-    private annotationSetBaseUrl;
-    private annotationBaseUrl;
-    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>;
-}
-
-interface Filters {
-    tagFilters?: {
-        [key: string]: any;
-    };
-    dateRangeFrom?: number | null;
-    dateRangeTo?: number | null;
-}
-
-declare const LOAD_ANNOTATION_SET = "[Annotations] Load Annotation Set";
-declare const LOAD_ANNOTATION_SET_SUCCESS = "[Annotations] Load Annotation Set Success";
-declare const LOAD_ANNOTATION_SET_FAIL = "[Annotations] Load Annotation Set Fail";
-declare const SAVE_ANNOTATION_SET = "[Annotations] Save Annotation Set";
-declare const SAVE_ANNOTATION_SET_SUCCESS = "[Annotations] Save Annotation Set Success";
-declare const SAVE_ANNOTATION_SET_FAIL = "[Annotations] Save Annotation Set Fail";
-declare const SAVE_ANNOTATION = "[Annotations] Save Annotation";
-declare const SAVE_ANNOTATION_SUCCESS = "[Annotations] Save Annotation Success";
-declare const SAVE_ANNOTATION_FAIL = "[Annotations] Save Annotation Fail";
-declare const ADD_OR_EDIT_COMMENT = "[Annotations] Add or Edit Comment";
-declare const DELETE_ANNOTATION = "[Annotations] Delete Annotation";
-declare const DELETE_ANNOTATION_SUCCESS = "[Annotations] Delete Annotation Success";
-declare const DELETE_ANNOTATION_FAIL = "[Annotations] Delete Annotation Fail";
-declare const SELECT_ANNOTATION = "[Annotations] Select Annotation";
-declare const SEARCH_COMMENT = "[Comments] Search Comments";
-declare const APPLY_COMMENT_SUMMARY_FILTER = "[Comments] Apply Comment Summary Filter";
-declare const CLEAR_COMMENT_SUMMARY_FILTER = "[Comments] Clear Comment Summary Filter";
-declare class LoadAnnotationSet implements Action {
-    payload: string;
-    readonly type = "[Annotations] Load Annotation Set";
-    constructor(payload: string);
-}
-declare class SaveAnnotationSet implements Action {
-    payload: AnnotationSet;
-    readonly type = "[Annotations] Save Annotation Set";
-    constructor(payload: AnnotationSet);
-}
-declare class LoadAnnotationSetSucess implements Action {
-    payload: {
-        status: number;
-        body: AnnotationSet;
-    };
-    readonly type = "[Annotations] Load Annotation Set Success";
-    constructor(payload: {
-        status: number;
-        body: AnnotationSet;
-    });
-}
-declare class SaveAnnotationSetSuccess implements Action {
-    payload: AnnotationSet;
-    readonly type = "[Annotations] Save Annotation Set Success";
-    constructor(payload: AnnotationSet);
-}
-declare class LoadAnnotationSetFail implements Action {
-    payload: {
-        status: number;
-        body: any;
-    };
-    readonly type = "[Annotations] Load Annotation Set Fail";
-    constructor(payload: {
-        status: number;
-        body: any;
-    });
-}
-declare class SaveAnnotationSetFail implements Action {
-    payload: {
-        status: number;
-        body: any;
-    };
-    readonly type = "[Annotations] Save Annotation Set Fail";
-    constructor(payload: {
-        status: number;
-        body: any;
-    });
-}
-declare class SaveAnnotation implements Action {
-    payload: Annotation;
-    autoSelect?: boolean;
-    readonly type = "[Annotations] Save Annotation";
-    constructor(payload: Annotation, autoSelect?: boolean);
-}
-declare class SaveAnnotationSuccess implements Action {
-    payload: any;
-    readonly type = "[Annotations] Save Annotation Success";
-    constructor(payload: any);
-}
-declare class SaveAnnotationFail implements Action {
-    payload: Error;
-    readonly type = "[Annotations] Save Annotation Fail";
-    constructor(payload: Error);
-}
-declare class AddOrEditComment implements Action {
-    payload: Comment;
-    readonly type = "[Annotations] Add or Edit Comment";
-    constructor(payload: Comment);
-}
-declare class DeleteAnnotation implements Action {
-    payload: string;
-    readonly type = "[Annotations] Delete Annotation";
-    constructor(payload: string);
-}
-declare class DeleteAnnotationSuccess implements Action {
-    payload: string;
-    readonly type = "[Annotations] Delete Annotation Success";
-    constructor(payload: string);
-}
-declare class DeleteAnnotationFail implements Action {
-    payload: Error;
-    readonly type = "[Annotations] Delete Annotation Fail";
-    constructor(payload: Error);
-}
-declare class SelectedAnnotation implements Action {
-    payload: SelectionAnnotation;
-    readonly type = "[Annotations] Select Annotation";
-    constructor(payload: SelectionAnnotation);
-}
-declare class SearchComment implements Action {
-    payload: string;
-    readonly type = "[Comments] Search Comments";
-    constructor(payload: string);
-}
-declare class ApplyCommentSymmaryFilter implements Action {
-    payload: Filters;
-    readonly type = "[Comments] Apply Comment Summary Filter";
-    constructor(payload: Filters);
-}
-declare class ClearCommentSummaryFilters implements Action {
-    readonly type = "[Comments] Clear Comment Summary Filter";
-}
-type AnnotationsActions = LoadAnnotationSet | LoadAnnotationSetSucess | LoadAnnotationSetFail | SaveAnnotation | SaveAnnotationSuccess | SaveAnnotationFail | SaveAnnotationSetSuccess | AddOrEditComment | DeleteAnnotation | DeleteAnnotationSuccess | DeleteAnnotationFail | SelectedAnnotation | SearchComment | ApplyCommentSymmaryFilter | ClearCommentSummaryFilters;
-
-interface AnnotationSetState {
-    annotationSet: any;
-    annotationEntities: {
-        [id: string]: any;
-    };
-    annotationPageEntities: {
-        [id: string]: Annotation[];
-    };
-    commentEntities: {
-        [id: string]: Comment;
-    };
-    selectedAnnotation: SelectionAnnotation;
-    commentSearchQueries: {
-        commentSearch: string;
-    };
-    commentSummaryFilters: {
-        hasFilter: boolean;
-        filters: Filters;
-    };
-    loaded: boolean;
-    loading: boolean;
-}
-declare const initialState: AnnotationSetState;
-declare function reducer(state: AnnotationSetState, action: AnnotationsActions): AnnotationSetState;
-declare const getAnnoSet: (state: AnnotationSetState) => any;
-declare const getCommentEnts: (state: AnnotationSetState) => {
-    [id: string]: Comment;
-};
-declare const getAnnoPageEnt: (state: AnnotationSetState) => {
-    [id: string]: Annotation[];
-};
-declare const getAnnoEnt: (state: AnnotationSetState) => {
-    [id: string]: any;
-};
-declare const getSelectedAnno: (state: AnnotationSetState) => SelectionAnnotation;
-declare const commentSearchQ: (state: AnnotationSetState) => {
-    commentSearch: string;
-};
-declare const getSummaryFilters: (state: AnnotationSetState) => {
-    hasFilter: boolean;
-    filters: Filters;
-};
-
-interface TagsState {
-    tagNameEnt: {
-        [id: string]: string[];
-    };
-    filteredComments: {
-        [id: string]: string[];
-    };
-    filteredPageEntities: {
-        [id: string]: Annotation[];
-    };
-    annotations: Annotation[];
-    formFilterState: {
-        [id: string]: boolean;
-    };
-    filters: string[];
-}
-
-interface BookmarksState {
-    bookmarks: Bookmark[];
-    bookmarkEntities: {
-        [id: string]: Bookmark;
-    };
-    bookmarkPageEntities: {
-        [id: string]: any;
-    };
-    editableBookmark: string;
-    loaded: boolean;
-    loading: boolean;
-    scrollTop?: number;
-}
-
-interface RedactionState {
-    redactionEntities: {
-        [id: string]: Redaction;
-    };
-    redactionPageEntities: {
-        [id: string]: any;
-    };
-    selectedRedaction: SelectionAnnotation | {};
-    redactedDocumentInfo: {
-        blob: Blob;
-        filename: string;
-    };
-    documentId: string;
-}
-
-interface State {
-    document: DocumentState;
-    annotations: AnnotationSetState;
-    tags: TagsState;
-    bookmarks: BookmarksState;
-    redactions: RedactionState;
-    icp: IcpState;
-}
-
 declare const getAnnotationsSetState: _ngrx_store.MemoizedSelector<object, AnnotationSetState, (s1: State) => AnnotationSetState>;
 declare const getAnnotationEntities: _ngrx_store.MemoizedSelector<object, {
     [id: string]: any;
@@ -2254,6 +2586,7 @@ declare const getFilteredAnnotations: _ngrx_store.MemoizedSelector<object, any[]
 declare class AnnotationEffects {
     private actions$;
     private annotationApiService;
+    constructor(actions$: Actions, annotationApiService: AnnotationApiService);
     loadAnnotation$: rxjs.Observable<LoadAnnotationSetSucess | LoadAnnotationSetFail> & _ngrx_effects.CreateEffectMetadata;
     postAnnotation$: rxjs.Observable<SaveAnnotationSuccess | SaveAnnotationFail> & _ngrx_effects.CreateEffectMetadata;
     deleteAnnotation$: rxjs.Observable<DeleteAnnotationSuccess | DeleteAnnotationFail> & _ngrx_effects.CreateEffectMetadata;