import * as i0 from '@angular/core';
import { OnInit, OnDestroy, EventEmitter, ViewContainerRef, AfterViewInit, ComponentRef, Type, ComponentFactoryResolver, ChangeDetectorRef, EnvironmentInjector, ApplicationRef, Injector, OnChanges, ElementRef, Renderer2, SimpleChanges, PipeTransform, DoCheck, ModuleWithProviders } from '@angular/core';
import * as rxjs from 'rxjs';
import { Subject, BehaviorSubject, Observable, Subscription } from 'rxjs';
import { HttpClient } from '@angular/common/http';
import { AuthorizerService } from '@vcomply/authorizer';
import * as i2 from '@angular/common';
import { DatePipe, PlatformLocation } from '@angular/common';
import { Router } from '@angular/router';
import * as i3 from '@vcomply/editor';
import * as i6 from '@angular/forms';
import { ControlValueAccessor } from '@angular/forms';
import * as i14 from '@angular/material/datepicker';
import * as i15 from 'ngx-material-timepicker';
import { DomSanitizer, SafeHtml, SafeResourceUrl } from '@angular/platform-browser';
import * as i10 from '@angular/material/core';

declare class Configurations {
    envConfig: any;
    constructor();
}

declare class ApiService {
    private http;
    private authorizer;
    environment: any;
    token: string;
    constructor(http: HttpClient, authorizer: AuthorizerService, config?: Configurations);
    get(uri: string, params?: any): rxjs.Observable<ArrayBuffer>;
    post(uri: string, payload: Object): rxjs.Observable<Object>;
    put(uri: string, payload: Object): rxjs.Observable<Object>;
    patch(uri: string, payload: Object): rxjs.Observable<Object>;
    delete(uri: string): rxjs.Observable<Object>;
    nodeAPI(url: string, payload: any): rxjs.Observable<Object>;
    getWithoutBaseUrl(uri: string, params?: any): rxjs.Observable<ArrayBuffer>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiService>;
}

declare class SnackBarService {
    private snackbarSubject;
    snackbarState: rxjs.Observable<any>;
    constructor();
    show(message: string, type?: 'success' | 'warning' | 'info' | 'alert' | 'error'): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SnackBarService>;
}

declare class CommonService {
    private authorizer;
    private apiService;
    private datePipe;
    private snackBarService;
    private platformLocation;
    refreshLog$: Subject<any>;
    currentLocation: string;
    refreshResponsibility$: Subject<any>;
    notificationQueue: BehaviorSubject<any[]>;
    constructor(authorizer: AuthorizerService, apiService: ApiService, datePipe: DatePipe, snackBarService: SnackBarService, platformLocation: PlatformLocation);
    changeTimeZone(value: any): Date;
    onAddComment(payload: any): void;
    changeDueDateJSON(list: Array<any>, type: 'ASSIGNEE' | 'REVIEWER'): any[];
    private getAssigneeResponse;
    private getReviewerResponse;
    /**
     * The function redirects the user to a compliance action page with specific URL parameters.
     * @param {any} urlDetails - urlDetails is a rest parameter that allows the function to accept an
     * indefinite number of arguments as an array. In this case, it is used to pass two specific values:
     * urlDetails[0] represents the mode, urlDetails[1] represents the reportId.
     */
    goToActionPage(...urlDetails: any): void;
    showErrorSnackbar(): void;
    getNotificationCount(): rxjs.Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommonService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CommonService>;
}

declare class BusinessCycleService {
    changeBusinessCycle$: BehaviorSubject<boolean>;
    getBusinessCycle(): {
        selected_cycle: any;
        start_date: any;
        end_date: any;
        selected_cycle_arr: any;
        time_filter_type: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<BusinessCycleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BusinessCycleService>;
}

declare class CommonApiService {
    private apiService;
    private authorizer;
    private datePipe;
    private commonService;
    private http;
    private businessCycleService;
    environment: any;
    payload: any;
    reviewerLoader: boolean;
    private inFlightRequests;
    private lastLoaded;
    orgDetails$: BehaviorSubject<any>;
    userDetails$: BehaviorSubject<any>;
    subscriptionDetails$: BehaviorSubject<any>;
    responsibilityDetails$: BehaviorSubject<any>;
    dueDateList$: BehaviorSubject<any>;
    mentionedDate$: BehaviorSubject<any>;
    collaboratorList$: BehaviorSubject<any>;
    reviewerDueDateList$: BehaviorSubject<any>;
    assigneeDueDateLoader: boolean;
    reviewerDueDateLoader: boolean;
    isLoading: boolean;
    constructor(apiService: ApiService, authorizer: AuthorizerService, datePipe: DatePipe, commonService: CommonService, http: HttpClient, businessCycleService: BusinessCycleService, config?: Configurations);
    private startRequest;
    private finishRequest;
    getOrgDetails(force?: boolean): void;
    /**
     * This function retrieves responsibility details by sending a request to either the new or old API endpoint
     * based on the useNewApi flag.
     * @param {string} id - The report ID used to retrieve responsibility details.
     */
    getResponsibilityDetails(id: string, force?: boolean): void;
    /**
     * This function retrieves a list of due dates for a compliance report using an API call and updates
     * two observable variables with the response.
     * @param {string} id - The `id` parameter is a string representing the report ID that is used to
     * fetch the due date list for compliance.
     */
    getDueDateList(id: string, force?: boolean): void;
    getCollaboratorList(_id: string, force?: boolean): void;
    getReviewerList(_id: string, force?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommonApiService, [null, null, null, null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CommonApiService>;
}

declare class ResponsibilityQuickviewContainerComponent implements OnInit, OnDestroy {
    private commonApiService;
    private commonService;
    id: string;
    features: any;
    organizationDetails: any;
    close: EventEmitter<any>;
    counter: number;
    private unsubscribe;
    constructor(commonApiService: CommonApiService, commonService: CommonService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    getOrgDetails(): void;
    subscribeDetails(force?: boolean): void;
    refreshQuickView(event: boolean): void;
    refreshContainer(): void;
    onCloseQuickView(event: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsibilityQuickviewContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResponsibilityQuickviewContainerComponent, "responsibility-quickview-container", never, { "id": { "alias": "id"; "required": false; }; "features": { "alias": "features"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class DialogConfig<D = any> {
    data?: D;
    position?: any;
    background?: any;
}

declare class DialogRef {
    private readonly afterDialogClosed;
    private readonly afterEventEmited;
    private readonly afterEventReceived;
    afterClosed: Observable<any>;
    afterEvent: Observable<any>;
    eventReceived: Observable<any>;
    constructor();
    close(result?: any): void;
    emitEvent(result?: any): void;
    sendEvent(result?: any): void;
}

declare class InsertionDirective {
    viewContainerRef: ViewContainerRef;
    constructor(viewContainerRef: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<InsertionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InsertionDirective, "[appInsertion]", never, {}, {}, never, never, false, never>;
}

declare class DialogComponent implements AfterViewInit, OnDestroy, OnInit {
    private componentFactoryResolver;
    private cd;
    private dialogRef;
    config: DialogConfig;
    private router;
    private environmentInjector;
    componentRef: ComponentRef<any>;
    position: any;
    background: any;
    insertionPoint: InsertionDirective;
    animation: boolean;
    private childActionSubscription;
    private readonly onDialogClose;
    onClose: rxjs.Observable<any>;
    childComponentType: Type<any>;
    constructor(componentFactoryResolver: ComponentFactoryResolver, cd: ChangeDetectorRef, dialogRef: DialogRef, config: DialogConfig, router: Router, environmentInjector: EnvironmentInjector);
    ngOnInit(): void;
    routeAction(): void;
    ngAfterViewInit(): void;
    onOverlayClicked(evt: MouseEvent): void;
    onDialogClicked(evt: MouseEvent): void;
    loadChildComponent(componentType: Type<any>): void;
    ngOnDestroy(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "ui-dialog", never, {}, {}, never, never, false, never>;
}

declare class DialogDataService {
    private componentFactoryResolver;
    private appRef;
    private injector;
    dialogComponentRef: ComponentRef<DialogComponent>[];
    constructor(componentFactoryResolver: ComponentFactoryResolver, appRef: ApplicationRef, injector: Injector);
    open(componentType: Type<any>, config: DialogConfig): DialogRef;
    private appendDialogComponentToBody;
    private removeDialogComponentFromBody;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogDataService>;
}

interface TabModal {
    id: 'OVERVIEW' | 'REVIEW' | 'COMPLETION' | 'FILES_FOLDERS';
    name: string;
}

declare class ContainerService {
    TAB_LIST: Array<TabModal>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ContainerService>;
}

declare class QuickViewService {
    private snackBarService;
    private http;
    private apiService;
    environment: any;
    constructor(snackBarService: SnackBarService, http: HttpClient, apiService: ApiService, config?: Configurations);
    shortName(str1: string): string | undefined;
    showErrorSnackbar(): void;
    FileUpload(formData: any): rxjs.Observable<any>;
    private getEventMessage;
    private fileUploadProgress;
    private apiResponse;
    fileRemove(attachmentId: any): rxjs.Observable<any>;
    uploadToNode(payload: any, des: any): rxjs.Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<QuickViewService, [null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<QuickViewService>;
}

declare class SessionStorageService {
    /**
     * Sets metadata in session storage
     * @param metadata - Object containing metadata to store
     */
    setMetadata(metadata: Record<string, any>, key: string): void;
    /**
     * Gets metadata from session storage
     * @returns Parsed metadata object or null if not found
     */
    getMetadata(key: string): Record<string, any> | null;
    /**
     * Removes metadata from session storage
     */
    clearMetadata(key: string): void;
    /**
     * Updates specific fields in the metadata
     * @param updates - aPartial metadata object containing fields to update
     */
    updateMetadata(updates: Partial<Record<string, any>>, key: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStorageService>;
}

declare class WorkflowService {
    private sessionStorage;
    modulePermissions: any;
    featureFlagService: any;
    private refreshSubject;
    isWorkflowOpenedSubject: Subject<boolean>;
    constructor(sessionStorage: SessionStorageService);
    workFlowConfig: any;
    openWorkflow(mode: string, workFlowType: string, openedFrom: string, id?: string, featureFlag?: any, secondaryPortal?: string, permission?: any): rxjs.Observable<boolean>;
    setWFESessionStorage(): void;
    createSessionData(): {
        wfe: {
            workflowType: any;
            mode: any;
            allowedWorkflows: any;
            feature: any;
            id: any;
            reponsibilityData: any;
            openedFrom: any;
            secondaryPortal: any;
        };
    };
    setAuthorization(UserInfo: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WorkflowService>;
}

declare class QuickViewComponent implements OnInit, OnDestroy {
    private dialogOpen;
    commonApi: CommonApiService;
    containerService: ContainerService;
    private authorizer;
    private snackBarService;
    private apiService;
    private quickViewService;
    private platformLocation;
    private workflowService;
    private commonService;
    private businessCycleService;
    ASSETS: any;
    currentTab: string;
    markAsComplete: boolean;
    responsibility: any;
    availableActionList: Array<any>;
    data: any;
    showFormPopUp: boolean;
    isTextEditor: boolean;
    isList: boolean;
    isUpload: boolean;
    id: string;
    organizationDetails: any;
    baseUrl: any;
    workroomUrl: string;
    features: any;
    skeletonLoader: boolean;
    reviewerDueDateList: Array<any>;
    unsubscribe: Subject<any>;
    close: EventEmitter<any>;
    refresh: EventEmitter<boolean>;
    loader: boolean;
    userDetails: any[];
    qvTabs: Array<TabModal>;
    notificationCount: any;
    isLoadingActions: boolean;
    hasLoadedActions: boolean;
    private userInfoLoadedFor;
    private isLoadingUserInfo;
    constructor(dialogOpen: DialogDataService, commonApi: CommonApiService, containerService: ContainerService, authorizer: AuthorizerService, snackBarService: SnackBarService, apiService: ApiService, quickViewService: QuickViewService, platformLocation: PlatformLocation, workflowService: WorkflowService, commonService: CommonService, businessCycleService: BusinessCycleService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    getTabVisibility(): void;
    getUserInfo(): void;
    onRefresh(): void;
    delete(): void;
    openDependentResponsibility(responsibility: any): void;
    transfer(): void;
    openWorkflow(): void;
    pause(): void;
    editDueDate(): void;
    addPastEvent(): void;
    switchTab(tab: string): void;
    onClose(data?: any): void;
    handleKeyboardEvent(event: KeyboardEvent): void;
    getResponsibilityDetails(): void;
    availableActions(): void;
    addNewDueDateAction(): void;
    acceptAction(): void;
    declineAction(): void;
    moreDetailsAction(): void;
    startAction(): void;
    ResumeProgressAction(): void;
    needMoreTimeAction(): void;
    cannotCompleteAction(): void;
    redoAction(): void;
    rejectAction(): void;
    condoneAction(): void;
    insistAction(): void;
    needMoreTimeAcceptAction(): void;
    needMoreTimeDeclineAction(): void;
    cannotComplyAcceptAction(): void;
    cannotComplyDeclineAction(): void;
    acceptNewDueDateAction(): void;
    activateAction(): void;
    deactivateAction(): void;
    editAction(): void;
    notifyAction(): void;
    duplicateAction(): void;
    transferAction(): void;
    handoverAction(): void;
    handoverToAction(): void;
    delegateAction(): void;
    delegatedToAction(): void;
    deleteAction(): void;
    addPastEventAction(): void;
    logAnIssueAction(): void;
    pauseAction(): void;
    editDueDateAction(): void;
    sendReminderAction(): void;
    sendReminderEmail(): void;
    entrustAction(): void;
    redirectToSingleAction(type: 'ACCEPT' | 'DECLINE' | 'REQUEST_DETAILS' | 'DONE' | 'NEED_MORE_TIME' | 'CANNOT_COMPLETE' | 'REDO' | 'REJECT' | 'CONDONE' | 'INSIST' | 'NEED_MORE_TIME_ACCEPT' | 'NEED_MORE_TIME_DECLINE' | 'CANNOT_COMPLY_ACCEPT' | 'CANNOT_COMPLY_DECLINE' | 'CANNOT_COMPLY_NEW_DATE', dueDateId: string): void;
    confirm(type: 'DELETE' | 'ACTIVATE' | 'DEACTIVATE' | 'DUPLICATE' | 'REMOVE_KEY_RESPONSIBILITY' | 'MAKE_KEY_RESPONSIBILITY', dueDateId?: string): void;
    duplicate(): void;
    notifyReport(reportIds: any[]): rxjs.Subscription;
    refreshQueue(): void;
    getNotificationCount(): void;
    activate(): void;
    deactivate(): void;
    makeKeyResponsibility(): void;
    removeKeyResponsibility(): void;
    /**
     * It sets the value of the showFormPopUp variable to true, and sets the values of the other variables
     * to false.
     */
    addNewDueDates(): void;
    onActionMenuClick(action: any, moreAction: any, event?: MouseEvent): void;
    private openActionForm;
    getToday(timestamp: any): number;
    handoverTransfer(message: string, type: 'TRANSFER' | 'HANDOVER' | 'DELEGATE', icon: '&#xe9e5;' | '&#xea7c;' | '&#xea7a;'): void;
    /**
     * It takes a user object, creates a payload object, creates a url string, creates a msg string, and
     * then calls the apiCallPost function with the url, msg, payload, and 'info' as parameters.
     * @param {any} user - any -&gt; this is the user object that is passed from the child component
     */
    onTransfer(user: any): void;
    /**
     * It takes a user object, creates a payload object, makes an API call, and then displays a message.
     * @param {any} user - any -&gt; this is the user object that is selected from the dropdown
     */
    onHandover(user: any): void;
    onDelegate(res: any): void;
    /**
     * It takes a url, a message, a payload, and a message class, and then it calls the apiService.post
     * method, and then it shows a snackbar with the message and message class.
     * @param {string} url - string - the url to call
     * @param {string} msg - string - The message to display in the snackbar
     * @param {any} payload - any = {}
     * @param {'success' | 'info'} [msgClass=success] - 'success' | 'info' = 'success'
     */
    apiCallPost(url: string, msg: string, payload?: any, msgClass?: 'success' | 'info', type?: string): void;
    handoverRevoke(): void;
    revokeDelegation(reportDetail: any): void;
    workflowEngineAction(type: 'EDIT_RESPONSIBILITY' | 'LOG_AN_ISSUE' | 'ENTRUST', reportId: string): void;
    pauseDueDates(): void;
    applyAction(event: any): void;
    /**
     * The function takes in a result object, which has a fromDate and toDate property. The function then
     * makes a post request to the server with the fromDate and toDate properties. If the response is
     * 404, it shows a snackbar with a message. If the response is anything else, it shows a different
     * snackbar with a different message.
     * @param {any} result - any = {
     */
    pauseDueDatesNow(result: any): void;
    editDueDates(): void;
    onEditDueDate(result: any): void;
    openDialogPastEvent(): void;
    /**
     * It takes in a data object, and then makes a post request to the API with the data object.
     *
     * The data object is a form that the user fills out.
     *
     * The form has a date field, a compliance field, a reason field, and an attachment field.
     *
     * The date field is a date picker.
     *
     * The compliance field is a dropdown.
     *
     * The reason field is a textarea.
     *
     * The attachment field is a file upload.
     *
     * The user can fill out the form and submit it.
     *
     * The form is submitted by calling the addPastEventNow function.
     *
     * The addPastEventNow function takes in the data object and makes a post request to the API with the
     * data object.
     *
     * The API then takes the data object and adds it to the database.
     *
     * The user can
     * @param {any} data - any = {
     */
    addPastEventNow(data: any): void;
    /**
     * Add new due date
     * @param {any} event - {
     */
    addNewDueDate(event: any): void;
    goToWorkroom(id: string): void;
    terminateDelegation(event: any): void;
    terminateHandover(event: any): void;
    get keyResponsibilityEnabled(): boolean;
    getReviewerDueDateList(): void;
    fetchActionFlags(): void;
    onMoreActionClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<QuickViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<QuickViewComponent, "quick-view", never, { "id": { "alias": "id"; "required": false; }; "organizationDetails": { "alias": "organizationDetails"; "required": false; }; "features": { "alias": "features"; "required": false; }; }, { "close": "close"; "refresh": "refresh"; }, never, never, false, never>;
}

declare class ActionService {
    private commonService;
    private dialog;
    private apiService;
    private snackBarService;
    constructor(commonService: CommonService, dialog: DialogDataService, apiService: ApiService, snackBarService: SnackBarService);
    /**
     * This function generates a list of possible actions based on certain conditions and returns it.
     * @param {any} reportDetails - It is an object containing details about the report, such as whether
     * editing is enabled or not.
     * @param {any} dueDateDetails - The `dueDateDetails` parameter is an object containing details about
     * a due date, such as whether certain actions are enabled or not.
     * @returns an array of objects, where each object represents an action that can be taken on a report.
     * Each object has a `name` property that describes the action and a `callback` property that is a
     * function to be executed when the action is taken.
     */
    loadActionButtons(reportDetails: any, dueDateDetails: any): any[];
    /**
     * This function opens a dialog box to confirm the deletion of a log and then sends a delete request to
     * the server.
     * @param {string} _id - The _id parameter is a string that represents the ID of a report that is being
     * deleted.
     * @param {string} dueDateId - The `dueDateId` parameter is an identifier for a specific due date that
     * is associated with a compliance report. It is used in the URL to specify which due date should be
     * deleted when the `delete` method is called.
     */
    openDelete(_id: string, dueDateId: string): void;
    canNotComplyAcceptNewDate(): void;
    canNotComplyDecline(): void;
    openSingleActionPage(_id: string, dueDate_Id: string, mode: string, type?: 'reviewduedateId' | 'duedateId'): void;
    markAsFailed(_id: string): void;
    addAReviewDate(_id: string): void;
    onRenitiateReview(_id: string): void;
    loadReviewerAction(reportDetails: any, dueDateDetails: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActionService>;
}

declare class OverviewComponent implements OnChanges, OnDestroy {
    private commonApiService;
    private apiService;
    private authorizer;
    private commonService;
    private snackbarService;
    private actionService;
    ASSETS: any;
    unsubscribe: Subject<any>;
    logDetails: any;
    reportDetails: any;
    type: 'ASSIGNEE' | 'REVIEW';
    dueDate: number;
    actionArray: Array<any>;
    dueDateId: string;
    environment: any;
    disabledAddRecords: boolean;
    actionList: Array<any>;
    loader: boolean;
    isNoData: boolean;
    dueDateDetails: any;
    id: number;
    actionLoader: boolean;
    constructor(commonApiService: CommonApiService, apiService: ApiService, authorizer: AuthorizerService, commonService: CommonService, snackbarService: SnackBarService, actionService: ActionService, config?: Configurations);
    ngOnChanges(): void;
    ngOnDestroy(): void;
    getResponsibilityDetails(): void;
    getLogDetails(dueDateId: string): void;
    getEditorInfo(event: any): void;
    uploadFile(event: any, details: any): void;
    onAddComment(payload: any): void;
    refreshLog(): void;
    addNewRecord(): void;
    getDueDateList(): void;
    getReviewerDueDateList(): void;
    handoverAcceptDecline(type: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverviewComponent, [null, null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OverviewComponent, "overview", never, { "type": { "alias": "type"; "required": false; }; "dueDate": { "alias": "dueDate"; "required": false; }; "dueDateId": { "alias": "dueDateId"; "required": false; }; "actionArray": { "alias": "actionArray"; "required": false; }; "loader": { "alias": "loader"; "required": false; }; "isNoData": { "alias": "isNoData"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class FilesService {
    private http;
    private authorizer;
    private apiService;
    private commonService;
    fileToBeUploaded: Array<any>;
    uploadedFile: Array<any>;
    uploadingFileList$: Subject<Array<any>>;
    constructor(http: HttpClient, authorizer: AuthorizerService, apiService: ApiService, commonService: CommonService);
    /**
     * The function downloads a file from a given URL and opens it in a new window.
     * @param {string} url - A string representing the URL of the file to be downloaded.
     * @param {string} filename - The name of the file that will be downloaded.
     */
    onDownloadFile(url: string, filename: string): void;
    /**
     * This function return  a file url to download file.
     * @param {string} url - A string representing the URL from which the file needs to be downloaded.
     * @param {string} filename - The name of the file to be downloaded.
     * @returns an Observable.
     */
    private getFileOnDownload;
    getFilesData(filesData: Array<any>, reportDetails: any, dueDateId: any): void;
    /**
     *
     * @param filesInfo[0] => selected files
     * @param filesInfo[1]  => Report details
     * @param filesInfo[2] => due date id
     */
    FileUpload(...filesInfo: Array<any>): void;
    extractCommentMention(html_content: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FilesService>;
}

declare class CompletionHistoryComponent implements OnDestroy {
    private dialog;
    private dialogOpen;
    commonApiService: CommonApiService;
    private commonService;
    private apiService;
    private fileService;
    private authorizer;
    private actionService;
    ASSETS: any;
    hideSubTable: boolean;
    hideFirstComment: boolean;
    hideFirstReply: boolean;
    hideSecondComment: boolean;
    hideSecondReply: boolean;
    dueDateList: Array<any>;
    reportDetails: any;
    openedDueDate: Array<number>;
    environment: any;
    description: any;
    firstReplyDescription: any;
    secondReplyDescription: any;
    isFilterApplied: boolean;
    TYPES_OF_FILTER: string[];
    appliedFilter: Array<number>;
    showFilter: boolean;
    enableHistory: 'ASSIGNEE' | 'REVIEWER';
    reviewerStatus: any;
    actionList: Array<any>;
    unsubscribe: Subject<any>;
    currentSortStatus: number;
    loader: boolean;
    isAnyData: boolean;
    constructor(dialog: DialogRef, dialogOpen: DialogDataService, commonApiService: CommonApiService, commonService: CommonService, apiService: ApiService, fileService: FilesService, authorizer: AuthorizerService, actionService: ActionService, config?: Configurations);
    ngOnDestroy(): void;
    refreshLog(index?: number): void;
    showSubTable(dueDate: any, index: number): void;
    feedback(): void;
    showFirstComment(): void;
    showFirstReply(): void;
    showSecondComment(): void;
    showSecondReply(): void;
    getAssigneeDueDateList(index: number): void;
    getReviewerDueDateList(index: any): void;
    viewChange(event: any): void;
    getReportDetails(): void;
    getLogDetails(index: number): void;
    downloadFiles(file: any): void;
    getEditorInfo(event: any, index: number): void;
    uploadFile(event: any, details: any, index: number): void;
    onAddComment(payload: any, index: number): void;
    onUpdateLog(index: number): void;
    selectedFilter(event: any, index: number): void;
    onApplyFilter(): void;
    filterCheck(res: any): any[];
    onClearFilter(): void;
    removeFilter(index: number): void;
    getAssessmentDetails(index: number): void;
    onDueDateSorting(): void;
    refreshPage(): void;
    refreshAPI(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CompletionHistoryComponent, [null, null, null, null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CompletionHistoryComponent, "completion-history", never, {}, {}, never, never, false, never>;
}

declare class FilesFoldersComponent implements OnInit {
    private dialog;
    private dialogOpen;
    private apiService;
    private authorizer;
    private quickViewService;
    private fileService;
    private snackBarService;
    private commonService;
    private commonApiService;
    ASSETS: any;
    fileList: any[];
    folderList: any[];
    breadCrumbArray: any[];
    breadCrumbNameArray: any[];
    folderArray: any[];
    timeLineFolderArray: any[];
    selectedFile: any[];
    inEditElement: any;
    organizationDetails: any;
    responsibility: any;
    id: any;
    timelineEnabled: boolean;
    createNewFolder: boolean;
    editElement: boolean;
    folderId: number;
    environment: any;
    folderToBeEdited: any;
    timelineLoader: boolean;
    loader: boolean;
    progressBar: boolean;
    timelineCreateCondition: boolean;
    timelineData: any[];
    userDetails: any;
    isManagePermission: any;
    dueDates: any[];
    private uploadIdCounter;
    constructor(dialog: DialogRef, dialogOpen: DialogDataService, apiService: ApiService, authorizer: AuthorizerService, quickViewService: QuickViewService, fileService: FilesService, snackBarService: SnackBarService, commonService: CommonService, commonApiService: CommonApiService, config?: Configurations);
    ngOnInit(): void;
    getUserPermissionInfo(): void;
    uploadFiles(): void;
    getResponsibilityFileList(folderId?: any): void;
    getAllFolders(): void;
    updateFolderArray(folderList: any): void;
    get activeArray(): any[];
    clickFolder(folder: any): void;
    getSubFolder(_id?: any): void;
    breadCrumbClick(row: any, index: any): void;
    clickTimeline(clickEvent?: true): void;
    getTimelineData(folder: any): void;
    createFolder(type: any): void;
    saveFolder(value: any): void;
    saveNewFolder(value: any): void;
    updateFolder(value: any): void;
    onFileUpload(files: any, mode: 'BROWSE' | 'DROP'): void;
    getUniqueId(): string;
    uploadAnAttachment(file: any, id: string): void;
    onUploadClick(): void;
    downloadFile(file: any): void;
    deleteFile(file: any): void;
    closeFolder(): void;
    deleteFolder(folder: any): void;
    editFolderName(folder?: any): void;
    removePreview(data: any): void;
    onCancelClick(): void;
    refreshFileAndFolderPage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesFoldersComponent, [null, null, null, null, null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilesFoldersComponent, "files-folders", never, { "responsibility": { "alias": "responsibility"; "required": false; }; "id": { "alias": "id"; "required": false; }; "organizationDetails": { "alias": "organizationDetails"; "required": false; }; "userDetails": { "alias": "userDetails"; "required": false; }; }, {}, never, never, false, never>;
}

declare class OverviewDetailsComponent implements OnDestroy {
    commonApi: CommonApiService;
    fileService: FilesService;
    hideDetails1: boolean;
    hideDetails2: boolean;
    hideSection: boolean;
    responsibility: any;
    overseerArr: Array<any>;
    categoryClass: string[];
    categoryName: string[];
    unsubscribe: Subject<any>;
    riskArray: string[];
    customFieldOpenedArray: any[];
    environment: any;
    status: any;
    statusClass: any;
    constructor(commonApi: CommonApiService, fileService: FilesService, config?: Configurations);
    ngOnDestroy(): void;
    showDetails1(): void;
    showDetails2(): void;
    showSection(): void;
    getResponsibilityDetails(): void;
    getOverseer(reportDetails?: any): void;
    stripHtml(html: any): string;
    showCustomField(index: any): void;
    getResponsibilityStatus(responsibility: any): void;
    getClass(responsibility: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverviewDetailsComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OverviewDetailsComponent, "overview-details", never, {}, {}, never, never, false, never>;
}

declare class QuickviewLoaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<QuickviewLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<QuickviewLoaderComponent, "quickview-loader", never, {}, {}, never, never, false, never>;
}

declare class CompletionLoaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CompletionLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CompletionLoaderComponent, "completion-loader", never, {}, {}, never, never, false, never>;
}

declare class FilesFoldersLoaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesFoldersLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilesFoldersLoaderComponent, "files-folders-loader", never, {}, {}, never, never, false, never>;
}

declare class MarkAsCompleteComponent {
    ASSETS: any;
    constructor();
    reason: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<MarkAsCompleteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MarkAsCompleteComponent, "mark-as-complete", never, {}, {}, never, never, false, never>;
}

declare class DetailsLoaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsLoaderComponent, "details-loader", never, {}, {}, never, never, false, never>;
}

declare class SkeletonLoaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonLoaderComponent, "skeleton-loader", never, {}, {}, never, never, false, never>;
}

declare class OverviewPerformanceComponent implements OnDestroy {
    commonApi: CommonApiService;
    responsibility: any;
    unsubscribe: Subject<any>;
    constructor(commonApi: CommonApiService);
    ngOnDestroy(): void;
    getResponsibilityDetails(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverviewPerformanceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OverviewPerformanceComponent, "overview-performance", never, {}, {}, never, never, false, never>;
}

declare class PopoverService {
    positionX: number;
    positionY: number;
    popoverHeight: any;
    popoverWidth: any;
    elementPosition: any;
    elementDirection: any;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PopoverService>;
}

declare class PopoverComponent {
    popoverService: PopoverService;
    dontCloseonClick: boolean;
    popoverContainer: boolean;
    popoverRatio: ElementRef;
    popoverContent: ElementRef;
    closedOnOverlay: EventEmitter<any>;
    constructor(popoverService: PopoverService);
    showPopover: boolean;
    leftValue: any;
    topValue: any;
    popoverHeight: any;
    popoverWidth: any;
    positionX: number;
    positionY: number;
    popover(): boolean;
    popoverEvent(): boolean;
    closePopover(top?: string): void;
    close(): void;
    clickedPopover(): void;
    getPosition(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "app-popover", never, { "dontCloseonClick": { "alias": "dontCloseonClick"; "required": false; }; }, { "closedOnOverlay": "closedOnOverlay"; }, never, ["*"], false, never>;
}

declare class PopoverDirective {
    private elRef;
    private popoverService;
    dynamicComponent: any;
    refrence: any;
    placement: string;
    leftValue: any;
    topValue: any;
    constructor(elRef: ElementRef, popoverService: PopoverService);
    click(): void;
    getPosition(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverDirective, "[appPopover]", never, { "refrence": { "alias": "refrence"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PopoverModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PopoverModule, [typeof PopoverComponent, typeof PopoverDirective], [typeof i2.CommonModule], [typeof PopoverComponent, typeof PopoverDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PopoverModule>;
}

declare class ToolTipDirective {
    private el;
    private renderer;
    tooltipTitle: string;
    placement: string;
    type: any;
    tooltipMandatory: boolean;
    showTooltip: boolean;
    animate: boolean;
    tooltip: HTMLElement;
    offset: number;
    constructor(el: ElementRef, renderer: Renderer2);
    onMouseEnter(): void;
    onMouseOver(): void;
    onMouseLeave(): void;
    onMouseOut(): void;
    onClick(): void;
    show(): void;
    hide(): void;
    create(): void;
    setPosition(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolTipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolTipDirective, "[appTooltip]", never, { "tooltipTitle": { "alias": "appTooltip"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "type": { "alias": "type"; "required": false; }; "tooltipMandatory": { "alias": "tooltipMandatory"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TooltipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipModule, [typeof ToolTipDirective], [typeof i2.CommonModule], [typeof ToolTipDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TooltipModule>;
}

declare class DialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, [typeof DialogComponent, typeof InsertionDirective], [typeof i2.CommonModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
}

declare class DialogBoxComponent implements OnInit {
    private dialog;
    dialogConfig: DialogConfig;
    animation: boolean;
    icon: string;
    className: string;
    message: string;
    constructor(dialog: DialogRef, dialogConfig: DialogConfig);
    ngOnInit(): void;
    onClick(deleteFlag: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogBoxComponent, "app-dialog", never, {}, {}, never, never, false, never>;
}

declare class TransferHandoverComponent implements OnInit {
    private dialog;
    dialogConfig: DialogConfig;
    animation: boolean;
    constructor(dialog: DialogRef, dialogConfig: DialogConfig);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransferHandoverComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TransferHandoverComponent, "transfer-handover", never, {}, {}, never, never, false, never>;
}

declare class PauseComponent implements OnInit {
    animation: boolean;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PauseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PauseComponent, "pause", never, {}, {}, never, never, false, never>;
}

declare class EditDueDateComponent implements OnInit {
    animation: boolean;
    constructor();
    ngOnInit(): void;
    description: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditDueDateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditDueDateComponent, "edit-due-date", never, {}, {}, never, never, false, never>;
}

declare class AddPastEventComponent implements OnInit {
    animation: boolean;
    constructor();
    ngOnInit(): void;
    description: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddPastEventComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddPastEventComponent, "add-past-event", never, {}, {}, never, never, false, never>;
}

declare class FeedbackStatusComponent implements OnInit {
    private dialog;
    animation: boolean;
    constructor(dialog: DialogRef);
    ngOnInit(): void;
    description: any;
    onClose(value?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FeedbackStatusComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FeedbackStatusComponent, "feedback-status", never, {}, {}, never, never, false, never>;
}

declare class UploadFilesComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFilesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UploadFilesComponent, "upload-files", never, {}, {}, never, never, false, never>;
}

declare class CsCheckboxComponent implements ControlValueAccessor {
    disabled: boolean | any;
    checked: boolean | any;
    onChanged: (value: any) => void;
    onTouched: () => void;
    writeValue(value: boolean): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    valueChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CsCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CsCheckboxComponent, "app-checkbox", never, { "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class CsRadioComponent {
    disabled: boolean;
    readonly: boolean;
    name: string;
    checked: boolean;
    value: any;
    checkedEvent: EventEmitter<any>;
    constructor();
    changeState(evt: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CsRadioComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CsRadioComponent, "app-radio", never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "name": { "alias": "name"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "checkedEvent": "checkedEvent"; }, never, ["*"], false, never>;
}

declare class CsSwitchComponent {
    disabled: boolean;
    ngValue: any;
    value: any;
    ngValueChange: EventEmitter<any>;
    tooltipMessage: any;
    position: any;
    constructor();
    valueChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CsSwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CsSwitchComponent, "app-cs-switch", never, { "disabled": { "alias": "disabled"; "required": false; }; "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; "tooltipMessage": { "alias": "tooltipMessage"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, { "ngValueChange": "ngValueChange"; }, never, never, false, never>;
}

declare class FormgroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormgroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FormgroupModule, [typeof CsCheckboxComponent, typeof CsRadioComponent, typeof CsSwitchComponent], [typeof i2.CommonModule, typeof TooltipModule, typeof i6.FormsModule], [typeof CsCheckboxComponent, typeof CsRadioComponent, typeof CsSwitchComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FormgroupModule>;
}

declare class ActionDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ActionDialogModule, [typeof DialogBoxComponent, typeof TransferHandoverComponent, typeof PauseComponent, typeof EditDueDateComponent, typeof AddPastEventComponent, typeof FeedbackStatusComponent, typeof UploadFilesComponent], [typeof i2.CommonModule, typeof DialogModule, typeof PopoverModule, typeof i3.VcomplyEditorModule, typeof TooltipModule, typeof FormgroupModule, typeof i14.MatDatepickerModule, typeof i15.NgxMaterialTimepickerModule, typeof i6.FormsModule], [typeof DialogBoxComponent, typeof TransferHandoverComponent, typeof PauseComponent, typeof EditDueDateComponent, typeof AddPastEventComponent, typeof FeedbackStatusComponent, typeof UploadFilesComponent, typeof i15.NgxMaterialTimepickerModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ActionDialogModule>;
}

declare class StopPropagationDirective {
    onClick(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StopPropagationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StopPropagationDirective, "[appStopPropagation]", never, {}, {}, never, never, false, never>;
}

declare class ConditionalFocusDirective implements OnChanges {
    private el;
    appConditionalFocus: any;
    constructor(el: ElementRef);
    ngOnChanges(change: SimpleChanges): void;
    ngAfterViewInit(): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionalFocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ConditionalFocusDirective, "[appConditionalFocus]", never, { "appConditionalFocus": { "alias": "appConditionalFocus"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DragAndDropDirectiveQV {
    onFileDropped: EventEmitter<any>;
    onDragOver(evt: any): void;
    onDragLeave(evt: any): void;
    ondrop(evt: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropDirectiveQV, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DragAndDropDirectiveQV, "[appDragDropQV]", never, {}, { "onFileDropped": "onFileDropped"; }, never, never, false, never>;
}

declare class DirectiveModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DirectiveModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DirectiveModule, [typeof StopPropagationDirective, typeof ConditionalFocusDirective, typeof DragAndDropDirectiveQV], [typeof i2.CommonModule], [typeof StopPropagationDirective, typeof ConditionalFocusDirective, typeof DragAndDropDirectiveQV]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DirectiveModule>;
}

declare class NoDataComponent {
    action: object;
    noDataImage: string;
    noDataText: string;
    noDataButton: string | any | boolean;
    noDataSecButton: string | boolean;
    noDataMultipleButtons: Array<string> | any;
    altText: string;
    buttonAction: EventEmitter<object>;
    clickedButton: EventEmitter<object>;
    smallButton: boolean;
    constructor();
    actionEmitter(button: object): void;
    getClickedButton(button: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NoDataComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NoDataComponent, "app-no-data", never, { "action": { "alias": "action"; "required": false; }; "noDataImage": { "alias": "noDataImage"; "required": false; }; "noDataText": { "alias": "noDataText"; "required": false; }; "noDataButton": { "alias": "noDataButton"; "required": false; }; "noDataSecButton": { "alias": "noDataSecButton"; "required": false; }; "noDataMultipleButtons": { "alias": "noDataMultipleButtons"; "required": false; }; "altText": { "alias": "altText"; "required": false; }; "smallButton": { "alias": "smallButton"; "required": false; }; }, { "buttonAction": "buttonAction"; "clickedButton": "clickedButton"; }, never, never, false, never>;
}

declare class NoDataModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NoDataModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NoDataModule, [typeof NoDataComponent], [typeof i2.CommonModule], [typeof NoDataComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NoDataModule>;
}

declare class DueDateLogComponent implements OnChanges, OnDestroy {
    fileService: FilesService;
    private commonService;
    private authorizer;
    private dialog;
    private apiService;
    private snackbarService;
    hideFirstReply: boolean;
    ASSETS: any;
    environment: any;
    logDetails: any;
    dueDateId: string;
    reportDetails: any;
    dueDateDetails: any;
    parentReplyIndex: Array<number>;
    subCommentIndex: Array<number>;
    childCommentIndex: Array<number>;
    subReplyIndex: Array<number>;
    firstReplyDescription: any;
    secondReplyDescription: any;
    multipleUserDetails: any;
    onActionTaken: EventEmitter<any>;
    commentHeadIcon: string;
    private unsubscribe;
    constructor(fileService: FilesService, commonService: CommonService, authorizer: AuthorizerService, dialog: DialogDataService, apiService: ApiService, snackbarService: SnackBarService, config?: Configurations);
    ngOnChanges(): void;
    ngOnDestroy(): void;
    showFirstComment(index: number): void;
    /**
     * The function toggles the display of the first reply in a list of replies.
     * @param {number} index - The index parameter is a number that represents the index of a reply in an
     * array. The function `showFirstReply` uses this index to toggle the visibility of the first reply
     * in a thread of replies. If the index is already in the `parentReplyIndex` array, it removes it,
     * otherwise
     */
    showFirstReply(index: number): void;
    /**
     * The function toggles the display of a child comment based on its index.
     * @param {number} index - The index parameter is a number that represents the index of a comment in
     * an array. This function is used to toggle the display of child comments for a particular parent
     * comment. If the index is already in the childCommentIndex array, it is removed, and if it is not
     * present, it is added
     */
    showSecondComment(index: number): void;
    /**
     * The function toggles the display of a sub-reply based on its index.
     * @param {number} index - The index parameter is a number that represents the index of a particular
     * reply in an array or list. This function is used to toggle the display of a second level of
     * replies to a particular reply. If the index is already in the subReplyIndex array, it is removed,
     * and if it is not
     */
    showSecondReply(index: number): void;
    /**
     * This function returns an array of comments sorted by date and filtered to only include root
     * comments.
     * @param {any} data - The parameter "data" is an array of objects that contains information about
     * comments or discussions. Each object represents a comment or discussion and has properties such as
     * "discussion_.id", "root_comment_id", "date", etc. The function "getRootComments" takes this array as
     * input and returns an array of
     * @returns The function `getRootComments` is returning an array of objects that represent the root
     * comments of a discussion. Each object in the array has a `subcommentArray` property that contains an
     * array of objects representing the sub-comments of the root comment. The array is sorted by the
     * `date` property of the objects in ascending order. The `filter` method is used to only return
     * objects that are parent componets
     */
    getRootComments(data: any): any;
    /**
     * This function adds a comment to a report with specific details.
     * @param {any} event - The event parameter is an object that contains information about the event
     * that triggered the function. It is likely an event object that was passed as an argument to the
     * function when it was called.
     * @param {any} log - The `log` parameter is an object that contains information related to a
     * specific discussion or comment. It likely includes properties such as `discussion_id`,
     * `duedate_id`, and possibly others depending on the context of the code.
     */
    getEditorInfo(event: any, log: any): void;
    /**
     * The function subscribes to a refreshLog$ observable and resets two index arrays when a new value
     * is emitted.
     */
    onRefresh(): void;
    /**
     * The function opens a dialog box with a given log and prompts the user to confirm deletion, then
     * deletes the log if confirmed.
     * @param {any} log - The `log` parameter is of type `any` and is passed as an argument to the
     * `deleteLog` function. It is used to display information in a dialog box and to delete a comment
     * associated with that log.
     */
    deleteLog(log: any): void;
    /**
     * This function deletes a comment using an API call and displays a success message.
     * @param {any} res - an object containing information about the comment to be deleted, including its
     * ID (_id)
     */
    deleteComment(res: any): void;
    /**
     * The function prompts a dialog box to confirm the deletion of a file or evidence and calls the
     * onEvidenceDelete function if confirmed.
     * @param {any} file - The file that is being deleted.
     * @param {any} log - The log parameter is an object that contains information about the file that was
     * deleted, including whether it was evidence or not, the number of evidence or files associated with
     * it, and the name of the member who uploaded it.
     */
    onFileDelete(file: any, log: any): void;
    /**
     * This function sends a post request to delete evidence or files and displays a success message using
     * the snackbar service.
     * @param {any} file - The file object that is being deleted.
     * @param {any} log - The `log` parameter is an object that contains information about the evidence or
     * file being deleted, such as the ID(s) of the evidence or file, the name of the member who deleted
     * it, and whether it is evidence or a file.
     */
    onEvidenceDelete(file: any, log: any): void;
    bookmark(member_id: any, report_id: any, duedate_id: any, discussion_id: any, comment: any, isBookmarkedValue: any): void;
    onBookMark(payload: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DueDateLogComponent, [null, null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DueDateLogComponent, "due-date-log", never, { "logDetails": { "alias": "logDetails"; "required": false; }; "reportDetails": { "alias": "reportDetails"; "required": false; }; "dueDateId": { "alias": "dueDateId"; "required": false; }; "dueDateDetails": { "alias": "dueDateDetails"; "required": false; }; }, { "onActionTaken": "onActionTaken"; }, never, never, false, never>;
}

interface UserProfile {
    name: string;
    email: string;
    shortName: string;
    imageUrl: string;
}

declare class AvatarComponent {
    avatarColor: 'blue' | 'green';
    sizeClass: 'md' | 'sm' | 'lg';
    userDetails: UserProfile;
    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarComponent, "avatar", never, { "avatarColor": { "alias": "avatarColor"; "required": false; }; "sizeClass": { "alias": "sizeClass"; "required": false; }; "userDetails": { "alias": "userDetails"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GetUserProfilePipe implements PipeTransform {
    environment: any;
    constructor(config?: Configurations);
    transform(value: any, type: 'ASSIGN_BY' | 'ASSIGN_TO' | 'EMPLOYEE' | 'LOG' | 'COLLABORATOR' | 'OVERSEER' | ''): UserProfile;
    getAssignByData(value: any): {
        name: string;
        email: any;
        shortName: any;
        imageUrl: string;
    };
    getAssignToData(value: any): {
        name: string;
        email: any;
        shortName: any;
        imageUrl: string;
    };
    getEmployeeData(value: any): {
        name: any;
        email: any;
        shortName: any;
        imageUrl: string;
    };
    getMemberData(value: any): {
        name: any;
        email: any;
        shortName: any;
        imageUrl: string;
    };
    getLogData(value: any): {
        name: any;
        email: any;
        shortName: any;
        imageUrl: string;
    };
    getCollaborator(value: any): {
        name: any;
        email: any;
        shortName: any;
        imageUrl: string;
    };
    getOverseer(value: any): {
        name: any;
        email: any;
        shortName: any;
        imageUrl: string;
    };
    getProfileURL(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetUserProfilePipe, [{ optional: true; }]>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetUserProfilePipe, "getUserProfile", false>;
}

declare class SanitizeHtmlPipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(value: string | null | undefined): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizeHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizeHtmlPipe, "sanitizeHtml", false>;
}

declare class EditorHtmlPipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(value: string | null | undefined): SafeHtml | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditorHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EditorHtmlPipe, "editorHtml", false>;
}

declare class GetLogClassPipe implements PipeTransform {
    transform(value: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetLogClassPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetLogClassPipe, "getLogClass", false>;
}

declare class ChangeTimezonePipe implements PipeTransform {
    private authorizer;
    constructor(authorizer: AuthorizerService);
    transform(value: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangeTimezonePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ChangeTimezonePipe, "changeTimezone", false>;
}

declare class ProfilePipe implements PipeTransform {
    environment: any;
    constructor(config?: Configurations);
    transform(value: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProfilePipe, [{ optional: true; }]>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ProfilePipe, "profile", false>;
}

declare class SearchPipe implements PipeTransform {
    transform(items: any[], ...args: any[]): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SearchPipe, "search", false>;
}

declare class StripHtmlPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<StripHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<StripHtmlPipe, "stripHtml", false>;
}

declare class ReadMorePipe implements PipeTransform {
    transform(value: string, height: number): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReadMorePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ReadMorePipe, "readMore", false>;
}

declare class AssigneeTooltipPipe implements PipeTransform {
    transform(entrustedMembers: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AssigneeTooltipPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AssigneeTooltipPipe, "AssigneeTooltip", false>;
}

declare class safeHTMLPipe implements PipeTransform {
    private domSanitizer;
    constructor(domSanitizer: DomSanitizer);
    transform(url: string | null | undefined): SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<safeHTMLPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<safeHTMLPipe, "safeHTML", false>;
}

declare class PipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, [typeof GetUserProfilePipe, typeof SanitizeHtmlPipe, typeof EditorHtmlPipe, typeof GetLogClassPipe, typeof ChangeTimezonePipe, typeof ProfilePipe, typeof SearchPipe, typeof StripHtmlPipe, typeof ReadMorePipe, typeof AssigneeTooltipPipe, typeof safeHTMLPipe], [typeof i2.CommonModule], [typeof GetUserProfilePipe, typeof SanitizeHtmlPipe, typeof EditorHtmlPipe, typeof GetLogClassPipe, typeof ChangeTimezonePipe, typeof ProfilePipe, typeof SearchPipe, typeof StripHtmlPipe, typeof ReadMorePipe, typeof AssigneeTooltipPipe, typeof safeHTMLPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
}

declare class FilesComponent {
    fileService: FilesService;
    filesArray: Array<any>;
    environment: any;
    isDeleted: boolean;
    onDelete: EventEmitter<any>;
    constructor(fileService: FilesService, config?: Configurations);
    deleteFile(file: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilesComponent, "files", never, { "filesArray": { "alias": "filesArray"; "required": false; }; "isDeleted": { "alias": "isDeleted"; "required": false; }; }, { "onDelete": "onDelete"; }, never, ["*"], true, never>;
}

declare class LogEditorComponent implements OnInit, OnChanges, OnDestroy {
    private commonApiService;
    fileService: FilesService;
    private authorizerService;
    description: any;
    currentInputComments: string;
    dueDateList: Array<any>;
    userList: Array<any>;
    reportDetails: any;
    dueDateId: string;
    fileUploadingStatus: Array<any>;
    onSave: EventEmitter<any>;
    userDetails: any;
    unSubscribe: Subject<any>;
    id: string;
    constructor(commonApiService: CommonApiService, fileService: FilesService, authorizerService: AuthorizerService);
    ngOnDestroy(): void;
    getCollaborator(): void;
    ngOnChanges(): void;
    ngOnInit(): void;
    /**
     * This function subscribes to a common API service and retrieves mentioned dates, which are then
     * assigned to a property in the description object.
     */
    getMentionedDates(): void;
    /**
     * This function retrieves mentioned users from a common API service and updates the description
     * accordingly.
     */
    getMentionedUsers(): void;
    getFiles(filesArray: any): void;
    getFileUploadingStatus(): void;
    insertComment(event: any): void;
    onDataChange(event: any): void;
    stripElement(value: string): string;
    removeSelectedFile(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogEditorComponent, "log-editor", never, { "description": { "alias": "description"; "required": false; }; "dueDateList": { "alias": "dueDateList"; "required": false; }; "userList": { "alias": "userList"; "required": false; }; "dueDateId": { "alias": "dueDateId"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "onSave": "onSave"; }, never, never, false, never>;
}

declare class LogEditorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LogEditorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LogEditorModule, [typeof LogEditorComponent], [typeof i2.CommonModule, typeof i3.VcomplyEditorModule, typeof TooltipModule, typeof i6.FormsModule, typeof FilesComponent, typeof PipesModule, typeof AvatarComponent], [typeof LogEditorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LogEditorModule>;
}

declare class TextLoaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TextLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextLoaderComponent, "text-loader", never, {}, {}, never, never, false, never>;
}

declare class TextLoaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TextLoaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TextLoaderModule, [typeof TextLoaderComponent], [typeof i2.CommonModule], [typeof TextLoaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TextLoaderModule>;
}

declare class DueDateLogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DueDateLogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DueDateLogModule, [typeof DueDateLogComponent], [typeof i2.CommonModule, typeof i3.VcomplyEditorModule, typeof TooltipModule, typeof AvatarComponent, typeof PipesModule, typeof FilesComponent, typeof LogEditorModule, typeof DialogModule, typeof ActionDialogModule, typeof TextLoaderModule], [typeof DueDateLogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DueDateLogModule>;
}

declare class ConfirmQuickComponent implements OnInit {
    private dialog;
    dialogConfig: DialogConfig;
    animation: boolean;
    messageContent: string;
    type: string;
    icon: string;
    constructor(dialog: DialogRef, dialogConfig: DialogConfig);
    ngOnInit(): void;
    delete(deleteFlag: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmQuickComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmQuickComponent, "vui-quick-confirm", never, {}, {}, never, never, false, never>;
}

declare class OrganizationUserService {
    private http;
    private organizationUsers;
    env: any;
    constructor(http: HttpClient, config?: Configurations);
    private getAllOrgUser;
    private setOrganizationUsers;
    getOrganizationUsers(): Observable<any[]>;
    private dataMap;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationUserService, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OrganizationUserService>;
}

declare class HandoverTransferComponent implements OnInit {
    private dialog;
    dialogConfig: DialogConfig;
    private apiService;
    private snackBarService;
    private authorizer;
    private OrganizationUserService;
    animation: boolean;
    messageContent: string;
    type: string;
    icon: string;
    loader: boolean;
    myId: number;
    responsibilityDetails: any;
    itemListArray: Array<any>;
    selectedData: any;
    searchText: string;
    minDate: any;
    delegateDate: any;
    validation: any;
    orgDetails: any;
    constructor(dialog: DialogRef, dialogConfig: DialogConfig, apiService: ApiService, snackBarService: SnackBarService, authorizer: AuthorizerService, OrganizationUserService: OrganizationUserService);
    ngOnInit(): void;
    delete(deleteFlag: boolean): void;
    showOption: boolean;
    selectedUser: any;
    data: any;
    closeDialog(data?: any): void;
    selectedOption(event: any): void;
    showErrorSnackbar(): void;
    /**
     * It gets a list of members from the API and then sets the user for handover.
     */
    getMemberList(): void;
    apiCalled(url: string, setUser: any): void;
    getEmployeeList(): void;
    /**
     * The function takes an array of objects, filters out the objects that don't meet the criteria, and
     * returns a new array of objects that do meet the criteria.
     * @param {any} handoverList - Array of objects
     */
    setUserForHandover(handoverList: any): void;
    /**
     * The function takes in an array of objects, and returns a filtered array of objects.
     *
     * The function is called like this:
     *
     * this.setUserForTransfer(this.transferList);
     * The function is called
     * @param {any} transferList - any = [{employee_email: "test@test.com", employee_name: "test",
     * employee_id: "123"}, {employee_email: "test1@test.com", employee_name: "test1", employee_id: "1234"}
     */
    setUserForTransfer(transferList: any): void;
    setUserForDelegate(delegateList: any): void;
    getToday(timestamp: any): number;
    getMinDate(): string;
    setNewDelegateDate(event: any): void;
    get isYesDisabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HandoverTransferComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HandoverTransferComponent, "handover-transfer", never, {}, {}, never, never, false, never>;
}

declare class DeleteParentRespQuickComponent implements OnInit {
    private dialog;
    dialogConfig: DialogConfig;
    animate: boolean;
    dependentResponsibilities: Array<any>;
    responsibility: any;
    constructor(dialog: DialogRef, dialogConfig: DialogConfig);
    ngOnInit(): void;
    activate(deleteFlag: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeleteParentRespQuickComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeleteParentRespQuickComponent, "delete-parent-quick-resp", never, {}, {}, never, never, false, never>;
}

declare class QuickActionDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<QuickActionDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<QuickActionDialogModule, [typeof ConfirmQuickComponent, typeof HandoverTransferComponent, typeof DeleteParentRespQuickComponent], [typeof DialogModule, typeof i2.CommonModule, typeof i6.FormsModule, typeof PopoverModule, typeof TooltipModule, typeof i14.MatDatepickerModule, typeof i10.MatNativeDateModule, typeof PipesModule], [typeof ConfirmQuickComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<QuickActionDialogModule>;
}

declare class DialogActionFormComponent implements OnInit, OnChanges, DoCheck {
    private authorizerService;
    private apiService;
    private snackBarService;
    private quickViewService;
    private datePipe;
    animation: boolean;
    data: any;
    isList: boolean;
    isTextEditor: boolean;
    isFileUpload: boolean;
    actionData: EventEmitter<any>;
    date1: any;
    date2: any;
    showOption: boolean;
    eventDateError: boolean;
    eventDate2Error: boolean;
    eventStatusName: string;
    selectedCompliance: number;
    selectedComplianceDate: any;
    selectedComplianceDate2: any;
    minDate: any;
    maxDate: any;
    today: Date;
    reportObject_id: any;
    uploadedFiles: Array<any>;
    fileName: Array<any>;
    files: never[];
    dropZoneHovered: boolean;
    attachmentId: Array<any>;
    attachmentResponse: any;
    isAddDate: boolean;
    isSubmit: boolean;
    isRevoke: boolean;
    reasonData: string;
    editDueDateId: any;
    searchText: string;
    startTime: any;
    numb: string;
    failedValue: any;
    reminderValue: any;
    timeData: string;
    dateObject: any;
    isValidTime: boolean;
    datepickerOverlay: boolean;
    dailyTime1: any;
    todayDate: Date;
    fromMinDate: Date;
    fromDate: Date;
    selectedDate: any;
    dateConfig: any;
    dateFromConfig: any;
    userInfo: any;
    descriptionComment: any;
    isLoader: boolean;
    constructor(authorizerService: AuthorizerService, apiService: ApiService, snackBarService: SnackBarService, quickViewService: QuickViewService, datePipe: DatePipe);
    private getSafeStringValue;
    ngOnInit(): void;
    ngOnChanges(): void;
    clickinput(): void;
    hideOption(): void;
    selectedOption(val: any): void;
    getToday(): string;
    cancelAction(): void;
    ngDoCheck(): void;
    submitForm(): void;
    fileExistsBefore(name: string): boolean;
    onFileUpload(event: any): void;
    deleteFile(i: number): void;
    dragHover(): void;
    dragHoverOut(): void;
    applyClass(val: any): any;
    getDate(event: any): void;
    getFromDate(event: any): void;
    getDueDateList(): void;
    changeTimeZone(date: any): "" | Date;
    onDueDateSelected(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogActionFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogActionFormComponent, "app-dialog-action-form", never, { "data": { "alias": "data"; "required": false; }; "isList": { "alias": "isList"; "required": false; }; "isTextEditor": { "alias": "isTextEditor"; "required": false; }; "isFileUpload": { "alias": "isFileUpload"; "required": false; }; }, { "actionData": "actionData"; }, never, never, true, never>;
}

declare class DialogFormModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFormModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogFormModule, never, [typeof DialogActionFormComponent, typeof i15.NgxMaterialTimepickerModule], [typeof DialogActionFormComponent, typeof i15.NgxMaterialTimepickerModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DialogFormModule>;
}

declare class SnackBarComponent implements OnInit {
    private snackbarService;
    show: boolean;
    message: string;
    icon: string;
    type: string;
    icons: any;
    snackbarSubscription: Subscription;
    constructor(snackbarService: SnackBarService);
    ngOnInit(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SnackBarComponent, "app-snack-bar", never, {}, {}, never, never, false, never>;
}

declare class SnackBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SnackBarModule, [typeof SnackBarComponent], [typeof i2.CommonModule], [typeof SnackBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SnackBarModule>;
}

declare class WorkflowComponent implements OnInit, OnDestroy {
    private sessionStorage;
    private workflowService;
    iframeSource: string;
    wfeIframe: string;
    iframeLoading: boolean;
    workflowSubscription: Subscription;
    isWorkflowOpened: boolean;
    constructor(sessionStorage: SessionStorageService, workflowService: WorkflowService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    handleWorkflowSubscription(): void;
    setIframeSource(): void;
    closeWorkflow(_: boolean): void;
    handleCloseIframe(event: any): void;
    handleIframeLoaded(): void;
    unloadNotification($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorkflowComponent, "app-workflow", never, {}, {}, never, never, false, never>;
}

declare class AppIframeComponent implements OnInit, AfterViewInit {
    src: string;
    type: string;
    closeIframe: EventEmitter<any>;
    onIframeLoaded: EventEmitter<void>;
    iframe: ElementRef;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private handleMessage;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppIframeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppIframeComponent, "app-iframe", never, { "src": { "alias": "src"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "closeIframe": "closeIframe"; "onIframeLoaded": "onIframeLoaded"; }, never, never, false, never>;
}

declare class AppIframeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AppIframeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AppIframeModule, [typeof AppIframeComponent], [typeof i2.CommonModule, typeof PipesModule], [typeof AppIframeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AppIframeModule>;
}

declare class QuickViewWorkflowModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<QuickViewWorkflowModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<QuickViewWorkflowModule, [typeof WorkflowComponent], [typeof i2.CommonModule, typeof AppIframeModule], [typeof WorkflowComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<QuickViewWorkflowModule>;
}

declare class VLoaderInlineComponent {
    vLoader: any;
    ASSETS: any;
    env: any;
    constructor(config?: Configurations);
    static ɵfac: i0.ɵɵFactoryDeclaration<VLoaderInlineComponent, [{ optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VLoaderInlineComponent, "vui-loader-inline", never, {}, {}, never, never, false, never>;
}

declare class VLoaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<VLoaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<VLoaderModule, [typeof VLoaderInlineComponent], [typeof i2.CommonModule], [typeof VLoaderInlineComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<VLoaderModule>;
}

declare class CircleComponent {
    progressColor: string;
    fillColor: string;
    value: string;
    isValueVisible: boolean;
    isPercentVisible: boolean;
    textColor: string;
    circularSize: string;
    borderSize: string;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CircleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CircleComponent, "app-circle-progress", never, { "progressColor": { "alias": "progressColor"; "required": false; }; "fillColor": { "alias": "fillColor"; "required": false; }; "value": { "alias": "value"; "required": false; }; "isValueVisible": { "alias": "isValueVisible"; "required": false; }; "isPercentVisible": { "alias": "isPercentVisible"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "circularSize": { "alias": "circularSize"; "required": false; }; "borderSize": { "alias": "borderSize"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CircleProgressModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CircleProgressModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CircleProgressModule, [typeof CircleComponent], [typeof i2.CommonModule], [typeof CircleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CircleProgressModule>;
}

declare class ResponsibilityQuickviewModule {
    static forRoot(environmentConfig: Configurations): ModuleWithProviders<ResponsibilityQuickviewModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsibilityQuickviewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ResponsibilityQuickviewModule, [typeof ResponsibilityQuickviewContainerComponent, typeof QuickViewComponent, typeof OverviewComponent, typeof CompletionHistoryComponent, typeof FilesFoldersComponent, typeof OverviewDetailsComponent, typeof QuickviewLoaderComponent, typeof CompletionLoaderComponent, typeof FilesFoldersLoaderComponent, typeof MarkAsCompleteComponent, typeof DetailsLoaderComponent, typeof SkeletonLoaderComponent, typeof OverviewPerformanceComponent], [typeof i2.CommonModule, typeof PopoverModule, typeof TooltipModule, typeof DialogModule, typeof ActionDialogModule, typeof FormgroupModule, typeof DirectiveModule, typeof NoDataModule, typeof DueDateLogModule, typeof i3.VcomplyEditorModule, typeof LogEditorModule, typeof TextLoaderModule, typeof AvatarComponent, typeof PipesModule, typeof QuickActionDialogModule, typeof i6.FormsModule, typeof DialogFormModule, typeof SnackBarModule, typeof FilesComponent, typeof QuickViewWorkflowModule, typeof VLoaderModule, typeof CircleProgressModule], [typeof ResponsibilityQuickviewContainerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ResponsibilityQuickviewModule>;
}

export { ResponsibilityQuickviewContainerComponent, ResponsibilityQuickviewModule };