herum-shared 0.1.25

package/index.d.ts

@@ -0,0 +1,2946 @@
+import * as i0 from '@angular/core';
+import { ElementRef, EventEmitter, OnChanges, OnDestroy, SimpleChanges, AfterViewInit, OnInit, ChangeDetectorRef, QueryList, TemplateRef, PipeTransform, Renderer2 } from '@angular/core';
+import { ResourceGradeUpdate, IMediaPlayer, ResourceSubscription, MediaSettings, TextChange, UserPreview, TextChangeStyle, Resource, QuizData, Question, UserAnswer, Answer, IdentifiedEntity, HerumTableParams, ViewModelType, GlobalKeyboardEvent, AudioVisualConfiguration, TreeNode, NodeMenuItem, SystemTreeNodeData, TimeRange, DateTimePicker, AnswerNote, UserQuestionData, DialogConfig, FileData, User, RecursiveTitledOption, MenuItem, CollectionSubscription, CollectionBase, Collection, ModifiedResource, SignUpField, DisplayIdentifiedEntity, TreeNodeAssignmentsData, Step, KeyValue, ProgressOverView, FetchedMessage, AlignDir, HoveredHerumRowTable, BaseRowData, FailedDependentsRequestsContext, CommonDependentsToast, ToastHttpResponseDependencies, ComplexObservableArrowFunctions, DependentMetadata, ObservableArrowFunction, Toast, ToastTemplate, ToastStatus, UploadProgressMetadata, UploadProgressStatus, UploadProgressType } from 'herum-shared/herum-types';
+import { Subject, BehaviorSubject, Observable } from 'rxjs';
+import { GlobalKeyboardListenerService as GlobalKeyboardListenerService$1, KeyPressService as KeyPressService$1, TrackTextChangesService, CommonGraphqlRequestsService } from 'herum-shared/services';
+import { HttpClient, HttpRequest, HttpErrorResponse } from '@angular/common/http';
+import { EnvironmentConfig } from 'herum-shared/environment';
+import * as i40 from '@angular/forms';
+import { FormControl, ControlValueAccessor, FormGroup, FormBuilder, NgControl, ControlContainer, ValidatorFn, AsyncValidatorFn } from '@angular/forms';
+import * as i53 from '@angular/material/datepicker';
+import { DateRange, MatCalendar } from '@angular/material/datepicker';
+import * as i2 from '@angular/common';
+import * as i41 from '@angular/material/menu';
+import * as i42 from '@angular/cdk/clipboard';
+import { Clipboard } from '@angular/cdk/clipboard';
+import * as i43 from '@angular/material/autocomplete';
+import * as i44 from '@angular/material/chips';
+import * as i45 from '@angular/material/form-field';
+import * as i46 from '@angular/material/tooltip';
+import * as i47 from '@angular/material/input';
+import * as i48 from '@angular/material/select';
+import * as i49 from '@angular/material/icon';
+import * as i50 from '@angular/material/checkbox';
+import * as i51 from '@angular/material/slider';
+import * as i52 from '@angular/cdk/drag-drop';
+import * as i54 from '@angular/material/core';
+import { DateAdapter } from '@angular/material/core';
+import { MatDialogRef, MatDialog } from '@angular/material/dialog';
+import * as i4 from 'herum-shared/atoms';
+import { HerumInputFieldComponent as HerumInputFieldComponent$1 } from 'herum-shared/atoms';
+import * as i4$1 from 'herum-shared/pipes';
+import * as i6 from 'herum-shared/molecules';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import { SplitGutterInteractionEvent } from 'angular-split';
+import * as i15 from 'ag-grid-angular';
+import { ICellRendererAngularComp, AgFilterComponent } from 'ag-grid-angular';
+import { ICellRendererParams, ColDef, GridApi, ColumnApi, GridReadyEvent, ModelUpdatedEvent, IFilterParams, IDoesFilterPassParams } from 'ag-grid-community';
+import * as _angular_animations from '@angular/animations';
+import { UtilsService as UtilsService$1 } from 'herum-shared/static-services';
+import { ToastsService as ToastsService$1, UploadsManagerService as UploadsManagerService$1 } from 'herum-shared/mongo/services';
+
+declare class HerumToolTipDirective {
+    private el;
+    tooltipText: string;
+    private tooltip;
+    constructor(el: ElementRef);
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    private showTooltip;
+    private hideTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumToolTipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HerumToolTipDirective, "[appHerumToolTip]", never, { "tooltipText": { "alias": "tooltipText"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface IHerumInterface {
+    srcPath: string;
+    resourceId: string;
+    onGradeUpdate: EventEmitter<ResourceGradeUpdate>;
+}
+
+declare class HerumVideoPlayerComponent implements OnChanges, OnDestroy, IHerumInterface, IMediaPlayer {
+    private globalKeyboardListener;
+    private keyPressService;
+    resourceSubscription: ResourceSubscription;
+    srcPath: string;
+    resourceId: string;
+    isResourceInWideMode: boolean;
+    format: 'regular' | 'preview' | 'no-height';
+    mediaSettings: MediaSettings;
+    isBlock: boolean;
+    id: string;
+    getTimeUpdate: number;
+    onGradeUpdate: EventEmitter<any>;
+    isLoadingChange: EventEmitter<boolean>;
+    mediaSettingsUpdate: EventEmitter<any>;
+    mediaSettingsUpdateByRequest: EventEmitter<number>;
+    videoPlayer: ElementRef;
+    _onKeyDown(event: KeyboardEvent): void;
+    videoLoaded: boolean;
+    currentTime: string;
+    duration: string;
+    progress: number;
+    isDragging: boolean;
+    maxTimePassed: number;
+    videoSpeedOptions: number[];
+    currentSpeed: number;
+    isPictureInPictureMode: boolean;
+    isGlobalKeyboardBindingActive: boolean;
+    canPlay: boolean;
+    isToUpdateGrade$: Subject<void>;
+    destroySubject$: Subject<null>;
+    updateGradeInterval: any;
+    updateCurrentTimeInterval: number;
+    constructor(globalKeyboardListener: GlobalKeyboardListenerService$1, keyPressService: KeyPressService$1);
+    ngOnChanges(changes: SimpleChanges): void;
+    private resetVideoState;
+    private setGradeInterval;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private setVideoPlayer;
+    private globalKeyboardListenerInitiation;
+    private isToUpdateGrade;
+    private fastForward;
+    private rewind;
+    _onPlayPause(): void;
+    private playPause;
+    private isFullScreen;
+    private formatTime;
+    _timeUpdate(): void;
+    _onMuteUnmute(): void;
+    _onToggleFullScreen(): void;
+    private getCurrentGrade;
+    private updateGrade;
+    _onTogglePictureInPictureMode(): void;
+    _setisDragging(isDragging: boolean): void;
+    _setVideoPlayerCurrentTime(currentTime: number): void;
+    _setVideoPlayerVolume(volume: number): void;
+    _setVideoSpeed(speed: number): void;
+    _loadStart(): void;
+    _videoLoad(): void;
+    _canplay(): void;
+    private emitMediaSettingsUpdate;
+    private keysBinding;
+    get keysBindingToFunction(): {
+        numpad0: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad1: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad2: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad3: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad4: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad5: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad6: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad7: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad9: {
+            keyNumber: number;
+            function: () => void;
+        };
+    };
+    private formatCode;
+    get primaryPlaySvg(): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumVideoPlayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumVideoPlayerComponent, "herum-video-player", never, { "resourceSubscription": { "alias": "resourceSubscription"; "required": false; }; "srcPath": { "alias": "srcPath"; "required": false; }; "resourceId": { "alias": "resourceId"; "required": false; }; "isResourceInWideMode": { "alias": "isResourceInWideMode"; "required": false; }; "format": { "alias": "format"; "required": false; }; "mediaSettings": { "alias": "mediaSettings"; "required": false; }; "isBlock": { "alias": "isBlock"; "required": false; }; "id": { "alias": "id"; "required": false; }; "getTimeUpdate": { "alias": "getTimeUpdate"; "required": false; }; }, { "onGradeUpdate": "onGradeUpdate"; "isLoadingChange": "isLoadingChange"; "mediaSettingsUpdate": "mediaSettingsUpdate"; "mediaSettingsUpdateByRequest": "mediaSettingsUpdateByRequest"; }, never, never, false, never>;
+}
+
+declare class TrackTextChangesComponent implements AfterViewInit, OnChanges {
+    private trackTextChangesService;
+    changes: TextChange[];
+    selectedChange: TextChange;
+    currentUser: UserPreview;
+    baseContent: string;
+    isReadOnly: boolean;
+    fontSize: number;
+    showComments: boolean;
+    changesEmitter: EventEmitter<any[]>;
+    editor: ElementRef;
+    trackChangesEnabled: boolean;
+    currentSelection: {
+        range: Range;
+        text: string;
+    } | null;
+    showTooltip: boolean;
+    showNotAllowedActionTooltip: boolean;
+    showCommentBox: boolean;
+    editCommentBox: boolean;
+    tooltipPosition: {
+        top: number;
+        left: number;
+    };
+    commentBoxPosition: {
+        top: number;
+        left: number;
+    };
+    showNotAllowedActionTooltipPosition: {
+        top: number;
+        left: number;
+    };
+    newCommentText: string;
+    isCursorInsideTooltip: boolean;
+    isCursorInsideMarker: boolean;
+    private editingCommentElement;
+    markerTimeoutId: any;
+    textChangeStyle: TextChangeStyle;
+    commentTextHoverColor: string;
+    constructor(trackTextChangesService: TrackTextChangesService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    _onKeyDown(event: KeyboardEvent): void;
+    /**
+     * handles text selection to show the tooltip for comments.
+     * @param event mouse event from the text editor.
+     */
+    _onTextSelection(): void;
+    private isAdditionKeyPressValid;
+    private handleShowNotAllowedActionTooltip;
+    private isValidSelection;
+    private getSelectionTooltipPosition;
+    private getTooltipPosition;
+    private setElementPosition;
+    _onDropTextSelection(event: MouseEvent): void;
+    /**
+     * Applies external changes to the base content and updates the editor.
+     */
+    private applyChangesToContent;
+    private sortAdjacentChangesWhichOneOfThemIsAdditionType;
+    /**
+     * Applies an addition change by inserting an <ins> tag.
+     * @param content The current content.
+     * @param change The change record.
+     * @returns The updated content.
+     */
+    private applyAdditionChange;
+    /**
+     * Applies a deletion change by inserting a <del> tag.
+     * @param content The current content.
+     * @param change The change record.
+     * @returns The updated content.
+     */
+    private applyDeletionChange;
+    /**
+     * Applies a comment change by inserting a comment marker with tooltip.
+     * @param content The current content.
+     * @param change The change record.
+     * @returns The updated content.
+     */
+    private applyCommentChange;
+    /**
+     * Generates the HTML string for a comment change.
+     * @param change The comment change record.
+     * @returns The outerHTML string of the comment element.
+     */
+    private getCommentHTML;
+    /**
+     * Rebinds hover and click events for comment markers after updating the content.
+     */
+    private rebindCommentTooltips;
+    private addEventListenerToMarkerAndTooltip;
+    private removeEventListenerFromMarkersAndTooltips;
+    private isUpdateAdditionWhileSelectionIsNextToInsTag;
+    private updateAddition;
+    private updateAdditionWhileSelectionIsInsideInsTag;
+    private updateAdditionWhileSelectionIsNextToInsTag;
+    /**
+     * Inserts a new addition by wrapping the inserted text in an <ins> tag.
+     * @param selection The current selection.
+     * @param text The text to insert.
+     */
+    private insertNewAddition;
+    /**
+     * Creates an <ins> tag element for added text.
+     * @param text The text content.
+     * @returns The created <ins> HTMLElement.
+     */
+    private createInsTag;
+    /**
+     * Updates the current selection to a new range.
+     * @param selection The current selection.
+     * @param node The node in which to set the caret.
+     * @param offset The offset within the node.
+     */
+    private updateSelection;
+    /**
+     * Handles deletion of selected text.
+     * @param selection The current selection.
+     */
+    private handleDeletion;
+    deleteChange(changeToDelete: TextChange): void;
+    /**
+     * Creates a <del> tag element for deleted text.
+     * @param text The text content.
+     * @returns The created <del> HTMLElement.
+     */
+    private createDelTag;
+    /**
+     * Opens the comment box tooltip for the current selection.
+     */
+    openCommentBox(): void;
+    /**
+     * Calculates the position for the comment box.
+     * @param rect The bounding client rect.
+     * @param isExisting Flag to adjust position if already open.
+     * @returns The top and left coordinates.
+     */
+    private calculateCommentBoxPosition;
+    /**
+     * Adds a comment using a prompt (used by the toolbar).
+     */
+    addComment(): void;
+    /**
+     * Saves a comment from the comment box. If editing, updates the existing comment.
+     */
+    saveComment(): void;
+    /**
+     * Creates a comment tag (<span>) for wrapping commented text.
+     * @param comment The comment text.
+     * @returns The created comment marker element.
+     */
+    private createCommentTag;
+    /**
+     * Attaches a tooltip (with edit and delete buttons) to a comment element.
+     * @param commentTag The comment marker element.
+     * @param comment The comment text.
+     */
+    private attachTooltipToComment;
+    updateListenersForMarksAndTooltips(): void;
+    /**
+     * Opens the edit comment mode by showing the comment tooltip pre-filled with the existing comment.
+     * @param commentTag The comment marker element.
+     * @param tooltip The tooltip element.
+     */
+    editComment(commentTag: HTMLElement, tooltip: HTMLElement): void;
+    /**
+     * Deletes a comment from the DOM and removes its change record.
+     * @param commentTag The comment marker element.
+     */
+    deleteComment(commentTag: HTMLElement): void;
+    cancelComment(): void;
+    private resetCommentUI;
+    private generateId;
+    /**
+     * Calculates the absolute offset of a node within the editor.
+     * @param root The root node (editor element).
+     * @param node The target node.
+     * @param offset The offset within the target node.
+     * @returns The absolute offset.
+     */
+    private getAbsoluteOffset;
+    /**
+     * Determines if a node is inside a given tag.
+     * @param node The starting node.
+     * @param tagName The tag name to check.
+     * @returns True if inside the tag; otherwise, false.
+     */
+    private isInsideTag;
+    private getNextSiblingSameTag;
+    /**
+     * Records a change in the changes list.
+     * @param change A partial change object.
+     */
+    private recordChange;
+    /**
+     * Toggles the track changes feature.
+     */
+    toggleTrackChanges(): void;
+    _isTruncatedElement(element: HTMLElement): boolean;
+    get informationIconSvgString(): string;
+    get messagePlusIconSvgString(): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackTextChangesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TrackTextChangesComponent, "track-text-changes", never, { "changes": { "alias": "changes"; "required": false; }; "selectedChange": { "alias": "selectedChange"; "required": false; }; "currentUser": { "alias": "currentUser"; "required": false; }; "baseContent": { "alias": "baseContent"; "required": false; }; "isReadOnly": { "alias": "isReadOnly"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "showComments": { "alias": "showComments"; "required": false; }; }, { "changesEmitter": "changesEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumVideoRangeBarComponent implements OnInit {
+    percentage: number;
+    percentageChanged: EventEmitter<number>;
+    constructor();
+    ngOnInit(): void;
+    onBarClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumVideoRangeBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumVideoRangeBarComponent, "herum-video-range-bar", never, { "percentage": { "alias": "percentage"; "required": false; }; }, { "percentageChanged": "percentageChanged"; }, never, never, false, never>;
+}
+
+declare class HerumPdfViewerComponent implements OnChanges, IHerumInterface {
+    srcPath: string;
+    isResourceInWideMode: boolean;
+    resourceId: string;
+    onGradeUpdate: EventEmitter<any>;
+    pdfFrame: ElementRef;
+    ngOnChanges(): void;
+    private updateGrade;
+    handleError(a: any): void;
+    onError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumPdfViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumPdfViewerComponent, "herum-pdf-viewer", never, { "srcPath": { "alias": "srcPath"; "required": false; }; "isResourceInWideMode": { "alias": "isResourceInWideMode"; "required": false; }; "resourceId": { "alias": "resourceId"; "required": false; }; }, { "onGradeUpdate": "onGradeUpdate"; }, never, never, false, never>;
+}
+
+declare class HerumStoryViewerComponent implements OnChanges, IHerumInterface {
+    srcPath: string;
+    isResourceInWideMode: boolean;
+    resourceId: string;
+    onGradeUpdate: EventEmitter<any>;
+    constructor();
+    ngOnChanges(): void;
+    private updateGrade;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumStoryViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumStoryViewerComponent, "herum-story-viewer", never, { "srcPath": { "alias": "srcPath"; "required": false; }; "isResourceInWideMode": { "alias": "isResourceInWideMode"; "required": false; }; "resourceId": { "alias": "resourceId"; "required": false; }; }, { "onGradeUpdate": "onGradeUpdate"; }, never, never, false, never>;
+}
+
+declare class UserActionDirective {
+    private el;
+    private http;
+    private environmentConfig;
+    description: string;
+    constructor(el: ElementRef, http: HttpClient, environmentConfig: EnvironmentConfig);
+    onClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserActionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UserActionDirective, "[userAction]", never, { "description": { "alias": "userAction"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumPresentationViewerComponent implements OnInit, IHerumInterface {
+    srcPath: string;
+    resourceId: string;
+    onGradeUpdate: EventEmitter<any>;
+    constructor();
+    ngOnInit(): void;
+    private updateGrade;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumPresentationViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumPresentationViewerComponent, "app-herum-presentation-viewer", never, { "srcPath": { "alias": "srcPath"; "required": false; }; "resourceId": { "alias": "resourceId"; "required": false; }; }, { "onGradeUpdate": "onGradeUpdate"; }, never, never, false, never>;
+}
+
+declare class HerumLoaderComponent {
+    private environmentConfig;
+    loaderText: string;
+    lottieRef: ElementRef;
+    isHadracha: boolean;
+    constructor(environmentConfig: EnvironmentConfig);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumLoaderComponent, "herum-loader", never, { "loaderText": { "alias": "loaderText"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SvgOnHoverDirective {
+    private element;
+    iconHoverColor: string;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    stroke: string;
+    constructor(element: ElementRef);
+    setElementAttribute(color: string): void;
+    setElementsAttribute(color: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SvgOnHoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SvgOnHoverDirective, "[svgOnHover]", never, { "iconHoverColor": { "alias": "svgOnHover"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumQuizComponent implements OnChanges {
+    private changeDetectorRef;
+    resourceSubscription: ResourceSubscription;
+    isLoading: boolean;
+    isResourceInWideMode: boolean;
+    resource: Resource;
+    quizData: QuizData;
+    onGradeUpdate: EventEmitter<any>;
+    isCurrentQuestionValid: boolean;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    get currentQuestionIndex(): number;
+    get currentQuestionValidation(): boolean;
+    get nextButtonText(): "התחל מבחן" | "חזרה למסך סיכום" | "סיים מבחן" | "הגשת מבחן" | "נסיון חוזר" | "לשאלה הבאה";
+    _previousQuestion(): void;
+    get previousButtonText(): "לשאלה הקודמת" | "חזרה לשאלה הראשונה";
+    get isValidQuiz(): boolean;
+    get isLastQuestion(): boolean;
+    getCorrectAnswersCount(question: Question): any;
+    _nextQuestion(isSkipped?: boolean): void;
+    _getUserAnswers(questionId: string): any;
+    _selectQuestion(questionIndex: number): void;
+    _onAnswersChange(userAnswers: UserAnswer[], questionId: string): void;
+    private updateQuizUserAnswer;
+    private startNewQuiz;
+    private mergeQuizUserDataIntoQuizData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumQuizComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumQuizComponent, "herum-quiz", never, { "resourceSubscription": { "alias": "resourceSubscription"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "isResourceInWideMode": { "alias": "isResourceInWideMode"; "required": false; }; "resource": { "alias": "resource"; "required": false; }; "quizData": { "alias": "quizData"; "required": false; }; }, { "onGradeUpdate": "onGradeUpdate"; }, never, never, false, never>;
+}
+
+declare class QuizHeaderComponent {
+    quizData: QuizData;
+    onSelectQuestion: EventEmitter<number>;
+    onReturnToGradePage: EventEmitter<boolean>;
+    questionsContainer: ElementRef;
+    maxQuestionsToShow: number;
+    questionWidth: number;
+    _onSelectQuestion(questionIndex: number): void;
+    _onReturnToGradePage(): void;
+    _backToSummary(): void;
+    private isQuestionAnswered;
+    private isUserAnsweredCorrect;
+    get questionsContainerWidth(): any;
+    get questionsState(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizHeaderComponent, "quiz-header", never, { "quizData": { "alias": "quizData"; "required": false; }; }, { "onSelectQuestion": "onSelectQuestion"; "onReturnToGradePage": "onReturnToGradePage"; }, never, never, false, never>;
+}
+
+declare class QuizTwoAnswersQuestionComponent {
+    question: Question;
+    userAnswers: UserAnswer[];
+    isSubmitted: boolean;
+    onAnswersChange: EventEmitter<any[]>;
+    selectedAnswer: string;
+    _onAnswersChange(answer: Answer): void;
+    _getAnswerClass(answer: Answer): string;
+    _isTruncatedTitleElement(element: HTMLElement): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizTwoAnswersQuestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizTwoAnswersQuestionComponent, "quiz-two-answers-question", never, { "question": { "alias": "question"; "required": false; }; "userAnswers": { "alias": "userAnswers"; "required": false; }; "isSubmitted": { "alias": "isSubmitted"; "required": false; }; }, { "onAnswersChange": "onAnswersChange"; }, never, never, false, never>;
+}
+
+declare class QuizOneAnswerQuestionComponent implements OnInit, OnChanges {
+    private changeDetectorRef;
+    private environmentConfig;
+    instructionTitle: string;
+    question: Question;
+    userAnswers: UserAnswer[];
+    quizData: QuizData;
+    areAnswersRevealed: boolean;
+    areAnswersBlocked: boolean;
+    isCheckingMode: boolean;
+    onAnswersChange: EventEmitter<any[]>;
+    convertedOptions: {
+        id: string;
+        name: string;
+    }[];
+    selectedAnswer: FormControl;
+    destroySubject$: Subject<null>;
+    answerNotes: string[];
+    correctAnswer: IdentifiedEntity;
+    constructor(changeDetectorRef: ChangeDetectorRef, environmentConfig: EnvironmentConfig);
+    ngOnChanges(changes: SimpleChanges): void;
+    private getAnswerNotes;
+    private convertToOptions;
+    private isCheckedAnswerCorrect;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizOneAnswerQuestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizOneAnswerQuestionComponent, "quiz-one-answer-question", never, { "instructionTitle": { "alias": "instructionTitle"; "required": false; }; "question": { "alias": "question"; "required": false; }; "userAnswers": { "alias": "userAnswers"; "required": false; }; "quizData": { "alias": "quizData"; "required": false; }; "areAnswersRevealed": { "alias": "areAnswersRevealed"; "required": false; }; "areAnswersBlocked": { "alias": "areAnswersBlocked"; "required": false; }; "isCheckingMode": { "alias": "isCheckingMode"; "required": false; }; }, { "onAnswersChange": "onAnswersChange"; }, never, never, false, never>;
+}
+
+declare class QuizSubmissionComponent {
+    quizData: QuizData;
+    quizValidation: boolean;
+    get isAllQuestionsAnswered(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizSubmissionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizSubmissionComponent, "quiz-submission", never, { "quizData": { "alias": "quizData"; "required": false; }; "quizValidation": { "alias": "quizValidation"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class QuizIntroComponent {
+    quizData: QuizData;
+    showSubmissionsCounter: boolean;
+    allQuestionsRequired: boolean;
+    resource: Resource;
+    areAnswersBlocked: boolean;
+    gradeTextPrefix: string;
+    get defaultGrade(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizIntroComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizIntroComponent, "quiz-intro", never, { "quizData": { "alias": "quizData"; "required": false; }; "showSubmissionsCounter": { "alias": "showSubmissionsCounter"; "required": false; }; "allQuestionsRequired": { "alias": "allQuestionsRequired"; "required": false; }; "resource": { "alias": "resource"; "required": false; }; "areAnswersBlocked": { "alias": "areAnswersBlocked"; "required": false; }; "gradeTextPrefix": { "alias": "gradeTextPrefix"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class QuizGradeSheetComponent {
+    resourceSubscription: ResourceSubscription;
+    quizData: QuizData;
+    get isUserPassTheQuiz(): boolean;
+    get questionCount(): any;
+    get quizName(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizGradeSheetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizGradeSheetComponent, "quiz-grade-sheet", never, { "resourceSubscription": { "alias": "resourceSubscription"; "required": false; }; "quizData": { "alias": "quizData"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumCheckboxComponent implements ControlValueAccessor, OnInit {
+    private environmentConfig;
+    type: 'checked' | 'indeterminate' | 'error' | 'disabled' | 'unchecked';
+    isChecked: boolean;
+    isBlocked: boolean;
+    checkedEmitter: EventEmitter<boolean>;
+    indeterminate: string;
+    checked: string;
+    error: string;
+    checkboxClasses: string;
+    params: HerumTableParams;
+    constructor(environmentConfig: EnvironmentConfig);
+    ngOnInit(): void;
+    _onClick(): void;
+    getCheckboxClasses(): string;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(value: {
+        type: any;
+        isChecked: boolean;
+    } | boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumCheckboxComponent, "herum-checkbox", never, { "type": { "alias": "type"; "required": false; }; "isChecked": { "alias": "isChecked"; "required": false; }; "isBlocked": { "alias": "isBlocked"; "required": false; }; }, { "checkedEmitter": "checkedEmitter"; }, never, never, false, never>;
+}
+
+declare class QuizMultiAnswerQuestionComponent {
+    private fb;
+    private environmentConfig;
+    question: Question;
+    quizData: QuizData;
+    userAnswers: UserAnswer[];
+    isCheckingMode: boolean;
+    areAnswersRevealed: boolean;
+    areAnswersBlocked: boolean;
+    correctAnswerCount: number;
+    onAnswersChange: EventEmitter<any[]>;
+    onValidationChange: EventEmitter<boolean>;
+    checkboxes: QueryList<HerumCheckboxComponent>;
+    isValid: boolean;
+    selectedAnswers: FormControl[];
+    answersForm: FormGroup;
+    destroySubject$: Subject<null>;
+    answerTypeAttributes: string[];
+    constructor(fb: FormBuilder, environmentConfig: EnvironmentConfig);
+    ngOnChanges(changes: SimpleChanges): void;
+    private setAnswerTypeAttributes;
+    _onAnswerClicked(index: number): void;
+    _isAnswerChecked(answerId: string): any;
+    getTypeCheckbox(answerId: string): string;
+    private iAnswerCorrect;
+    _onAnswersChange(answer: Answer, isChosen: boolean): void;
+    private getFormControlValue;
+    get controlNamePrefix(): string;
+    get isBlocked(): any;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizMultiAnswerQuestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizMultiAnswerQuestionComponent, "quiz-multi-answer-question", never, { "question": { "alias": "question"; "required": false; }; "quizData": { "alias": "quizData"; "required": false; }; "userAnswers": { "alias": "userAnswers"; "required": false; }; "isCheckingMode": { "alias": "isCheckingMode"; "required": false; }; "areAnswersRevealed": { "alias": "areAnswersRevealed"; "required": false; }; "areAnswersBlocked": { "alias": "areAnswersBlocked"; "required": false; }; "correctAnswerCount": { "alias": "correctAnswerCount"; "required": false; }; }, { "onAnswersChange": "onAnswersChange"; "onValidationChange": "onValidationChange"; }, never, never, false, never>;
+}
+
+declare class QuizLoaderComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizLoaderComponent, "quiz-loader", never, {}, {}, never, never, false, never>;
+}
+
+declare class HerumListCentralizerComponent {
+    containerSize: number;
+    itemSize: number;
+    currentItemIndex: number;
+    isHorizontalMode: boolean;
+    isArrowsNeeded: boolean;
+    itemTemplate: TemplateRef<any>;
+    itemsState: any[];
+    items: any[];
+    centralizedIndex: number;
+    maxItemsToShow: number;
+    ngOnChanges(changes: SimpleChanges): void;
+    private setCentralizedIndex;
+    private calculateResourcesToShow;
+    _onPreviousCentralizedIndex(): void;
+    _onNextCentralizedIndex(): void;
+    _slicedList(items: any[]): any[];
+    get isPreviousArrowActive(): boolean;
+    get isNextArrowActive(): boolean;
+    get isSlicedItemsNeeded(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumListCentralizerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumListCentralizerComponent, "herum-list-centralizer", never, { "containerSize": { "alias": "containerSize"; "required": false; }; "itemSize": { "alias": "itemSize"; "required": false; }; "currentItemIndex": { "alias": "currentItemIndex"; "required": false; }; "isHorizontalMode": { "alias": "isHorizontalMode"; "required": false; }; "isArrowsNeeded": { "alias": "isArrowsNeeded"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "itemsState": { "alias": "itemsState"; "required": false; }; "items": { "alias": "items"; "required": false; }; "centralizedIndex": { "alias": "centralizedIndex"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumLocalLoaderComponent {
+    percentage: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumLocalLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumLocalLoaderComponent, "herum-local-loader", never, { "percentage": { "alias": "percentage"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BlockedFormComponent {
+    inputs: {
+        label: string;
+        value: string;
+    }[];
+    progressBars: {
+        label: string;
+        value: number;
+    }[];
+    view: ViewModelType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockedFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockedFormComponent, "blocked-form", never, { "inputs": { "alias": "inputs"; "required": false; }; "progressBars": { "alias": "progressBars"; "required": false; }; "view": { "alias": "view"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GlobalKeyboardListenerService {
+    private environmentConfig;
+    globalKeyboardEvents$: Subject<GlobalKeyboardEvent>;
+    connection: WebSocket;
+    constructor(environmentConfig: EnvironmentConfig);
+    initGlobalSocket(): void;
+    get globalKeysToChromeKeysNames(): {
+        'NUMPAD 0': string;
+        'NUMPAD 1': string;
+        'NUMPAD 2': string;
+        'NUMPAD 3': string;
+        'NUMPAD 4': string;
+        'NUMPAD 5': string;
+        'NUMPAD 6': string;
+        'NUMPAD 7': string;
+        'NUMPAD 8': string;
+        'NUMPAD 9': string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalKeyboardListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalKeyboardListenerService>;
+}
+
+declare class KeyPressService {
+    shouldPreventMacroKeyPress(event: KeyboardEvent, macroKeysPress: number[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyPressService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeyPressService>;
+}
+
+declare class UtilsService {
+    private environmentConfig;
+    constructor(environmentConfig: EnvironmentConfig);
+    getDisplayedNameForMongoMethodByUserActivity(urlRequest: string): string | undefined;
+    fetchFiles(fileId: string, resourceType: string, bucket?: string): Promise<Response>;
+    initAudioFile(fileId: string, bucketName?: string, signal?: AbortSignal): Promise<File>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+}
+
+declare class AudioVisualizationService {
+    private audioVisualConfiguration;
+    constructor(audioVisualConfiguration: AudioVisualConfiguration);
+    clearCanvas(canvasCtx: CanvasRenderingContext2D, canvas: HTMLCanvasElement): void;
+    drawWaveform(ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement, audioBuffer: AudioBuffer, currentTime: number, duration: number): void;
+    private getChannelData;
+    /**
+     * Determine the canvas dimensions, using 3/4 of the canvas height for the waveform.
+     */
+    getCanvasDimensions(canvas: HTMLCanvasElement): {
+        width: number;
+        height: number;
+        centerY: number;
+    };
+    /**
+     * Calculate the current played bar index based on current time.
+     */
+    getPlayedBarIndex(width: number, barWidth: number, gap: number, currentTime: number, duration: number): number;
+    /**
+     * Determine the sample range (start and end indices) for a given bar.
+     */
+    getSampleRange(barIndex: number, samplesPerBar: number, totalSamples: number): {
+        startSample: number;
+        endSample: number;
+    };
+    /**
+     * Compute the maximum amplitude within the sample range for both channels.
+     */
+    computeMaxAmplitudes(leftChannelData: Float32Array, rightChannelData: Float32Array, startSample: number, endSample: number): {
+        leftMax: number;
+        rightMax: number;
+    };
+    /**
+     * Draw both the left (top) and right (bottom) bars with rounded corners.
+     */
+    drawBar(ctx: CanvasRenderingContext2D, x: number, centerY: number, leftBarHeight: number, rightBarHeight: number, isPlayed: boolean, barWidth: number, barRadius: number): void;
+    drawTimeLabels(canvasCtx: CanvasRenderingContext2D, canvas: HTMLCanvasElement, duration: number): void;
+    drawCurrentTimeLine(canvasCtx: CanvasRenderingContext2D, canvas: HTMLCanvasElement, currentTime: number, duration: number): void;
+    formatTime(seconds: number): string;
+    get barSettings(): {
+        barRadius: number;
+        barWidth: number;
+        gap: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudioVisualizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AudioVisualizationService>;
+}
+
+declare class AudioPlayerComponent implements OnInit, IMediaPlayer {
+    private visualizationService;
+    private globalKeyboardListener;
+    private keyPressService;
+    private utilsService;
+    private audioVisualConfiguration;
+    showVolumeSliders: boolean;
+    isPreview: boolean;
+    getTimeUpdate: number;
+    playbackSpeed: number;
+    isBlock: boolean;
+    currentTime: number;
+    isAudioPlaying: boolean;
+    width: number;
+    id: string;
+    audioFile: File;
+    mediaSettings: MediaSettings;
+    bucketName: string;
+    periodicCurrentTime: EventEmitter<number>;
+    isLoadingChange: EventEmitter<boolean>;
+    timingUpdateByRequest: EventEmitter<any>;
+    mediaSettingsUpdate: EventEmitter<any>;
+    audioCanvas: ElementRef<HTMLCanvasElement>;
+    slider: ElementRef<HTMLInputElement>;
+    audioContainer: ElementRef;
+    sourceNode: MediaElementAudioSourceNode;
+    audioElement: HTMLAudioElement;
+    audioContext: AudioContext;
+    audioBuffer: AudioBuffer;
+    rightGainNode: GainNode;
+    leftGainNode: GainNode;
+    isGlobalKeyboardBindingActive: boolean;
+    isFileLoaded: boolean;
+    isLoading: boolean;
+    sliderValue: number;
+    errorMessage: string;
+    rightVolume: number;
+    leftVolume: number;
+    duration: number;
+    eventListenersMap: {
+        ended: () => boolean;
+        loadeddata: () => void;
+        timeupdate: () => void;
+    };
+    destroySubject$: Subject<null>;
+    constructor(visualizationService: AudioVisualizationService, globalKeyboardListener: GlobalKeyboardListenerService, keyPressService: KeyPressService, utilsService: UtilsService, audioVisualConfiguration: AudioVisualConfiguration);
+    ngOnChanges(changes: SimpleChanges): Promise<void>;
+    private syncStateBasedOnMediaSettingsInput;
+    private resetAudio;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private globalKeyboardListenerInitiation;
+    private resizeCanvas;
+    private loadFile;
+    private initAudioBuffer;
+    private initializeAudioElement;
+    private audioLoadeddata;
+    private setupAudioNodes;
+    private updateWaveformProgress;
+    private formatCode;
+    onWindowResize(): void;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    private keysBinding;
+    get keysBindingToFunction(): {
+        numpad0: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad1: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad3: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad2: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad4: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad5: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad6: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad7: {
+            keyNumber: number;
+            function: () => void;
+        };
+        numpad9: {
+            keyNumber: number;
+            function: () => void;
+        };
+    };
+    _updateVolume(): void;
+    _onTogglePlay(): void;
+    _skipForward(seconds?: number): void;
+    private updateSliderBackground;
+    _skipBackward(seconds?: number): void;
+    private playAudio;
+    private startAudioPlayback;
+    private pauseAudio;
+    private solidPauseAudio;
+    _onCanvasClick(event: MouseEvent): void;
+    renderWaveform(): void;
+    _updatePlaybackSpeed(selectedSpeed?: number): void;
+    private updatePlaybackSpeed;
+    private emitMediaSettingsUpdate;
+    private removeAudioElementEventListeners;
+    get speedOptions(): number[];
+    get currentTimeLabel(): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudioPlayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AudioPlayerComponent, "herum-audio-player", never, { "showVolumeSliders": { "alias": "showVolumeSliders"; "required": false; }; "isPreview": { "alias": "isPreview"; "required": false; }; "getTimeUpdate": { "alias": "getTimeUpdate"; "required": false; }; "playbackSpeed": { "alias": "playbackSpeed"; "required": false; }; "isBlock": { "alias": "isBlock"; "required": false; }; "currentTime": { "alias": "currentTime"; "required": false; }; "isAudioPlaying": { "alias": "isAudioPlaying"; "required": false; }; "width": { "alias": "width"; "required": false; }; "id": { "alias": "id"; "required": false; }; "audioFile": { "alias": "audioFile"; "required": false; }; "mediaSettings": { "alias": "mediaSettings"; "required": false; }; "bucketName": { "alias": "bucketName"; "required": false; }; }, { "periodicCurrentTime": "periodicCurrentTime"; "isLoadingChange": "isLoadingChange"; "timingUpdateByRequest": "timingUpdateByRequest"; "mediaSettingsUpdate": "mediaSettingsUpdate"; }, never, never, false, never>;
+}
+
+declare class HerumMiniTableComponent {
+    view: "wide" | "narrow" | "herum-table";
+    height: "short" | "long";
+    rows: {
+        listPath: string[];
+        itemsPaths: {
+            paths: string[];
+            label: string | boolean;
+            type: 'bar' | 'text' | 'date' | 'checkbox' | 'toggle';
+        }[];
+    };
+    object: any;
+    onCellEdit: EventEmitter<any>;
+    items: any[];
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    getItems(object: any, pathParts: string[]): any;
+    updateItems(object: any, pathParts: string[], updatedValue: any): any[];
+    getCellItem(object: any, cell: {
+        paths: string[];
+        label: string;
+        type: string;
+    }): any;
+    private displayedDayCount;
+    _onPermissionChange(item: any, itemPath: any, permission: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumMiniTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumMiniTableComponent, "herum-mini-table", never, { "view": { "alias": "view"; "required": false; }; "height": { "alias": "height"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "object": { "alias": "object"; "required": false; }; }, { "onCellEdit": "onCellEdit"; }, never, never, false, never>;
+}
+
+declare class HerumHierarchyTreeComponent implements OnChanges {
+    private environmentConfig;
+    treeNode: TreeNode;
+    showAssignmentsDetails: boolean;
+    nodeMenuItems: NodeMenuItem<SystemTreeNodeData>[];
+    onMenuItemSelected: EventEmitter<any>;
+    onNodeSelected: EventEmitter<any>;
+    onCreateNewChildren: EventEmitter<any>;
+    topParent: TreeNode;
+    left: number;
+    top: number;
+    elementRef: ElementRef;
+    constructor(environmentConfig: EnvironmentConfig);
+    ngOnChanges(): void;
+    _onNodeSelected(node: TreeNode): void;
+    _displayNode(node: TreeNode): any;
+    isLastHierarchy(treeNode: TreeNode): boolean;
+    _onCreateNewStruct(node: TreeNode): void;
+    _onMenuItemSelected(item: NodeMenuItem<SystemTreeNodeData>): void;
+    get heightForVerticalView(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumHierarchyTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumHierarchyTreeComponent, "herum-hierarchy-tree", never, { "treeNode": { "alias": "treeNode"; "required": false; }; "showAssignmentsDetails": { "alias": "showAssignmentsDetails"; "required": false; }; "nodeMenuItems": { "alias": "nodeMenuItems"; "required": false; }; "left": { "alias": "left"; "required": false; }; "top": { "alias": "top"; "required": false; }; }, { "onMenuItemSelected": "onMenuItemSelected"; "onNodeSelected": "onNodeSelected"; "onCreateNewChildren": "onCreateNewChildren"; }, never, never, false, never>;
+}
+
+declare class RecursiveTreeComponent {
+    treeNode: TreeNode;
+    showAssignmentsDetails: boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecursiveTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RecursiveTreeComponent, "recursive-tree", never, { "treeNode": { "alias": "treeNode"; "required": false; }; "showAssignmentsDetails": { "alias": "showAssignmentsDetails"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumTextualVerticalTreeComponent implements OnInit {
+    treesNodes: TreeNode[];
+    selectedNode: TreeNode;
+    hierarchySvg: string;
+    resourceSvg: string;
+    selectedTypeToShow: string;
+    onNodeSelected: EventEmitter<any>;
+    constructor();
+    ngOnInit(): void;
+    _onStructSelection(treeNode: TreeNode): void;
+    _onExpandNode(treeNode: TreeNode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumTextualVerticalTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumTextualVerticalTreeComponent, "herum-textual-vertical-tree", never, { "treesNodes": { "alias": "treesNodes"; "required": false; }; "selectedNode": { "alias": "selectedNode"; "required": false; }; "hierarchySvg": { "alias": "hierarchySvg"; "required": false; }; "resourceSvg": { "alias": "resourceSvg"; "required": false; }; "selectedTypeToShow": { "alias": "selectedTypeToShow"; "required": false; }; }, { "onNodeSelected": "onNodeSelected"; }, never, never, false, never>;
+}
+
+declare class HerumDateTimePickerSelectComponent implements ControlValueAccessor {
+    private changeDetectorRef;
+    size: 'fit' | 'default' | 'big' | 'responsive' | 'button-size';
+    dropDownDirection: 'upwards' | 'downwards';
+    isDropDownInPositionFixed: boolean;
+    selectedDate: Date | DateRange<Date>;
+    rangeMode: boolean;
+    minDate: Date | undefined;
+    datePickerActiveColor: string;
+    datePickerHoverColor: string;
+    widthDatePicker: string;
+    showTimePicker: boolean;
+    showDatePicker: boolean;
+    showDateTimeInput: boolean;
+    showTimeSelect: boolean;
+    selectedTime: string | TimeRange;
+    showSeconds: boolean;
+    timePickerItemSize: string | undefined;
+    timePickerActiveColor: string;
+    timePickerHoverColor: string;
+    heightTimePicker: string;
+    showButtonText: boolean;
+    buttonMode: boolean;
+    dateTimeValueChange: EventEmitter<any>;
+    onClick(event: MouseEvent): void;
+    onResize(): void;
+    dropContainer: ElementRef;
+    dateTimeToDisplay: string;
+    buttonText: string;
+    dateTimeValue: DateTimePicker;
+    disabled: boolean;
+    isDropdownOpen: boolean;
+    narrowSelect: boolean;
+    componentId: string;
+    placeholder: string;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    _onToggleDropdown(): void;
+    _onSubmit(): void;
+    _onClear(): void;
+    _timeChange(time: string | TimeRange): void;
+    private handleRangeTimeChange;
+    _disableChange(disabled: boolean): void;
+    _dateChange(date: Date | DateRange<Date>, dateTimePickerEvent?: boolean): void;
+    private updateRangeTime;
+    private updateFullYearRangeDate;
+    private buildRangeDateTimeToDisplay;
+    private formateDate;
+    private extractTimeFromDate;
+    private setDateTimeToDisplay;
+    private updateTimeInDate;
+    private getPlaceholder;
+    private removeSecondsUnits;
+    private setDisabled;
+    private setRangeDate;
+    private setSelectedTimeInDateRange;
+    private resetSeconds;
+    private setRangeSelectedTime;
+    private closeDropdown;
+    onChange: (dateTimeValue: DateTimePicker) => void;
+    onTouched: () => void;
+    writeValue(value: Date | string | DateRange<Date>): void;
+    private setSelectedTimeByDate;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    get dateTimepickerDropdownId(): string;
+    get dropdownClasses(): string;
+    get _getDropdownStates(): "openUp" | "openDown" | "closeDown" | "closeUp";
+    get calendarImageSrc(): string;
+    get timePickerImageSrc(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumDateTimePickerSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumDateTimePickerSelectComponent, "herum-date-time-picker-select", never, { "size": { "alias": "size"; "required": false; }; "dropDownDirection": { "alias": "dropDownDirection"; "required": false; }; "isDropDownInPositionFixed": { "alias": "isDropDownInPositionFixed"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "rangeMode": { "alias": "rangeMode"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "datePickerActiveColor": { "alias": "datePickerActiveColor"; "required": false; }; "datePickerHoverColor": { "alias": "datePickerHoverColor"; "required": false; }; "widthDatePicker": { "alias": "widthDatePicker"; "required": false; }; "showTimePicker": { "alias": "showTimePicker"; "required": false; }; "showDatePicker": { "alias": "showDatePicker"; "required": false; }; "showDateTimeInput": { "alias": "showDateTimeInput"; "required": false; }; "showTimeSelect": { "alias": "showTimeSelect"; "required": false; }; "selectedTime": { "alias": "selectedTime"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "timePickerItemSize": { "alias": "timePickerItemSize"; "required": false; }; "timePickerActiveColor": { "alias": "timePickerActiveColor"; "required": false; }; "timePickerHoverColor": { "alias": "timePickerHoverColor"; "required": false; }; "heightTimePicker": { "alias": "heightTimePicker"; "required": false; }; "showButtonText": { "alias": "showButtonText"; "required": false; }; "buttonMode": { "alias": "buttonMode"; "required": false; }; }, { "dateTimeValueChange": "dateTimeValueChange"; }, never, never, false, never>;
+}
+
+declare class HerumTimeRangeSelectComponent {
+    showSeconds: boolean;
+    selectedTime: TimeRange;
+    timeChange: EventEmitter<any>;
+    startLabel: string;
+    endLabel: string;
+    _startTimeChange(startTime: string): void;
+    _endTimeChange(endTime: string): void;
+    private emitSelectedTimeRange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumTimeRangeSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumTimeRangeSelectComponent, "herum-time-range-select", never, { "showSeconds": { "alias": "showSeconds"; "required": false; }; "selectedTime": { "alias": "selectedTime"; "required": false; }; }, { "timeChange": "timeChange"; }, never, never, false, never>;
+}
+
+declare class AudioSliderComponent {
+    slider: ElementRef<HTMLInputElement>;
+    sliderValue: number;
+    maxValue: number;
+    color: string;
+    id: string;
+    sliderChange: EventEmitter<number>;
+    ngAfterViewInit(): void;
+    updateSliderBackground(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudioSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AudioSliderComponent, "audio-slider", never, { "sliderValue": { "alias": "sliderValue"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; "color": { "alias": "color"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "sliderChange": "sliderChange"; }, never, never, false, never>;
+}
+
+declare class AnswerNotesToTextChangesPipe implements PipeTransform {
+    transform(answerNotes: AnswerNote[]): TextChange[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnswerNotesToTextChangesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AnswerNotesToTextChangesPipe, "answerNotesToTextChanges", false>;
+}
+
+declare class QuizOpenAnswerQuestionComponent {
+    private answerNotesToTextChangesPipe;
+    previewMode: boolean;
+    question: Question;
+    userQuestion: UserQuestionData;
+    areAnswersRevealed: boolean;
+    areAnswersBlocked: boolean;
+    isCheckingMode: boolean;
+    selectedTextChange: TextChange;
+    freeTextCorrectAnswerChange: EventEmitter<string>;
+    notesChange: EventEmitter<any[]>;
+    freeTextCorrectAnswerControl: FormControl<string>;
+    notes: TextChange[];
+    destroySubject$: Subject<null>;
+    constructor(answerNotesToTextChangesPipe: AnswerNotesToTextChangesPipe);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    _notesChange(notes: TextChange[]): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuizOpenAnswerQuestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuizOpenAnswerQuestionComponent, "quiz-open-answer-question", never, { "previewMode": { "alias": "previewMode"; "required": false; }; "question": { "alias": "question"; "required": false; }; "userQuestion": { "alias": "userQuestion"; "required": false; }; "areAnswersRevealed": { "alias": "areAnswersRevealed"; "required": false; }; "areAnswersBlocked": { "alias": "areAnswersBlocked"; "required": false; }; "isCheckingMode": { "alias": "isCheckingMode"; "required": false; }; "selectedTextChange": { "alias": "selectedTextChange"; "required": false; }; }, { "freeTextCorrectAnswerChange": "freeTextCorrectAnswerChange"; "notesChange": "notesChange"; }, never, never, false, never>;
+}
+
+declare class HerumHighlightDirective {
+    private el;
+    private renderer;
+    highlightText: string | null | undefined;
+    highlightQuery: string | null | undefined;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnChanges(): void;
+    private escapeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumHighlightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HerumHighlightDirective, "[herumHighlight]", never, { "highlightText": { "alias": "highlightText"; "required": false; }; "highlightQuery": { "alias": "herumHighlight"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class InsuranceDialogComponent {
+    dialogRef: MatDialogRef<InsuranceDialogComponent>;
+    data: DialogConfig;
+    private environmentConfig;
+    constructor(dialogRef: MatDialogRef<InsuranceDialogComponent>, data: DialogConfig, environmentConfig: EnvironmentConfig);
+    _onSubmit(): void;
+    _onClose(): void;
+    get systemIdentifier(): string;
+    get isWarning(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsuranceDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsuranceDialogComponent, "app-insurance-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class HerumFilesViewerDialogComponent implements OnInit {
+    private dialogRef;
+    data: any;
+    fileData: FileData;
+    constructor(dialogRef: MatDialogRef<FileData>, data: any);
+    ngOnInit(): void;
+    _downloadFile(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumFilesViewerDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumFilesViewerDialogComponent, "herum-files-viewer-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class DialogsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogsModule, [typeof InsuranceDialogComponent, typeof HerumFilesViewerDialogComponent], [typeof i2.CommonModule, typeof i4.AtomsModule, typeof i4$1.PipesModule, typeof i6.MoleculesModule], [typeof InsuranceDialogComponent, typeof HerumFilesViewerDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogsModule>;
+}
+
+declare class CollegeLoaderComponent implements OnInit {
+    bars: any[];
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollegeLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollegeLoaderComponent, "college-loader", never, {}, {}, never, never, false, never>;
+}
+
+declare class UsersProfilePreviewComponent {
+    users: Partial<User>[];
+    title: string;
+    searchFields: (keyof User)[];
+    placeholder: string;
+    filteredUsers: Partial<User>[];
+    ngOnChanges(changes: SimpleChanges): void;
+    _filterUsers(freeText: string): void;
+    fallbackProfileImage(user: Partial<User>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsersProfilePreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UsersProfilePreviewComponent, "users-profile-preview", never, { "users": { "alias": "users"; "required": false; }; "title": { "alias": "title"; "required": false; }; "searchFields": { "alias": "searchFields"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumBreadcrumbsComponent {
+    items: IdentifiedEntity[];
+    itemToSet: IdentifiedEntity;
+    itemEmitter: EventEmitter<any[]>;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onClick(itemIndex: number, isLastItem: boolean): void;
+    private handleItemInput;
+    private updateCurrentItem;
+    private addItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumBreadcrumbsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumBreadcrumbsComponent, "herum-breadcrumbs", never, { "items": { "alias": "items"; "required": false; }; "itemToSet": { "alias": "itemToSet"; "required": false; }; }, { "itemEmitter": "itemEmitter"; }, never, never, false, never>;
+}
+
+declare class SliceBreadcrumbsPipe implements PipeTransform {
+    transform(items: IdentifiedEntity[], ...args: unknown[]): IdentifiedEntity[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliceBreadcrumbsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SliceBreadcrumbsPipe, "sliceBreadcrumbs", false>;
+}
+
+declare class HerumButtonComponent {
+    type: 'primary' | 'secondary' | 'ghost' | 'white';
+    color: 'regular' | 'error';
+    size: 'fit' | 'small' | 'medium' | 'medium-square' | 'big';
+    roundedCorners: 'up' | 'down' | 'default';
+    disabled: boolean;
+    isLoading: boolean;
+    name: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumButtonComponent, "herum-button", never, { "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "roundedCorners": { "alias": "roundedCorners"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class HerumChipComponent {
+    title: string;
+    isDeleteButtonNeeded: boolean;
+    isActive: boolean;
+    isMenuMode: boolean;
+    type: 'positive' | 'negative' | 'regular';
+    remove: EventEmitter<boolean>;
+    chipsActivation: EventEmitter<boolean>;
+    _onRemove(): void;
+    _onChipsSelect(): void;
+    get splittedTitle(): string;
+    get isTitleToBeSplitted(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumChipComponent, "herum-chip", never, { "title": { "alias": "title"; "required": false; }; "isDeleteButtonNeeded": { "alias": "isDeleteButtonNeeded"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "isMenuMode": { "alias": "isMenuMode"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "remove": "remove"; "chipsActivation": "chipsActivation"; }, never, never, false, never>;
+}
+
+declare class HerumCircularProgressBarComponent {
+    percentage: number;
+    fill: boolean;
+    size: 'default-size' | 'big-size';
+    firstGradient: string;
+    fillColor: string;
+    showPercentage: boolean;
+    displayedContent: number | string;
+    displayedContentColorMatchesGradientColor: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    getGradientStyle(): string;
+    get percentageText(): number | "-";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumCircularProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumCircularProgressBarComponent, "herum-circular-progress-bar", never, { "percentage": { "alias": "percentage"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "size": { "alias": "size"; "required": false; }; "firstGradient": { "alias": "firstGradient"; "required": false; }; "fillColor": { "alias": "fillColor"; "required": false; }; "showPercentage": { "alias": "showPercentage"; "required": false; }; "displayedContent": { "alias": "displayedContent"; "required": false; }; "displayedContentColorMatchesGradientColor": { "alias": "displayedContentColorMatchesGradientColor"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumDatePickerComponent {
+    private elementRef;
+    private dateAdapter;
+    private changeDetectorRef;
+    activeColor: string;
+    hoverColor: string;
+    minDate: Date;
+    rangeMode: boolean;
+    selectedDate: Date | DateRange<Date>;
+    dateChange: EventEmitter<Date | DateRange<Date>>;
+    calendar: MatCalendar<Date | DateRange<Date>>;
+    hostElement: HTMLElement;
+    startDate: Date;
+    endDate: Date | null;
+    matCalendarContainerHeight: number;
+    constructor(elementRef: ElementRef, dateAdapter: DateAdapter<Date>, changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    private setStyleProperties;
+    private handleSelectedDateChange;
+    ngAfterViewInit(): void;
+    private setMatCalendarContainerHeight;
+    _onSelectedDateChange(date: Date): void;
+    private handleSingleDateMode;
+    private handleRangeMode;
+    private setRangeDates;
+    _minDateFilter: (date: Date) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumDatePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumDatePickerComponent, "herum-date-picker", never, { "activeColor": { "alias": "activeColor"; "required": false; }; "hoverColor": { "alias": "hoverColor"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "rangeMode": { "alias": "rangeMode"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; }, { "dateChange": "dateChange"; }, never, never, false, never>;
+}
+
+declare class HerumDownloadFileComponent {
+    fileId: string;
+    filePath: string;
+    linkText: string;
+    downloadFile: EventEmitter<string>;
+    downloadFileElement: ElementRef;
+    ngAfterViewInit(): void;
+    _onDownloadFile(fileId: string): void;
+    get downloadFileSvgString(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumDownloadFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumDownloadFileComponent, "herum-download-file", never, { "fileId": { "alias": "fileId"; "required": false; }; "filePath": { "alias": "filePath"; "required": false; }; "linkText": { "alias": "linkText"; "required": false; }; }, { "downloadFile": "downloadFile"; }, never, never, false, never>;
+}
+
+declare class HerumEllipsisLoaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumEllipsisLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumEllipsisLoaderComponent, "herum-ellipsis-loader", never, {}, {}, never, never, false, never>;
+}
+
+declare class HerumIconLabelComponent {
+    iconPath: string;
+    isLoading: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumIconLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumIconLabelComponent, "herum-icon-label", never, { "iconPath": { "alias": "iconPath"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class HerumIndeterminateComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumIndeterminateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumIndeterminateComponent, "app-herum-indeterminate", never, {}, {}, never, never, false, never>;
+}
+
+declare class ConditionalFormControlNameDirective {
+    private el;
+    private renderer;
+    private ngControl;
+    set formControlName(value: string);
+    private controlName;
+    constructor(el: ElementRef, renderer: Renderer2, ngControl: NgControl);
+    ngOnInit(): void;
+    private updateFormControlName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionalFormControlNameDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConditionalFormControlNameDirective, "[appConditionalFormControlName]", never, { "formControlName": { "alias": "appConditionalFormControlName"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumInputFieldComponent implements OnInit, ControlValueAccessor {
+    private ngControl;
+    private cdr;
+    type: 'number' | 'text' | 'search' | 'textBox' | 'search-blur' | 'numeric-text' | 'password';
+    placeholder: string;
+    disabled: boolean;
+    isBlocked: boolean;
+    isValid: boolean;
+    errorMsg: string;
+    showErrorMsgGap: boolean;
+    inputValue: string;
+    isLoading: boolean;
+    id: string;
+    debounceTime: number;
+    minValue: number;
+    maxValue: number;
+    isBlurred: boolean;
+    touched: boolean;
+    ltrMode: boolean;
+    preventMacroKeysPressEvent: number[];
+    inputValueEmitter: EventEmitter<string | number>;
+    inputElement: ElementRef<HTMLInputElement>;
+    onKeyPress(event: KeyboardEvent): void;
+    onPaste(event: ClipboardEvent): void;
+    formControlName: string;
+    isPasswordVisible: boolean;
+    inputSubject$: Subject<string>;
+    destroySubject$: Subject<null>;
+    constructor(ngControl: NgControl, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    private initInputSubject$;
+    private setInputsByFormControl;
+    clearInput(): void;
+    _onInput(freeText: string): void;
+    private setNgControlRangeValidator;
+    private getRangeErrorMessage;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    _setBlurred(): void;
+    _onTogglePasswordVisibility(event?: MouseEvent): void;
+    get searchImageSvg(): string;
+    get whiteSearchImageSvg(): string;
+    get xImageSvg(): string;
+    get inputHtmlType(): string;
+    get passwordEyeSource(): string;
+    get isRequired(): boolean;
+    get shouldShowClearIcon(): boolean;
+    get shouldShowPasswordToggle(): boolean;
+    get shouldShowErrorMsg(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumInputFieldComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumInputFieldComponent, "herum-input-field", never, { "type": { "alias": "type"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isBlocked": { "alias": "isBlocked"; "required": false; }; "isValid": { "alias": "isValid"; "required": false; }; "errorMsg": { "alias": "errorMsg"; "required": false; }; "showErrorMsgGap": { "alias": "showErrorMsgGap"; "required": false; }; "inputValue": { "alias": "inputValue"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "id": { "alias": "id"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; "minValue": { "alias": "minValue"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; "isBlurred": { "alias": "isBlurred"; "required": false; }; "touched": { "alias": "touched"; "required": false; }; "ltrMode": { "alias": "ltrMode"; "required": false; }; "preventMacroKeysPressEvent": { "alias": "preventMacroKeysPressEvent"; "required": false; }; }, { "inputValueEmitter": "inputValueEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumLogoComponent {
+    logoTextSize: 'bigSize' | 'defaultSize';
+    logoTextColor: 'primaryColor' | 'secondaryColor';
+    logoText: string;
+    get logoTextWidth(): "default-text-size-width" | "big-text-size-width";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumLogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumLogoComponent, "herum-logo", never, { "logoTextSize": { "alias": "logoTextSize"; "required": false; }; "logoTextColor": { "alias": "logoTextColor"; "required": false; }; "logoText": { "alias": "logoText"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumMultiSelectComponent implements ControlValueAccessor {
+    onClick(event: MouseEvent): void;
+    placeholder: string;
+    options: IdentifiedEntity[];
+    titledOptionsList: {
+        title: string;
+        options: IdentifiedEntity[];
+    }[];
+    recursiveTitledOption: RecursiveTitledOption[] | RecursiveTitledOption;
+    selectedOptionsInput: IdentifiedEntity[];
+    maxChips: number;
+    disabled: boolean;
+    size: 'fit' | 'default' | 'responsive';
+    isDropDownInPositionFixed: boolean;
+    dropDownDirection: 'upwards' | 'downwards';
+    isMultiHeads: boolean;
+    selectedOptions: EventEmitter<any[]>;
+    selectedRecursiveOptions: EventEmitter<any>;
+    filterInput: HerumInputFieldComponent;
+    dropContainer: ElementRef;
+    filteredOptions: IdentifiedEntity[];
+    filteredTitledOptionsList: {
+        title: string;
+        options: IdentifiedEntity[];
+    }[];
+    selectedOptionsValue: IdentifiedEntity[];
+    isDropdownOpen: boolean;
+    isShowAll: boolean;
+    currentDropdownId: string;
+    destroySubject$: Subject<null>;
+    componentId: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    _onStopPropagation(event: MouseEvent): void;
+    _onFilterDropDown(text: string): void;
+    private setFilteredOptionsTypes;
+    private getFilteredOptions;
+    private getFilteredList;
+    _select(option: IdentifiedEntity): void;
+    _selectRecursive(selectedRecursiveOptions: RecursiveTitledOption): void;
+    private removeSelectedOption;
+    getLimitedList(): any[];
+    _getHiddenOptions(): string;
+    showAll(): void;
+    isOptionSelected(option: IdentifiedEntity): any;
+    toggleDropdown(): void;
+    closeDropdown(event: MouseEvent): void;
+    private resetFiltering;
+    get dropdownClasses(): string;
+    hasNoResults(): boolean;
+    get optionsLength(): number;
+    get _getDropdownStates(): "openUp" | "openDown" | "closeDown" | "closeUp";
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(selectedOptionsValue: IdentifiedEntity[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    showErrors(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumMultiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumMultiSelectComponent, "herum-multi-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "options": { "alias": "options"; "required": false; }; "titledOptionsList": { "alias": "titledOptionsList"; "required": false; }; "recursiveTitledOption": { "alias": "recursiveTitledOption"; "required": false; }; "selectedOptionsInput": { "alias": "selectedOptionsInput"; "required": false; }; "maxChips": { "alias": "maxChips"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "isDropDownInPositionFixed": { "alias": "isDropDownInPositionFixed"; "required": false; }; "dropDownDirection": { "alias": "dropDownDirection"; "required": false; }; "isMultiHeads": { "alias": "isMultiHeads"; "required": false; }; }, { "selectedOptions": "selectedOptions"; "selectedRecursiveOptions": "selectedRecursiveOptions"; }, never, never, false, never>;
+}
+
+declare class HerumNarrowCollectionMenuItemComponent {
+    index: string;
+    item: {};
+    itemState: {};
+    itemEmitter: EventEmitter<any>;
+    isAvailable: boolean;
+    isActive: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onSelectItem(): void;
+    setItemState(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumNarrowCollectionMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumNarrowCollectionMenuItemComponent, "herum-narrow-collection-menu-item", never, { "index": { "alias": "index"; "required": false; }; "item": { "alias": "item"; "required": false; }; "itemState": { "alias": "itemState"; "required": false; }; }, { "itemEmitter": "itemEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumNoResultMessageComponent {
+    mainTitle: string;
+    secondaryTitle: string;
+    alignItems: 'center' | 'right';
+    iconSize: 'small' | 'big';
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumNoResultMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumNoResultMessageComponent, "herum-no-result-message", never, { "mainTitle": { "alias": "mainTitle"; "required": false; }; "secondaryTitle": { "alias": "secondaryTitle"; "required": false; }; "alignItems": { "alias": "alignItems"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumOptionsListComponent {
+    options: IdentifiedEntity[];
+    selectedOptions: IdentifiedEntity[];
+    isContentInsideExpendablePanel: boolean;
+    isInternalMode: boolean;
+    selectedOptionsEmitter: EventEmitter<any>;
+    _onSelect(option: IdentifiedEntity): void;
+    isOptionSelected(option: IdentifiedEntity): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumOptionsListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumOptionsListComponent, "herum-options-list", never, { "options": { "alias": "options"; "required": false; }; "selectedOptions": { "alias": "selectedOptions"; "required": false; }; "isContentInsideExpendablePanel": { "alias": "isContentInsideExpendablePanel"; "required": false; }; "isInternalMode": { "alias": "isInternalMode"; "required": false; }; }, { "selectedOptionsEmitter": "selectedOptionsEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumPaginatorComponent {
+    private changeDetectorRef;
+    numberOfSlots: number;
+    elementsToSlice: Array<unknown>;
+    numberOfElementsInPage: number;
+    currentPage: number;
+    totalPages: number;
+    showArrows: boolean;
+    slicerMode: boolean;
+    slicedElements: EventEmitter<unknown[]>;
+    currentPageChange: EventEmitter<number>;
+    paginatorRenderChange: EventEmitter<any>;
+    element: ElementRef;
+    visiblePages: Array<number | string>;
+    startEllipsisPosition: number;
+    endEllipsisPosition: number;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    private showArrowsValidation;
+    private numberOfSlotsValidation;
+    _onChangePage(page: number | string): void;
+    private updateVisiblePages;
+    private shouldShowAllPages;
+    private displayAllPages;
+    private addFirstPage;
+    private addStartEllipsis;
+    private addMiddlePagesSlots;
+    private calculateMiddlePageSlots;
+    private calculateAvailableMiddleSlots;
+    private expandMiddleRange;
+    private shrinkMiddleRange;
+    private addEndEllipsis;
+    private addLastPage;
+    private emitElementsPerCurrentPage;
+    private isValidPageNumber;
+    _isNumber(value: any): boolean;
+    get chevronIcon(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumPaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumPaginatorComponent, "herum-paginator", never, { "numberOfSlots": { "alias": "numberOfSlots"; "required": false; }; "elementsToSlice": { "alias": "elementsToSlice"; "required": false; }; "numberOfElementsInPage": { "alias": "numberOfElementsInPage"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "totalPages": { "alias": "totalPages"; "required": false; }; "showArrows": { "alias": "showArrows"; "required": false; }; "slicerMode": { "alias": "slicerMode"; "required": false; }; }, { "slicedElements": "slicedElements"; "currentPageChange": "currentPageChange"; "paginatorRenderChange": "paginatorRenderChange"; }, never, never, false, never>;
+}
+
+declare class HerumPanelLinksComponent {
+    selectedLink: IdentifiedEntity;
+    links: IdentifiedEntity[];
+    linkEmitter: EventEmitter<any>;
+    _onClick(link: IdentifiedEntity): void;
+    _isActiveLink(linkId: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumPanelLinksComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumPanelLinksComponent, "herum-panel-links", never, { "selectedLink": { "alias": "selectedLink"; "required": false; }; "links": { "alias": "links"; "required": false; }; }, { "linkEmitter": "linkEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumProgressBarComponent {
+    percentage: number;
+    invalidPercentage: number;
+    showPercentage: boolean;
+    percentagePosition: string;
+    type: 'gradient' | 'solid';
+    size: 'tight' | 'regular';
+    color: string;
+    borderRadius: "none" | "right" | "left" | "both";
+    total: string;
+    showBorder: boolean;
+    thickness: 'thin' | 'thick';
+    getPercentageFormat(): string;
+    get invalidPercentageCalculation(): number;
+    get isInfinity(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumProgressBarComponent, "herum-progress-bar", never, { "percentage": { "alias": "percentage"; "required": false; }; "invalidPercentage": { "alias": "invalidPercentage"; "required": false; }; "showPercentage": { "alias": "showPercentage"; "required": false; }; "percentagePosition": { "alias": "percentagePosition"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "total": { "alias": "total"; "required": false; }; "showBorder": { "alias": "showBorder"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumQuizHeaderItemComponent {
+    index: string;
+    item: {};
+    itemState: {};
+    itemEmitter: EventEmitter<any>;
+    _onSelectItem(index: string): void;
+    getItemClass(itemState: {}): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumQuizHeaderItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumQuizHeaderItemComponent, "herum-quiz-header-item", never, { "index": { "alias": "index"; "required": false; }; "item": { "alias": "item"; "required": false; }; "itemState": { "alias": "itemState"; "required": false; }; }, { "itemEmitter": "itemEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumRecursiveHierarchyOptionsListComponent {
+    options: IdentifiedEntity[];
+    selectedOptions: IdentifiedEntity[];
+    recursiveTitledOption: RecursiveTitledOption;
+    selectedOptionsEmitter: EventEmitter<any>;
+    selectedRecursiveOptionsEmitter: EventEmitter<any>;
+    _onSelect(option: RecursiveTitledOption): void;
+    _isOptionSelected(option: IdentifiedEntity): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumRecursiveHierarchyOptionsListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumRecursiveHierarchyOptionsListComponent, "herum-recursive-hierarchy-options-list", never, { "options": { "alias": "options"; "required": false; }; "selectedOptions": { "alias": "selectedOptions"; "required": false; }; "recursiveTitledOption": { "alias": "recursiveTitledOption"; "required": false; }; }, { "selectedOptionsEmitter": "selectedOptionsEmitter"; "selectedRecursiveOptionsEmitter": "selectedRecursiveOptionsEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumSelectComponent implements ControlValueAccessor {
+    options: IdentifiedEntity[];
+    displayBy: string;
+    placeholder: string;
+    selectedOption: IdentifiedEntity;
+    disabled: boolean;
+    isDropDownInPositionFixed: boolean;
+    iconPath: string;
+    isAutoComplete: boolean;
+    title: string;
+    size: 'min' | 'fit' | 'default' | 'big' | 'responsive' | 'fill-container';
+    displayLoadingMode: boolean;
+    isLoadingInput: boolean;
+    dropDownDirection: 'upwards' | 'downwards';
+    filterPlaceholder: string;
+    debounceTime: number;
+    selectedOptionEmitter: EventEmitter<any>;
+    filterTextEmitter: EventEmitter<string>;
+    filterInput: HerumInputFieldComponent;
+    dropContainer: ElementRef;
+    dropdown: ElementRef;
+    onClick(event: MouseEvent): void;
+    narrowSelect: boolean;
+    onResize(event: Event): void;
+    filteredOptions: IdentifiedEntity[];
+    isDropdownOpen: boolean;
+    destroySubject$: Subject<null>;
+    componentId: string;
+    get errorOccurred(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    _onSelectOption(selectedOption: IdentifiedEntity): void;
+    _onStopPropagation(event: MouseEvent): void;
+    _onFilterDropDown(text: string): void;
+    toggleDropdown(): void;
+    closeDropdown(event: MouseEvent): void;
+    isSelectedOption(option: IdentifiedEntity): boolean;
+    private resetFiltering;
+    _isLoading(): boolean;
+    onChange: (selectedOption: IdentifiedEntity) => void;
+    onTouched: () => void;
+    writeValue(selectedOption: IdentifiedEntity): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    ngOnDestroy(): void;
+    get dropdownClasses(): string;
+    get _getDropdownStates(): "openUp" | "openDown" | "closeDown" | "closeUp";
+    get skeletonArray(): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumSelectComponent, "herum-select", never, { "options": { "alias": "options"; "required": false; }; "displayBy": { "alias": "displayBy"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "selectedOption": { "alias": "selectedOption"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isDropDownInPositionFixed": { "alias": "isDropDownInPositionFixed"; "required": false; }; "iconPath": { "alias": "iconPath"; "required": false; }; "isAutoComplete": { "alias": "isAutoComplete"; "required": false; }; "title": { "alias": "title"; "required": false; }; "size": { "alias": "size"; "required": false; }; "displayLoadingMode": { "alias": "displayLoadingMode"; "required": false; }; "isLoadingInput": { "alias": "isLoadingInput"; "required": false; }; "dropDownDirection": { "alias": "dropDownDirection"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; }, { "selectedOptionEmitter": "selectedOptionEmitter"; "filterTextEmitter": "filterTextEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumSliderComponent {
+    size: string;
+    maxSliderValue: number;
+    currentSliderValue: number;
+    initSlider: boolean;
+    l: any;
+    isDraggingEmitter: EventEmitter<boolean>;
+    updatedSliderValue: EventEmitter<number>;
+    slider: ElementRef;
+    progress: number;
+    isDragging: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onUpdateProgressMouseClicked(event: MouseEvent): void;
+    _onUpdateProgressMouseDown(event: MouseEvent): void;
+    calculateSliderProgress(): number;
+    isSmallSizeSlider(): boolean;
+    private updateSliderOnMouseEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumSliderComponent, "herum-slider", never, { "size": { "alias": "size"; "required": false; }; "maxSliderValue": { "alias": "maxSliderValue"; "required": false; }; "currentSliderValue": { "alias": "currentSliderValue"; "required": false; }; "initSlider": { "alias": "initSlider"; "required": false; }; }, { "isDraggingEmitter": "isDraggingEmitter"; "updatedSliderValue": "updatedSliderValue"; }, never, never, false, never>;
+}
+
+declare class HerumSpinnerComponent {
+    size: 'default-size';
+    borderColor: 'default-border-color';
+    borderWidth: 'default-border-width';
+    borderTopColor: 'default-border-top-color';
+    shape: 'circle';
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumSpinnerComponent, "herum-spinner", never, { "size": { "alias": "size"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; "borderWidth": { "alias": "borderWidth"; "required": false; }; "borderTopColor": { "alias": "borderTopColor"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumSwitchComponent implements ControlValueAccessor {
+    isChecked: boolean;
+    disabled: boolean;
+    checked: EventEmitter<boolean>;
+    _onCheck(): void;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(isChecked: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumSwitchComponent, "herum-switch", never, { "isChecked": { "alias": "isChecked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "checked": "checked"; }, never, never, false, never>;
+}
+
+declare class HerumTextAreaComponent implements ControlValueAccessor {
+    placeholder: string;
+    disabled: boolean;
+    formControlName: string;
+    isValid: boolean;
+    isLoading: boolean;
+    errorMsg: string;
+    showErrorMsgGap: boolean;
+    id: string;
+    preventMacroKeysPressEvent: number[];
+    heightMode: 'regular' | 'max';
+    fontSize: number;
+    inputValue: string;
+    maxLength: number;
+    inputValueEmitter: EventEmitter<string>;
+    onKeyPress(event: KeyboardEvent): void;
+    textarea: ElementRef;
+    touched: boolean;
+    isBlurred: boolean;
+    ngAfterViewInit(): void;
+    _onClearTextArea(): void;
+    _onInput(event: string): void;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    showErrors(): void;
+    setBlurred(): void;
+    get xSvg(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumTextAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumTextAreaComponent, "herum-text-area", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "isValid": { "alias": "isValid"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "errorMsg": { "alias": "errorMsg"; "required": false; }; "showErrorMsgGap": { "alias": "showErrorMsgGap"; "required": false; }; "id": { "alias": "id"; "required": false; }; "preventMacroKeysPressEvent": { "alias": "preventMacroKeysPressEvent"; "required": false; }; "heightMode": { "alias": "heightMode"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "inputValue": { "alias": "inputValue"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; }, { "inputValueEmitter": "inputValueEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumTimePickerComponent {
+    private elementRef;
+    private changeDetectorRef;
+    activeColor: string;
+    hoverColor: string;
+    itemSize: string;
+    selectedTime: string;
+    showSeconds: boolean;
+    timeChange: EventEmitter<string>;
+    hoursColumn: ElementRef;
+    minutesColumn: ElementRef;
+    secondsColumn: ElementRef;
+    hours: string[];
+    minutes: string[];
+    seconds: string[];
+    selectedHour: number;
+    selectedMinute: number;
+    selectedSecond: number;
+    hostElement: HTMLElement;
+    columnHeight: string;
+    constructor(elementRef: ElementRef, changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    _onSelectHour(index: number): void;
+    _onSelectMinute(index: number): void;
+    _onSelectSecond(index: number): void;
+    private emitSelectedTime;
+    private setTime;
+    private formatTime;
+    private scrollToSelectedTime;
+    private handleScrollToSelectedTime;
+    private calculateColumnHeight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumTimePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumTimePickerComponent, "herum-time-picker", never, { "activeColor": { "alias": "activeColor"; "required": false; }; "hoverColor": { "alias": "hoverColor"; "required": false; }; "itemSize": { "alias": "itemSize"; "required": false; }; "selectedTime": { "alias": "selectedTime"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; }, { "timeChange": "timeChange"; }, never, never, false, never>;
+}
+
+declare class HerumToggleButtonComponent implements ControlValueAccessor {
+    options: string[];
+    selectedOption: string;
+    disabled: boolean;
+    onSelectedOption: EventEmitter<string>;
+    selectedOptionIndex: number | undefined;
+    ngOnChanges(changes: SimpleChanges): void;
+    toggleOption(selectedOptionIndex: number): void;
+    isOptionSelected(selectedOptionIndex: number): boolean;
+    isBorderNeeded(elementIndex: number): boolean;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(selectedOption: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumToggleButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumToggleButtonComponent, "herum-toggle-button", never, { "options": { "alias": "options"; "required": false; }; "selectedOption": { "alias": "selectedOption"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelectedOption": "onSelectedOption"; }, never, never, false, never>;
+}
+
+declare class HerumUploadFileComponent implements ControlValueAccessor {
+    private parentForm;
+    size: 'default' | 'responsive';
+    placeholder: string;
+    isDirectoryMode: boolean;
+    allowedFileTypes: string[];
+    selectedFile: FileData;
+    formControlName: string;
+    isEditMode: boolean;
+    uploadFile: EventEmitter<File[]>;
+    fileInput: ElementRef;
+    files: File[];
+    uploadName: string;
+    filesSuffixes: {
+        [key: string]: string;
+    };
+    fileSuffix: string;
+    isValidirectory: boolean;
+    hasTouched: boolean;
+    uploadFileSvg: string;
+    constructor(parentForm: ControlContainer);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    _onPreventDefault(event: DragEvent): void;
+    _onDrop(event: DragEvent): void;
+    _onUploadFile(files: File[]): void;
+    private setExistingFile;
+    private isFileTypeAllowed;
+    private directoryValidation;
+    private getIconPath;
+    _onRemoveFiles(event: MouseEvent): void;
+    _onCancelUploadFile(): void;
+    getAcceptValue(allowedFileTypes: string[]): string;
+    _isTruncatedTitleElement(element: HTMLElement): boolean;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(value: any): void;
+    private resetData;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    get directoryName(): string;
+    get formControl(): i40.AbstractControl<any, any, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumUploadFileComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumUploadFileComponent, "herum-upload-file", never, { "size": { "alias": "size"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "isDirectoryMode": { "alias": "isDirectoryMode"; "required": false; }; "allowedFileTypes": { "alias": "allowedFileTypes"; "required": false; }; "selectedFile": { "alias": "selectedFile"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "isEditMode": { "alias": "isEditMode"; "required": false; }; }, { "uploadFile": "uploadFile"; }, never, never, false, never>;
+}
+
+declare class HerumVideoSelectComponent implements OnInit, ControlValueAccessor {
+    currentVideoSpeed: number;
+    options: number[];
+    selectedOptionEmitter: EventEmitter<number>;
+    selectedOption: number;
+    selectedOptionIndexValue: number;
+    isDropupOpen: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    _onToggleDropup(): void;
+    closeDropup(event: MouseEvent): void;
+    selectOption(optionIndex: number): void;
+    isSelectedOption(optionIndex: number): boolean;
+    show(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumVideoSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumVideoSelectComponent, "herum-video-select", never, { "currentVideoSpeed": { "alias": "currentVideoSpeed"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "selectedOptionEmitter": "selectedOptionEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumRadioButtonComponent implements ControlValueAccessor {
+    private environmentConfig;
+    options: IdentifiedEntity[];
+    isValid: boolean;
+    errorMsg: string;
+    isVertical: boolean;
+    selectOptionEmitter: EventEmitter<string>;
+    isBlocked: boolean;
+    type: 'checked' | 'error' | 'disabled' | 'completed';
+    selectedOption: string;
+    additionalOptionsText: string[];
+    showAdditionalOptionsText: boolean;
+    secondarySelectedOption: IdentifiedEntity;
+    selectedOptionId: string;
+    isSelectedOptionFocused: boolean;
+    isOptionFocused: boolean;
+    focusedIdOption: string;
+    constructor(environmentConfig: EnvironmentConfig);
+    ngOnChanges(changes: SimpleChanges): void;
+    _onSelect(option: IdentifiedEntity): void;
+    getRadioButtonClasses(id: string): string;
+    private setAllButtonsToDisabled;
+    private setSelectedButton;
+    getRadioButtonInnerCircleClasses(id: string): string;
+    _isRadioButtonFocused(id: string, value: boolean): void;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    writeValue(value: {
+        type: any;
+        id: string;
+        isBlocked: boolean;
+    }): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumRadioButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumRadioButtonComponent, "herum-radio-button", never, { "options": { "alias": "options"; "required": false; }; "isValid": { "alias": "isValid"; "required": false; }; "errorMsg": { "alias": "errorMsg"; "required": false; }; "isVertical": { "alias": "isVertical"; "required": false; }; "isBlocked": { "alias": "isBlocked"; "required": false; }; "type": { "alias": "type"; "required": false; }; "selectedOption": { "alias": "selectedOption"; "required": false; }; "additionalOptionsText": { "alias": "additionalOptionsText"; "required": false; }; "showAdditionalOptionsText": { "alias": "showAdditionalOptionsText"; "required": false; }; "secondarySelectedOption": { "alias": "secondarySelectedOption"; "required": false; }; }, { "selectOptionEmitter": "selectOptionEmitter"; }, never, never, false, never>;
+}
+
+type MenuItemWithDisabled = MenuItem & {
+    disabled: boolean;
+    disabledTooltip?: string;
+};
+declare class RoundedVerticalMenuComponent implements OnInit, OnChanges {
+    menuItems: MenuItemWithDisabled[];
+    currentItem?: MenuItemWithDisabled;
+    currentUser: User;
+    itemSelected: EventEmitter<any>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onSelectItem(item: MenuItemWithDisabled): void;
+    private updateDisabledMenuItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoundedVerticalMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RoundedVerticalMenuComponent, "rounded-vertical-menu", never, { "menuItems": { "alias": "menuItems"; "required": false; }; "currentItem": { "alias": "currentItem"; "required": false; }; "currentUser": { "alias": "currentUser"; "required": false; }; }, { "itemSelected": "itemSelected"; }, never, never, false, never>;
+}
+
+declare class TrackTextChangesNotesComponent {
+    textChanges: TextChange[];
+    enableDeleteNote: boolean;
+    deleteNoteChange: EventEmitter<any[]>;
+    hoverNote: EventEmitter<any>;
+    noteTypesToDisplay: string[];
+    ngOnChanges(changes: SimpleChanges): void;
+    private setNoteTypesToDisplay;
+    _onDeleteTextChange(textChangeToDelete: TextChange): void;
+    _onHoverNote(hoveredTextChange: TextChange): void;
+    _trackNote(index: number, textChange: TextChange): any;
+    get deleteSvgString(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackTextChangesNotesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TrackTextChangesNotesComponent, "track-text-changes-notes", never, { "textChanges": { "alias": "textChanges"; "required": false; }; "enableDeleteNote": { "alias": "enableDeleteNote"; "required": false; }; }, { "deleteNoteChange": "deleteNoteChange"; "hoverNote": "hoverNote"; }, never, never, false, never>;
+}
+
+declare class UserProfileImageComponent {
+    imageSize: 'image-default-size' | 'image-small-size' | 'responsive';
+    mode: 'vertical' | 'horizontal';
+    user: User | UserPreview;
+    isLoadingUser: boolean;
+    isUserClickAble: boolean;
+    userClicked: EventEmitter<any>;
+    imagePath: string;
+    isLoadingImage: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onUserClicked(): void;
+    _useFallbackProfileImage(event: Event): void;
+    _loadComplete(): void;
+    get userProfileImage(): any;
+    get fallbackProfileImage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserProfileImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserProfileImageComponent, "user-profile-image", never, { "imageSize": { "alias": "imageSize"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "user": { "alias": "user"; "required": false; }; "isLoadingUser": { "alias": "isLoadingUser"; "required": false; }; "isUserClickAble": { "alias": "isUserClickAble"; "required": false; }; }, { "userClicked": "userClicked"; }, never, ["*"], false, never>;
+}
+
+declare class AtomsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AtomsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AtomsModule, [typeof CollegeLoaderComponent, typeof UsersProfilePreviewComponent, typeof HerumBreadcrumbsComponent, typeof SliceBreadcrumbsPipe, typeof HerumButtonComponent, typeof HerumCheckboxComponent, typeof HerumChipComponent, typeof HerumCircularProgressBarComponent, typeof HerumDatePickerComponent, typeof HerumDownloadFileComponent, typeof HerumEllipsisLoaderComponent, typeof HerumIconLabelComponent, typeof HerumIndeterminateComponent, typeof ConditionalFormControlNameDirective, typeof HerumInputFieldComponent, typeof HerumLogoComponent, typeof HerumMultiSelectComponent, typeof HerumNarrowCollectionMenuItemComponent, typeof HerumNoResultMessageComponent, typeof HerumOptionsListComponent, typeof HerumPaginatorComponent, typeof HerumPanelLinksComponent, typeof HerumProgressBarComponent, typeof HerumQuizHeaderItemComponent, typeof HerumRecursiveHierarchyOptionsListComponent, typeof HerumSelectComponent, typeof HerumSliderComponent, typeof HerumSpinnerComponent, typeof HerumSwitchComponent, typeof HerumTextAreaComponent, typeof HerumTimePickerComponent, typeof HerumToggleButtonComponent, typeof HerumUploadFileComponent, typeof HerumVideoSelectComponent, typeof HerumRadioButtonComponent, typeof RoundedVerticalMenuComponent, typeof TrackTextChangesNotesComponent, typeof UserProfileImageComponent], [typeof i2.CommonModule, typeof i40.ReactiveFormsModule, typeof i40.FormsModule, typeof i41.MatMenuModule, typeof i42.ClipboardModule, typeof i43.MatAutocompleteModule, typeof i44.MatChipsModule, typeof i45.MatFormFieldModule, typeof i46.MatTooltipModule, typeof i47.MatInputModule, typeof i48.MatSelectModule, typeof i49.MatIconModule, typeof i50.MatCheckboxModule, typeof i51.MatSliderModule, typeof i52.DragDropModule, typeof i53.MatDatepickerModule, typeof i54.MatNativeDateModule, typeof i4$1.PipesModule], [typeof CollegeLoaderComponent, typeof UsersProfilePreviewComponent, typeof HerumBreadcrumbsComponent, typeof SliceBreadcrumbsPipe, typeof HerumButtonComponent, typeof HerumCheckboxComponent, typeof HerumChipComponent, typeof HerumCircularProgressBarComponent, typeof HerumDatePickerComponent, typeof HerumDownloadFileComponent, typeof HerumEllipsisLoaderComponent, typeof HerumIconLabelComponent, typeof HerumIndeterminateComponent, typeof ConditionalFormControlNameDirective, typeof HerumInputFieldComponent, typeof HerumLogoComponent, typeof HerumMultiSelectComponent, typeof HerumNarrowCollectionMenuItemComponent, typeof HerumNoResultMessageComponent, typeof HerumOptionsListComponent, typeof HerumPaginatorComponent, typeof HerumPanelLinksComponent, typeof HerumProgressBarComponent, typeof HerumQuizHeaderItemComponent, typeof HerumRecursiveHierarchyOptionsListComponent, typeof HerumSelectComponent, typeof HerumSliderComponent, typeof HerumSpinnerComponent, typeof HerumSwitchComponent, typeof HerumTextAreaComponent, typeof HerumTimePickerComponent, typeof HerumToggleButtonComponent, typeof HerumUploadFileComponent, typeof HerumVideoSelectComponent, typeof HerumRadioButtonComponent, typeof RoundedVerticalMenuComponent, typeof TrackTextChangesNotesComponent, typeof UserProfileImageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AtomsModule>;
+}
+
+declare class SafePipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(url: any): _angular_platform_browser.SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", false>;
+}
+
+declare class CollectionSubscriptionToCollectionBasePipe implements PipeTransform {
+    transform(collectionSubscription: CollectionSubscription, ...args: unknown[]): CollectionBase;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollectionSubscriptionToCollectionBasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CollectionSubscriptionToCollectionBasePipe, "collectionSubscriptionToCollectionBase", false>;
+}
+
+declare class CollectionToCollectionBasePipe implements PipeTransform {
+    transform(collection: Collection, ...args: unknown[]): CollectionBase;
+    transformMulti(collections: Collection[]): CollectionBase[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollectionToCollectionBasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CollectionToCollectionBasePipe, "collectionToCollectionBase", false>;
+}
+
+declare class SafeHtmlPipe implements PipeTransform {
+    private sanitized;
+    constructor(sanitized: DomSanitizer);
+    transform(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", false>;
+}
+
+declare class ResourceSubscriptionToResourcePipe implements PipeTransform {
+    transform(resourceSubscription: any, ...args: unknown[]): ModifiedResource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceSubscriptionToResourcePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ResourceSubscriptionToResourcePipe, "resourceSubscriptionToResource", false>;
+}
+
+declare class ResourceToResourceSubscriptionPipe implements PipeTransform {
+    transform(resource: ModifiedResource, ...args: unknown[]): ResourceSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceToResourceSubscriptionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ResourceToResourceSubscriptionPipe, "resourceToResourceSubscription", false>;
+}
+
+declare class EllipsisPipe implements PipeTransform {
+    transform(value: string, element: HTMLElement, numberOfRows?: number): string;
+    private handleMultiRows;
+    private ellipsis;
+    private getElementWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EllipsisPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EllipsisPipe, "ellipsis", false>;
+}
+
+declare class UserIdentifiedEntitiesToBackendModelsPipe implements PipeTransform {
+    transform(user: User): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserIdentifiedEntitiesToBackendModelsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UserIdentifiedEntitiesToBackendModelsPipe, "userIdentifiedEntitiesToBackendModels", false>;
+}
+
+declare class StringArrayToSignUpFieldArrayPipe implements PipeTransform {
+    transform(fields: string[] | null | undefined): SignUpField[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<StringArrayToSignUpFieldArrayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StringArrayToSignUpFieldArrayPipe, "stringArrayToSignUpFieldArray", false>;
+}
+
+declare class ToIntegerPipe implements PipeTransform {
+    transform(number: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToIntegerPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToIntegerPipe, "toInteger", false>;
+}
+
+declare class DisplayedSubmissionsCounterPipe implements PipeTransform {
+    transform(resource: Resource, quizData: QuizData, areAnswersBlocked?: boolean): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisplayedSubmissionsCounterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DisplayedSubmissionsCounterPipe, "displayedSubmissionsCounter", false>;
+}
+
+declare class PipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, [typeof SafePipe, typeof CollectionSubscriptionToCollectionBasePipe, typeof CollectionToCollectionBasePipe, typeof SafeHtmlPipe, typeof ResourceSubscriptionToResourcePipe, typeof ResourceToResourceSubscriptionPipe, typeof EllipsisPipe, typeof UserIdentifiedEntitiesToBackendModelsPipe, typeof AnswerNotesToTextChangesPipe, typeof StringArrayToSignUpFieldArrayPipe, typeof ToIntegerPipe, typeof DisplayedSubmissionsCounterPipe], never, [typeof SafePipe, typeof CollectionSubscriptionToCollectionBasePipe, typeof CollectionToCollectionBasePipe, typeof SafeHtmlPipe, typeof ResourceSubscriptionToResourcePipe, typeof ResourceToResourceSubscriptionPipe, typeof EllipsisPipe, typeof UserIdentifiedEntitiesToBackendModelsPipe, typeof AnswerNotesToTextChangesPipe, typeof StringArrayToSignUpFieldArrayPipe, typeof ToIntegerPipe, typeof DisplayedSubmissionsCounterPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
+}
+
+declare class HerumActiveLinkComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumActiveLinkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumActiveLinkComponent, "app-herum-active-link", never, {}, {}, never, never, false, never>;
+}
+
+declare class HerumActiveMenuComponent {
+    private elementRef;
+    private changeDetectorRef;
+    useIcons: boolean;
+    view: "wide" | "narrow";
+    activeColor: string;
+    activeTextColor: string;
+    secondaryTextColor: string;
+    menuItems: any[];
+    selectedItem: any;
+    selectById: boolean;
+    isBlock: boolean;
+    dragEvent: SplitGutterInteractionEvent;
+    selectionIndex: EventEmitter<number>;
+    tabsContainer: ElementRef;
+    tabsElement: QueryList<ElementRef>;
+    onResize(): void;
+    currentItemIndex: number;
+    hostElement: HTMLElement;
+    constructor(elementRef: ElementRef, changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    private setCSSVariable;
+    ngAfterViewInit(): void;
+    _onSelectTab(selection: number): void;
+    private setTabElementWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumActiveMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumActiveMenuComponent, "herum-active-menu", never, { "useIcons": { "alias": "useIcons"; "required": false; }; "view": { "alias": "view"; "required": false; }; "activeColor": { "alias": "activeColor"; "required": false; }; "activeTextColor": { "alias": "activeTextColor"; "required": false; }; "secondaryTextColor": { "alias": "secondaryTextColor"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "selectById": { "alias": "selectById"; "required": false; }; "isBlock": { "alias": "isBlock"; "required": false; }; "dragEvent": { "alias": "dragEvent"; "required": false; }; }, { "selectionIndex": "selectionIndex"; }, never, never, false, never>;
+}
+
+declare class HerumAutocompleteComponent implements ControlValueAccessor {
+    private ngControl;
+    options: DisplayIdentifiedEntity[];
+    displayBy: string;
+    subTitleBy: string;
+    placeholder: string;
+    noResultsText: string;
+    disabled: boolean;
+    isLoadingInput: boolean;
+    debounceTime: number;
+    selectedOption: DisplayIdentifiedEntity | null;
+    isBlurred: boolean;
+    filterTextEmitter: EventEmitter<string>;
+    selectedOptionEmitter: EventEmitter<any>;
+    filterInput: HerumInputFieldComponent$1;
+    containerRef: ElementRef<HTMLDivElement>;
+    onWindowClick(event: MouseEvent): void;
+    currentSearchedItem: string;
+    filteredOptions: DisplayIdentifiedEntity[];
+    isDropdownOpen: boolean;
+    isWaitingForResults: boolean;
+    readonly skeletonRows: number[];
+    readonly skeletonWidths: number[];
+    constructor(ngControl: NgControl);
+    ngOnChanges(changes: SimpleChanges): void;
+    _onInputClick(event: MouseEvent): void;
+    _inputChange(rawText: string): void;
+    _onSelectOption(option: DisplayIdentifiedEntity): void;
+    _getSkeletonWidth(index: number): number;
+    onChange: (value: string) => void;
+    onTouched: () => void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    private filterOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumAutocompleteComponent, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumAutocompleteComponent, "herum-autocomplete", never, { "options": { "alias": "options"; "required": false; }; "displayBy": { "alias": "displayBy"; "required": false; }; "subTitleBy": { "alias": "subTitleBy"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "noResultsText": { "alias": "noResultsText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isLoadingInput": { "alias": "isLoadingInput"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; "selectedOption": { "alias": "selectedOption"; "required": false; }; "isBlurred": { "alias": "isBlurred"; "required": false; }; }, { "filterTextEmitter": "filterTextEmitter"; "selectedOptionEmitter": "selectedOptionEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumClosedListMultiSelectComponent {
+    private commonGraphqlRequestsService;
+    closedListName: string;
+    placeholder: string;
+    disabled: boolean;
+    isDropDownInPositionFixed: boolean;
+    size: 'fit' | 'default' | 'big' | 'responsive';
+    dropDownDirection: 'upwards' | 'downwards';
+    selectedClosedListOptionalValues: IdentifiedEntity[];
+    selectedClosedListValueEmitter: EventEmitter<any[]>;
+    closedListValues: IdentifiedEntity[];
+    constructor(commonGraphqlRequestsService: CommonGraphqlRequestsService);
+    ngOnChanges(changes: SimpleChanges): void;
+    private setClosedListValues;
+    _selectedOptionsEmitter(selectedClosedListValue: IdentifiedEntity[]): void;
+    onChange: (selectedClosedListValue: IdentifiedEntity[]) => void;
+    onTouched: () => void;
+    writeValue(selectedClosedListOptionalValues: IdentifiedEntity[]): void;
+    private syncIdsBetweenSelectedValuesToValues;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumClosedListMultiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumClosedListMultiSelectComponent, "herum-closed-list-multi-select", never, { "closedListName": { "alias": "closedListName"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isDropDownInPositionFixed": { "alias": "isDropDownInPositionFixed"; "required": false; }; "size": { "alias": "size"; "required": false; }; "dropDownDirection": { "alias": "dropDownDirection"; "required": false; }; "selectedClosedListOptionalValues": { "alias": "selectedClosedListOptionalValues"; "required": false; }; }, { "selectedClosedListValueEmitter": "selectedClosedListValueEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumClosedListSelectComponent implements ControlValueAccessor {
+    private commonGraphqlRequestsService;
+    closedListName: string;
+    placeholder: string;
+    closedListOptionalValueName: string;
+    disabled: boolean;
+    isDropDownInPositionFixed: boolean;
+    iconPath: string;
+    isAutoComplete: boolean;
+    title: string;
+    size: 'fit' | 'default' | 'big' | 'responsive';
+    displayLoadingMode: boolean;
+    isLoadingInput: boolean;
+    dropDownDirection: 'upwards' | 'downwards';
+    filterPlaceholder: string;
+    selectedClosedListValueEmitter: EventEmitter<any>;
+    filterTextEmitter: EventEmitter<string>;
+    closedListValues: IdentifiedEntity[];
+    selectedClosedListOptionalValue: IdentifiedEntity;
+    constructor(commonGraphqlRequestsService: CommonGraphqlRequestsService);
+    ngOnChanges(changes: SimpleChanges): void;
+    private setClosedListValues;
+    private handleClosedListValueId;
+    _selectedOptionEmitter(selectedClosedListValue: IdentifiedEntity): void;
+    _filterTextEmitter(text: string): void;
+    onChange: (selectedClosedListValue: IdentifiedEntity) => void;
+    onTouched: () => void;
+    writeValue(closedListOptionalValueName: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumClosedListSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumClosedListSelectComponent, "herum-closed-list-select", never, { "closedListName": { "alias": "formControlName"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "closedListOptionalValueName": { "alias": "closedListOptionalValueName"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isDropDownInPositionFixed": { "alias": "isDropDownInPositionFixed"; "required": false; }; "iconPath": { "alias": "iconPath"; "required": false; }; "isAutoComplete": { "alias": "isAutoComplete"; "required": false; }; "title": { "alias": "title"; "required": false; }; "size": { "alias": "size"; "required": false; }; "displayLoadingMode": { "alias": "displayLoadingMode"; "required": false; }; "isLoadingInput": { "alias": "isLoadingInput"; "required": false; }; "dropDownDirection": { "alias": "dropDownDirection"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; }, { "selectedClosedListValueEmitter": "selectedClosedListValueEmitter"; "filterTextEmitter": "filterTextEmitter"; }, never, never, false, never>;
+}
+
+declare class HerumDateTimeInputComponent {
+    placeholder: string;
+    inputValue: string;
+    minDate: Date;
+    showSeconds: boolean;
+    rangeMode: boolean;
+    dateChange: EventEmitter<Date | DateRange<Date>>;
+    timeChange: EventEmitter<string>;
+    disableChange: EventEmitter<boolean>;
+    errorMessage: string;
+    isValid: boolean;
+    debounceTime: number;
+    ltrMode: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    _valueChange(dateString: string): void;
+    private handleDateRangeTimeRangeMode;
+    private handleDateRangeTimeRangeValidations;
+    private startEndDateValidation;
+    private handleDateTimeMode;
+    private createDateTime;
+    private handleDateTimeValidations;
+    private minDateValidation;
+    private patternValidation;
+    private timestampValidation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumDateTimeInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumDateTimeInputComponent, "herum-date-time-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "inputValue": { "alias": "inputValue"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "rangeMode": { "alias": "rangeMode"; "required": false; }; }, { "dateChange": "dateChange"; "timeChange": "timeChange"; "disableChange": "disableChange"; }, never, never, false, never>;
+}
+
+declare class HerumDateTimePickerComponent {
+    private elementRef;
+    showDatePicker: boolean;
+    showTimePicker: boolean;
+    showTimeSelect: boolean;
+    selectedTime: string;
+    selectedDate: Date | DateRange<Date>;
+    rangeMode: boolean;
+    minDate: Date;
+    timePickerHoverColor: string;
+    timePickerActiveColor: string;
+    widthDatePicker: string;
+    heightTimePicker: string;
+    datePickerHoverColor: string;
+    datePickerActiveColor: string;
+    showSeconds: boolean;
+    timePickerItemSize: string;
+    timeChange: EventEmitter<string>;
+    dateChange: EventEmitter<Date | DateRange<Date>>;
+    hostElement: HTMLElement;
+    constructor(elementRef: ElementRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    _timeChange(time: string): void;
+    _dateChange(date: Date | DateRange<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumDateTimePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumDateTimePickerComponent, "herum-date-time-picker", never, { "showDatePicker": { "alias": "showDatePicker"; "required": false; }; "showTimePicker": { "alias": "showTimePicker"; "required": false; }; "showTimeSelect": { "alias": "showTimeSelect"; "required": false; }; "selectedTime": { "alias": "selectedTime"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "rangeMode": { "alias": "rangeMode"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "timePickerHoverColor": { "alias": "timePickerHoverColor"; "required": false; }; "timePickerActiveColor": { "alias": "timePickerActiveColor"; "required": false; }; "widthDatePicker": { "alias": "widthDatePicker"; "required": false; }; "heightTimePicker": { "alias": "heightTimePicker"; "required": false; }; "datePickerHoverColor": { "alias": "datePickerHoverColor"; "required": false; }; "datePickerActiveColor": { "alias": "datePickerActiveColor"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "timePickerItemSize": { "alias": "timePickerItemSize"; "required": false; }; }, { "timeChange": "timeChange"; "dateChange": "dateChange"; }, never, never, false, never>;
+}
+
+declare class HerumDropZoneComponent {
+    private environmentConfig;
+    selectedFiles: File[];
+    placeholder: string;
+    numberOfAllowedFiles: number;
+    allowedFileTypes: any[];
+    supportedFilesMimes: any[];
+    supportedFilesTypes: any[];
+    requiredField: boolean;
+    directionPreview: 'row' | 'column';
+    type: 'row' | 'column';
+    grow: boolean;
+    fillContainer: boolean;
+    uploadFileSvg: string;
+    previewImageUrl?: string;
+    allowToDeleteImage: boolean;
+    filesDataEvent: EventEmitter<File[]>;
+    fileInput: ElementRef<HTMLInputElement>;
+    filesList: File[];
+    isLoading: boolean;
+    isDownloadInProgress: boolean;
+    hasExceededNumberOfAllowedFiles: boolean;
+    filesSuffixes: {
+        [key: string]: string;
+    };
+    isValidUpload: boolean;
+    isSupportedFileType: boolean;
+    parsedAllowedFileTypes: string;
+    errorMessages: {
+        condition: () => boolean;
+        message: string;
+    }[];
+    constructor(environmentConfig: EnvironmentConfig);
+    ngOnChanges(changes: SimpleChanges): void;
+    _onRemoveFile(index: number, event: MouseEvent): void;
+    _onRemoveImage(): void;
+    _onUploadDroppedFiles(event: DragEvent): void;
+    _onPreventDefault(event: DragEvent): void;
+    _onDownloadMediaConvertor(event: MouseEvent): void;
+    _onUploadFiles(event: Event): void;
+    _onClickFileInput(): void;
+    private uploadFiles;
+    private supportedFilesValidation;
+    private filesTypeValidation;
+    private isExceededFilesLength;
+    getIconPath(file: File): string;
+    get convertorMediaPath(): string;
+    private parseAllowedFileTypes;
+    private addOrRemoveRequiredFieldError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumDropZoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumDropZoneComponent, "herum-drop-zone", never, { "selectedFiles": { "alias": "selectedFiles"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "numberOfAllowedFiles": { "alias": "numberOfAllowedFiles"; "required": false; }; "allowedFileTypes": { "alias": "allowedFileTypes"; "required": false; }; "supportedFilesMimes": { "alias": "supportedFilesMimes"; "required": false; }; "supportedFilesTypes": { "alias": "supportedFilesTypes"; "required": false; }; "requiredField": { "alias": "requiredField"; "required": false; }; "directionPreview": { "alias": "directionPreview"; "required": false; }; "type": { "alias": "type"; "required": false; }; "grow": { "alias": "grow"; "required": false; }; "fillContainer": { "alias": "fillContainer"; "required": false; }; "uploadFileSvg": { "alias": "uploadFileSvg"; "required": false; }; "previewImageUrl": { "alias": "previewImageUrl"; "required": false; }; "allowToDeleteImage": { "alias": "allowToDeleteImage"; "required": false; }; }, { "filesDataEvent": "filesDataEvent"; }, never, never, false, never>;
+}
+
+declare class HerumExpendablePanelComponent {
+    title: string;
+    isBoldTitle: boolean;
+    isContentDisplayed: boolean;
+    _onToggleContentDisplay(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumExpendablePanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumExpendablePanelComponent, "herum-expendable-panel", never, { "title": { "alias": "title"; "required": false; }; "isBoldTitle": { "alias": "isBoldTitle"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class HerumFilesViewerComponent {
+    private environmentConfig;
+    fileData: FileData;
+    showDeleteFileButton: boolean;
+    downloadFile: EventEmitter<any>;
+    deleteFile: EventEmitter<any>;
+    srcPath: string;
+    fileType: string;
+    constructor(environmentConfig: EnvironmentConfig);
+    ngOnChanges(changes: SimpleChanges): void;
+    _onDeleteFile(): void;
+    _downloadFile(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumFilesViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumFilesViewerComponent, "herum-files-viewer", never, { "fileData": { "alias": "fileData"; "required": false; }; "showDeleteFileButton": { "alias": "showDeleteFileButton"; "required": false; }; }, { "downloadFile": "downloadFile"; "deleteFile": "deleteFile"; }, never, never, false, never>;
+}
+
+declare class HerumHierarchyTreeNodeComponent {
+    private changeDetectorRef;
+    private environmentConfig;
+    treeNodeData: TreeNodeAssignmentsData;
+    size: "small" | "regular";
+    expandedMode: "open" | "close" | "none";
+    showArrow: boolean;
+    showAssignmentsDetails: boolean;
+    nodeMenuItems: NodeMenuItem<SystemTreeNodeData>[];
+    onNodeSelected: EventEmitter<boolean>;
+    onMenuItemSelected: EventEmitter<any>;
+    onExpand: EventEmitter<boolean>;
+    isExpand: boolean;
+    constructor(changeDetectorRef: ChangeDetectorRef, environmentConfig: EnvironmentConfig);
+    ngOnChanges(changes: SimpleChanges): void;
+    _isTruncatedTitleElement(element: HTMLElement): boolean;
+    _onExpand(): void;
+    _onNodeSelected(): void;
+    _onMenuItemSelected(item: NodeMenuItem<SystemTreeNodeData>): void;
+    get toRPActualAssignmentsDisplayText(): string;
+    get expectedAssignmentsDisplayText(): string;
+    get invalidAssignmentsDisplayText(): string;
+    get negativePercentage(): number;
+    get smallChevronSvg(): string;
+    get systemIdentifier(): string;
+    get isHerum(): boolean;
+    get isHadracha(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumHierarchyTreeNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumHierarchyTreeNodeComponent, "herum-hierarchy-tree-node", never, { "treeNodeData": { "alias": "treeNodeData"; "required": false; }; "size": { "alias": "size"; "required": false; }; "expandedMode": { "alias": "expandedMode"; "required": false; }; "showArrow": { "alias": "showArrow"; "required": false; }; "showAssignmentsDetails": { "alias": "showAssignmentsDetails"; "required": false; }; "nodeMenuItems": { "alias": "nodeMenuItems"; "required": false; }; }, { "onNodeSelected": "onNodeSelected"; "onMenuItemSelected": "onMenuItemSelected"; "onExpand": "onExpand"; }, never, never, false, never>;
+}
+
+declare class HerumMultiProgressBarComponent implements OnInit {
+    progressBarsSections: {
+        label: string;
+        percentage: number;
+        progressBars: {
+            label: string;
+            value: number;
+            percentage: number;
+            color: string;
+        }[];
+    }[];
+    constructor();
+    ngOnInit(): void;
+    getBorderRadius(sectionIndex: number, progressBarIndex: number): "none" | "right" | "left" | "both";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumMultiProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumMultiProgressBarComponent, "herum-multi-progress-bar", never, { "progressBarsSections": { "alias": "progressBarsSections"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumNavigatorComponent {
+    isFirstItem: boolean;
+    isLastItem: boolean;
+    nextButtonText: string;
+    previousButtonText: string;
+    isNextButtonDisable: boolean;
+    isBackButtonDisable: boolean;
+    currentItemIndex: number;
+    updatedItemIndex: EventEmitter<number>;
+    _onPreviousItem(currentItemIndex: number): void;
+    _onNextItem(currentItemIndex: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumNavigatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumNavigatorComponent, "herum-navigator", never, { "isFirstItem": { "alias": "isFirstItem"; "required": false; }; "isLastItem": { "alias": "isLastItem"; "required": false; }; "nextButtonText": { "alias": "nextButtonText"; "required": false; }; "previousButtonText": { "alias": "previousButtonText"; "required": false; }; "isNextButtonDisable": { "alias": "isNextButtonDisable"; "required": false; }; "isBackButtonDisable": { "alias": "isBackButtonDisable"; "required": false; }; "currentItemIndex": { "alias": "currentItemIndex"; "required": false; }; }, { "updatedItemIndex": "updatedItemIndex"; }, never, never, false, never>;
+}
+
+declare class HerumStepNavigatorComponent {
+    steps: Step[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumStepNavigatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumStepNavigatorComponent, "herum-step-navigator", never, { "steps": { "alias": "steps"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumStepperComponent {
+    color: 'primary' | 'white';
+    useDymanicSize: boolean;
+    steps: Step[];
+    current: number;
+    getStepItemStyle(index: number): {
+        opacity: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumStepperComponent, "herum-stepper", never, { "color": { "alias": "color"; "required": false; }; "useDymanicSize": { "alias": "useDymanicSize"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "current": { "alias": "current"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumTimeSelectComponent {
+    showSeconds: boolean;
+    minutesPlaceholder: string;
+    secondsPlaceholder: string;
+    hoursPlaceholder: string;
+    selectedTime: string;
+    label: string;
+    timeChange: EventEmitter<string>;
+    selectedHour: IdentifiedEntity;
+    selectedMinute: IdentifiedEntity;
+    selectedSecond: IdentifiedEntity;
+    hours: IdentifiedEntity[];
+    minutes: IdentifiedEntity[];
+    seconds: IdentifiedEntity[];
+    ngOnChanges(changes: SimpleChanges): void;
+    _selectedSecondOptionChange(updatedSecond: IdentifiedEntity): void;
+    _selectedMinuteOptionChange(updatedMinute: IdentifiedEntity): void;
+    _selectedHourOptionChange(updatedHour: IdentifiedEntity): void;
+    private emitSelectedTime;
+    private formatTime;
+    private selectedTimeToSelectedIdentifiedEntities;
+    private generateIdentifiedEntityTimeArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumTimeSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumTimeSelectComponent, "herum-time-select", never, { "showSeconds": { "alias": "showSeconds"; "required": false; }; "minutesPlaceholder": { "alias": "minutesPlaceholder"; "required": false; }; "secondsPlaceholder": { "alias": "secondsPlaceholder"; "required": false; }; "hoursPlaceholder": { "alias": "hoursPlaceholder"; "required": false; }; "selectedTime": { "alias": "selectedTime"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, { "timeChange": "timeChange"; }, never, never, false, never>;
+}
+
+declare class HerumUserProfileComponent {
+    userData: User;
+    mode: 'vertical' | 'horizontal';
+    titleSize: 'big' | 'medium' | 'small';
+    imageSize: 'image-default-size' | 'image-small-size';
+    get userFullName(): string;
+    get fullHierarchyName(): any;
+    get assignmentStateDisplayName(): "" | "שיבוץ זמני" | "אכ\"א" | "אג\"ת";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumUserProfileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumUserProfileComponent, "herum-user-profile", never, { "userData": { "alias": "userData"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "titleSize": { "alias": "titleSize"; "required": false; }; "imageSize": { "alias": "imageSize"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumUserProgressComponent {
+    title: string;
+    percentage: number;
+    type: 'gradient' | 'solid';
+    get percentageLabel(): "כשירות נמוכה" | "כשירות בינונית" | "כשירות טובה מאוד" | "כשירות מושלמת! כל הכבוד!";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumUserProgressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumUserProgressComponent, "app-herum-user-progress", never, { "title": { "alias": "title"; "required": false; }; "percentage": { "alias": "percentage"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KeyValueListComponent {
+    items: KeyValue[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyValueListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeyValueListComponent, "key-value-list", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class LabelsWithIconsListComponent {
+    items: {
+        iconPath: string;
+        label: string;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelsWithIconsListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LabelsWithIconsListComponent, "labels-with-icons-list", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProgressesOverViewComponent {
+    titleSize: 'section-title' | 'section-header-title';
+    circularProgressSize: 'default-size' | 'big-size';
+    progressesOverView: ProgressOverView[];
+    progressOverViewDirection: 'column' | 'row';
+    containerProgressesOverViewDirection: 'column' | 'row';
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressesOverViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressesOverViewComponent, "progresses-over-view", never, { "titleSize": { "alias": "titleSize"; "required": false; }; "circularProgressSize": { "alias": "circularProgressSize"; "required": false; }; "progressesOverView": { "alias": "progressesOverView"; "required": false; }; "progressOverViewDirection": { "alias": "progressOverViewDirection"; "required": false; }; "containerProgressesOverViewDirection": { "alias": "containerProgressesOverViewDirection"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MoleculesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MoleculesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MoleculesModule, [typeof HerumActiveLinkComponent, typeof HerumActiveMenuComponent, typeof HerumAutocompleteComponent, typeof HerumClosedListMultiSelectComponent, typeof HerumClosedListSelectComponent, typeof HerumDateTimeInputComponent, typeof HerumDateTimePickerComponent, typeof HerumDropZoneComponent, typeof HerumExpendablePanelComponent, typeof HerumFilesViewerComponent, typeof HerumHierarchyTreeNodeComponent, typeof HerumMultiProgressBarComponent, typeof HerumNavigatorComponent, typeof HerumStepNavigatorComponent, typeof HerumStepperComponent, typeof HerumTimeSelectComponent, typeof HerumUserProfileComponent, typeof HerumUserProgressComponent, typeof KeyValueListComponent, typeof LabelsWithIconsListComponent, typeof ProgressesOverViewComponent], [typeof i2.CommonModule, typeof i40.ReactiveFormsModule, typeof i40.FormsModule, typeof i41.MatMenuModule, typeof i42.ClipboardModule, typeof i43.MatAutocompleteModule, typeof i44.MatChipsModule, typeof i45.MatFormFieldModule, typeof i46.MatTooltipModule, typeof i47.MatInputModule, typeof i48.MatSelectModule, typeof i49.MatIconModule, typeof i50.MatCheckboxModule, typeof i51.MatSliderModule, typeof i52.DragDropModule, typeof i53.MatDatepickerModule, typeof i54.MatNativeDateModule, typeof i4$1.PipesModule, typeof i4.AtomsModule], [typeof HerumActiveLinkComponent, typeof HerumActiveMenuComponent, typeof HerumAutocompleteComponent, typeof HerumClosedListMultiSelectComponent, typeof HerumClosedListSelectComponent, typeof HerumDateTimeInputComponent, typeof HerumDateTimePickerComponent, typeof HerumDropZoneComponent, typeof HerumExpendablePanelComponent, typeof HerumFilesViewerComponent, typeof HerumHierarchyTreeNodeComponent, typeof HerumMultiProgressBarComponent, typeof HerumNavigatorComponent, typeof HerumStepNavigatorComponent, typeof HerumStepperComponent, typeof HerumTimeSelectComponent, typeof HerumUserProfileComponent, typeof HerumUserProgressComponent, typeof KeyValueListComponent, typeof LabelsWithIconsListComponent, typeof ProgressesOverViewComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MoleculesModule>;
+}
+
+declare class ErrorMessageDialogComponent implements OnInit {
+    dialogRef: MatDialogRef<ErrorMessageDialogComponent>;
+    data: any;
+    private environmentConfig;
+    errorImagePath: string;
+    constructor(dialogRef: MatDialogRef<ErrorMessageDialogComponent>, data: any, environmentConfig: EnvironmentConfig);
+    ngOnInit(): void;
+    _onSubmit(): void;
+    _onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessageDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorMessageDialogComponent, "error-message-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class ErrorsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ErrorsModule, [typeof ErrorMessageDialogComponent], [typeof i2.CommonModule], [typeof ErrorMessageDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ErrorsModule>;
+}
+
+declare class FetchedMessageDialog {
+    dialogRef: MatDialogRef<FetchedMessageDialog>;
+    data: {
+        fetchedMessage: FetchedMessage;
+        recipient: Object;
+    };
+    message: FetchedMessage;
+    constructor(dialogRef: MatDialogRef<FetchedMessageDialog>, data: {
+        fetchedMessage: FetchedMessage;
+        recipient: Object;
+    });
+    ngOnInit(): void;
+    _onCloseDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FetchedMessageDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FetchedMessageDialog, "fetched-message-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class FetchedMessageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FetchedMessageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FetchedMessageModule, [typeof FetchedMessageDialog], [typeof i2.CommonModule, typeof i4.AtomsModule, typeof i4$1.PipesModule], [typeof FetchedMessageDialog]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FetchedMessageModule>;
+}
+
+declare class CheckboxCellComponent implements ICellRendererAngularComp {
+    isChecked: boolean;
+    blocked: boolean;
+    align?: AlignDir;
+    params: HerumTableParams;
+    _checked(checked: boolean): void;
+    agInit(params: HerumTableParams): void;
+    refresh(params: HerumTableParams): boolean;
+    private setParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxCellComponent, "app-checkbox-cell", never, {}, {}, never, never, false, never>;
+}
+
+declare class ChipsCellComponent implements ICellRendererAngularComp {
+    params: ICellRendererParams;
+    value: any;
+    agInit(params: HerumTableParams): void;
+    refresh(params: HerumTableParams): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChipsCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChipsCellComponent, "app-chips-cell", never, {}, {}, never, never, false, never>;
+}
+
+declare class CopyableCellComponent implements ICellRendererAngularComp {
+    params: ICellRendererParams;
+    value: any;
+    agInit(params: HerumTableParams): void;
+    refresh(params: HerumTableParams): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyableCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CopyableCellComponent, "app-copyable-cell", never, {}, {}, never, never, false, never>;
+}
+
+declare class DeleteRowComponent implements ICellRendererAngularComp {
+    isRowHovered: boolean;
+    params: HerumTableParams;
+    value: any;
+    garbageSvg: string;
+    agInit(params: HerumTableParams): void;
+    _onDelete(event: MouseEvent): void;
+    _isTruncatedTitleElement(element: HTMLElement): boolean;
+    refresh(params: HerumTableParams): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeleteRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DeleteRowComponent, "delete-row", never, { "isRowHovered": { "alias": "isRowHovered"; "required": false; }; "params": { "alias": "params"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class EditRowComponent implements ICellRendererAngularComp, HoveredHerumRowTable {
+    private clipboard;
+    isRowHovered: boolean;
+    params: ICellRendererParams;
+    value: any;
+    action: number;
+    isCopyableToClipboard: boolean;
+    constructor(clipboard: Clipboard);
+    agInit(params: HerumTableParams): void;
+    _onEdit(event: MouseEvent): void;
+    _onCopyToClipboard(event: MouseEvent): void;
+    refresh(params: HerumTableParams): boolean;
+    get editIcon(): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditRowComponent, "edit-row", never, { "isRowHovered": { "alias": "isRowHovered"; "required": false; }; "params": { "alias": "params"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class InputCellComponent implements ICellRendererAngularComp {
+    align?: AlignDir;
+    params: HerumTableParams;
+    inputValue: number;
+    _input(value: number): void;
+    agInit(params: HerumTableParams): void;
+    refresh(params: HerumTableParams): boolean;
+    private setParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCellComponent, "input-cell", never, {}, {}, never, never, false, never>;
+}
+
+declare class RowActionButtonsComponent implements ICellRendererAngularComp {
+    isRowHovered: boolean;
+    value: any;
+    params: ICellRendererParams;
+    agInit(params: HerumTableParams): void;
+    refresh(params: HerumTableParams): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowActionButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RowActionButtonsComponent, "row-action-buttons", never, {}, {}, never, never, false, never>;
+}
+
+declare class SwitchCellComponent implements ICellRendererAngularComp {
+    isChecked?: boolean;
+    align?: AlignDir;
+    disabled: boolean;
+    params: HerumTableParams;
+    _checked(isChecked: boolean): void;
+    agInit(params: HerumTableParams): void;
+    refresh(params: HerumTableParams): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchCellComponent, "switch-cell", never, { "isChecked": { "alias": "isChecked"; "required": false; }; "align": { "alias": "align"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HerumTableComponent implements OnChanges, AfterViewInit {
+    rowData: (unknown & BaseRowData)[];
+    columnDefs: ColDef[];
+    selectedRowsIds: string[];
+    noResults: number;
+    overlayNoRowsTemplate: string;
+    rowsSelectionType: 'multiple' | 'single';
+    usePagination: boolean;
+    suppressRowClickSelection: boolean;
+    showExportToExcel: boolean;
+    onCheckedRow: EventEmitter<any>;
+    onUncheckedRow: EventEmitter<any>;
+    selectedRowByChild: EventEmitter<any>;
+    cellValueChangeByChild: EventEmitter<any>;
+    cellMouseOver: EventEmitter<any>;
+    onPaginationChanged: EventEmitter<any>;
+    tableContainer: ElementRef;
+    onResize(): void;
+    windowWidth: number;
+    context: any;
+    childComponentsReferences: HoveredHerumRowTable[];
+    isLoading: boolean;
+    gridApi: GridApi;
+    isFirstDataRendered: boolean;
+    defaultColDef: {
+        resizable: boolean;
+        sortable: boolean;
+        flex: number;
+        minWidth: number;
+        maxWidth: number;
+        rowHeight: number;
+    };
+    gridOptions: any;
+    frameworkComponents: {
+        customCheckboxRenderer: typeof CheckboxCellComponent;
+    };
+    rowHeight: number;
+    tableWidth: string;
+    gridColumnApi: ColumnApi;
+    params: HerumTableParams;
+    hoveredRowId: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    _onExportCsv(): void;
+    _onFirstDataRendered(params: HerumTableParams): void;
+    _onGridReady(params: GridReadyEvent): void;
+    _onModelUpdated(modelUpdatedEvent: ModelUpdatedEvent): void;
+    _onSelectionChanged(event: any): void;
+    _onPaginationChanged(event: any): void;
+    _onCellMouseOver(event: any): void;
+    _onFilterChanged(params: HerumTableParams): void;
+    _onRowSelected(row: any): void;
+    _onGridMouseLeave(): void;
+    selectedRowByChildComponent(params: HerumTableParams): void;
+    deleteChildComponentReference(componentReference: HoveredHerumRowTable): void;
+    setChildComponentRef(componentReference: HoveredHerumRowTable): void;
+    private setTableHeight;
+    private updateSelectedRows;
+    private sortBySelectedRows;
+    private resizeColumnsWidth;
+    private toggleHoverIcon;
+    private getExistingComponentReferenceIndex;
+    private updateRowHeight;
+    private setRowheightStyleProperty;
+    private getMaxRowHeightFromColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumTableComponent, "herum-table", never, { "rowData": { "alias": "rowData"; "required": false; }; "columnDefs": { "alias": "columnDefs"; "required": false; }; "selectedRowsIds": { "alias": "selectedRowsIds"; "required": false; }; "noResults": { "alias": "noResults"; "required": false; }; "overlayNoRowsTemplate": { "alias": "overlayNoRowsTemplate"; "required": false; }; "rowsSelectionType": { "alias": "rowsSelectionType"; "required": false; }; "usePagination": { "alias": "usePagination"; "required": false; }; "suppressRowClickSelection": { "alias": "suppressRowClickSelection"; "required": false; }; "showExportToExcel": { "alias": "showExportToExcel"; "required": false; }; }, { "onCheckedRow": "onCheckedRow"; "onUncheckedRow": "onUncheckedRow"; "selectedRowByChild": "selectedRowByChild"; "cellValueChangeByChild": "cellValueChangeByChild"; "cellMouseOver": "cellMouseOver"; "onPaginationChanged": "onPaginationChanged"; }, never, never, false, never>;
+}
+
+declare class HerumAgGridFilterComponent implements AgFilterComponent, OnInit {
+    private envConfig;
+    private static readonly rowHeight;
+    private model;
+    private uniqueCheck;
+    private filterParams;
+    private fieldId;
+    private filterList;
+    isEverythingSelected: boolean;
+    isToggleAllCheckBoxBlocked: boolean;
+    containerHeight: number;
+    selectedValuesMap: object;
+    checkBoxType: string;
+    onFilterListChange$: BehaviorSubject<string[]>;
+    onFilterValuesChanged$: Observable<string[]>;
+    destroySubject$: Subject<null>;
+    selectedFilter: FormControl;
+    constructor(envConfig: EnvironmentConfig);
+    ngOnInit(): void;
+    agInit(params: IFilterParams): void;
+    private handleChekedValuesWhenfiltering;
+    setUniqueValues(): void;
+    toggleItem(value: string, updateMetadata?: boolean): void;
+    setCheckBoxType(): void;
+    toggleEverything(): void;
+    onNewRowsLoaded(): void;
+    isFilterActive(): boolean;
+    doesFilterPass(params: IDoesFilterPassParams): boolean;
+    getModel(): string[];
+    onFilterChanged(): void;
+    setModel(value: string): void;
+    private setContainerHeight;
+    private sortValues;
+    private selectEverything;
+    private unselectEverything;
+    private addUniqueValueIfMissing;
+    private isValueValid;
+    isTruncatedTitleElement(element: HTMLElement): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumAgGridFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumAgGridFilterComponent, "app-herum-ag-grid-filter", never, {}, {}, never, never, false, never>;
+}
+
+declare class TableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof CheckboxCellComponent, typeof ChipsCellComponent, typeof CopyableCellComponent, typeof DeleteRowComponent, typeof EditRowComponent, typeof InputCellComponent, typeof RowActionButtonsComponent, typeof SwitchCellComponent, typeof HerumTableComponent, typeof HerumAgGridFilterComponent], [typeof i2.CommonModule, typeof i4.AtomsModule, typeof i40.FormsModule, typeof i40.ReactiveFormsModule, typeof i46.MatTooltipModule, typeof i15.AgGridModule, typeof i4$1.PipesModule, typeof i42.ClipboardModule], [typeof CheckboxCellComponent, typeof ChipsCellComponent, typeof CopyableCellComponent, typeof DeleteRowComponent, typeof EditRowComponent, typeof InputCellComponent, typeof RowActionButtonsComponent, typeof SwitchCellComponent, typeof HerumTableComponent, typeof HerumAgGridFilterComponent, typeof i15.AgGridModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}
+
+declare class HerumSharedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumSharedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HerumSharedModule, [typeof HerumToolTipDirective, typeof HerumVideoPlayerComponent, typeof TrackTextChangesComponent, typeof HerumVideoRangeBarComponent, typeof HerumPdfViewerComponent, typeof HerumStoryViewerComponent, typeof UserActionDirective, typeof HerumPresentationViewerComponent, typeof HerumLoaderComponent, typeof SvgOnHoverDirective, typeof HerumQuizComponent, typeof QuizHeaderComponent, typeof QuizTwoAnswersQuestionComponent, typeof QuizOneAnswerQuestionComponent, typeof QuizSubmissionComponent, typeof QuizIntroComponent, typeof QuizGradeSheetComponent, typeof QuizMultiAnswerQuestionComponent, typeof QuizLoaderComponent, typeof HerumListCentralizerComponent, typeof HerumLocalLoaderComponent, typeof BlockedFormComponent, typeof AudioPlayerComponent, typeof HerumMiniTableComponent, typeof HerumHierarchyTreeComponent, typeof RecursiveTreeComponent, typeof HerumTextualVerticalTreeComponent, typeof HerumDateTimePickerSelectComponent, typeof HerumTimeRangeSelectComponent, typeof AudioSliderComponent, typeof QuizOpenAnswerQuestionComponent, typeof HerumHighlightDirective], [typeof i2.CommonModule, typeof i40.ReactiveFormsModule, typeof i40.FormsModule, typeof i41.MatMenuModule, typeof i42.ClipboardModule, typeof i43.MatAutocompleteModule, typeof i44.MatChipsModule, typeof i45.MatFormFieldModule, typeof i46.MatTooltipModule, typeof i47.MatInputModule, typeof i48.MatSelectModule, typeof i49.MatIconModule, typeof i50.MatCheckboxModule, typeof i51.MatSliderModule, typeof i52.DragDropModule, typeof i53.MatDatepickerModule, typeof i54.MatNativeDateModule, typeof DialogsModule, typeof AtomsModule, typeof PipesModule, typeof MoleculesModule, typeof ErrorsModule, typeof FetchedMessageModule, typeof TableModule], [typeof TrackTextChangesComponent, typeof HerumToolTipDirective, typeof UserActionDirective, typeof HerumVideoPlayerComponent, typeof HerumPdfViewerComponent, typeof HerumStoryViewerComponent, typeof HerumLoaderComponent, typeof HerumLocalLoaderComponent, typeof HerumQuizComponent, typeof SvgOnHoverDirective, typeof HerumHighlightDirective, typeof i2.CommonModule, typeof HerumListCentralizerComponent, typeof BlockedFormComponent, typeof HerumMiniTableComponent, typeof HerumHierarchyTreeComponent, typeof HerumTextualVerticalTreeComponent, typeof AudioPlayerComponent, typeof HerumDateTimePickerSelectComponent, typeof HerumTimeRangeSelectComponent, typeof QuizIntroComponent, typeof QuizOneAnswerQuestionComponent, typeof QuizMultiAnswerQuestionComponent, typeof QuizOpenAnswerQuestionComponent, typeof DialogsModule, typeof AtomsModule, typeof MoleculesModule, typeof PipesModule, typeof ErrorsModule, typeof FetchedMessageModule, typeof TableModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HerumSharedModule>;
+}
+
+declare const openClose: _angular_animations.AnimationTriggerMetadata;
+
+declare class HerumFormControl extends FormControl {
+    errorMessages: {
+        [key: string]: string;
+    };
+    currentErrorMessage: string;
+    destroySubject$: Subject<null>;
+    /**
+     @comment The component that creates this class should have destroySubject$ so you can listen to its ngOnDestroy life cycle hook so you can unsubscribe statusChangesSubscription
+     */
+    constructor(formState: any, validatorOrOpts: ValidatorFn | ValidatorFn[] | null, asyncValidator: AsyncValidatorFn | AsyncValidatorFn[] | null, errorMessages: {
+        [key: string]: string;
+    }, componentReference: any);
+    private setCurrentErrorMessage;
+}
+
+declare class FetchedMessageService {
+    private http;
+    private dialog;
+    private environmentConfig;
+    private recipient;
+    private messageKey;
+    constructor(http: HttpClient, dialog: MatDialog, environmentConfig: EnvironmentConfig);
+    handleFetchedMessage(recipient: Object, messageKey: string, condition?: boolean): void;
+    private setMessageKey;
+    private setRecipient;
+    fetchedMessageData(): Observable<Object>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FetchedMessageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FetchedMessageService>;
+}
+
+declare class ErrorsHandlerService {
+    private dialog;
+    private http;
+    private utilsService;
+    private environmentConfig;
+    isErrorPopupCurrentlyOpened: boolean;
+    failedReportUploadProgressRequests: HttpRequest<any>[];
+    failedDependentsRequestsContext: FailedDependentsRequestsContext;
+    dependentRequestId$: Subject<string>;
+    reportUploadProgressRequest$: Subject<string>;
+    commonDependentsErrorToast$: Subject<CommonDependentsToast>;
+    errorToast$: Subject<ToastHttpResponseDependencies>;
+    constructor(dialog: MatDialog, http: HttpClient, utilsService: UtilsService$1, environmentConfig: EnvironmentConfig);
+    handleError(errorStatus: number, errorData?: any): void;
+    setFailedReportUploadProgressRequests(failedReportUploadProgressRequest: HttpRequest<any>): void;
+    private handleUnauthorizedError;
+    private handleConflictError;
+    private handleForbiddenError;
+    private handleTimeoutError;
+    private handleInternalServerError;
+    private handleDependentRequestError;
+    private handleReportUploadProgressRequestError;
+    private isErrorToastNeeded;
+    private handleErrorToast;
+    setChainedFailedObservableFunctions(dependentId: string, error: HttpErrorResponse, failedComplexObservableArrowFunctions: ComplexObservableArrowFunctions, initialValue?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorsHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorsHandlerService>;
+}
+
+declare class DependentsService {
+    private errorsHandlerService;
+    dependentMetadata: DependentMetadata;
+    constructor(errorsHandlerService: ErrorsHandlerService);
+    chainObservableFunctions(complexFunctions: ComplexObservableArrowFunctions, initialValue?: any): any;
+    private setInitialObservable;
+    private handleInitialComplexFunction;
+    private handleInitialFunction;
+    private chainObservables;
+    private handleCurrentChainedComplexObservable;
+    handleCurrentChainedObservable(complexFunctions: ComplexObservableArrowFunctions, currentFunction: ObservableArrowFunction, result: any, functionsIndex: number): any;
+    private calculateNumberOfObservableFunctions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DependentsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DependentsService>;
+}
+
+declare class ToastsService {
+    private errorsHandlerService;
+    private utilsService;
+    private environmentConfig;
+    toast$: BehaviorSubject<Toast>;
+    toastId: number;
+    toastsTemplates: {
+        [key: string]: ToastTemplate;
+    };
+    constructor(errorsHandlerService: ErrorsHandlerService, utilsService: UtilsService$1, environmentConfig: EnvironmentConfig);
+    createToastBasedOnHttpResponse(toastHttpResponseDependencies: ToastHttpResponseDependencies): void;
+    findErrorMessageByStatusCode(statusCode: string, mongoMethodDisplayedName: string): string;
+    showErrorToast(toastContextKey: string): void;
+    showSuccessToast(toastContextKey: string): void;
+    showInformationToast(toastContextKey: string): void;
+    showOnDemandToast(toastContextKey: string, status: ToastStatus, toastStorageKey?: string): void;
+    private hasToastAlreadyShownAndShouldShowOnce;
+    showToast(title: string, content: string, status: ToastStatus): void;
+    private setToastStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastsService>;
+}
+
+declare class UploadsManagerService {
+    private errorsHandlerService;
+    private dependentsService;
+    private http;
+    private toastsService;
+    uploadsManagerTitle$: BehaviorSubject<string>;
+    uploadsProgressMetadata$: BehaviorSubject<UploadProgressMetadata[]>;
+    constructor(errorsHandlerService: ErrorsHandlerService, dependentsService: DependentsService, http: HttpClient, toastsService: ToastsService);
+    private setSubscriptions;
+    private updateUploadProgressStatus;
+    retryFailedUploads(): Observable<any>[];
+    retryFailedUpload(uploadProgressId: string): Observable<any>;
+    private handleFailedDependentRequest;
+    private handleFailedReportUploadRequest;
+    addOrUpdateUploadProgressMetadata(uploadProgressMetadata: UploadProgressMetadata): void;
+    getUploadProgressById(uploadProgressId: string): UploadProgressMetadata;
+    createNewToastBasedOnHttpRequest(commonDependentsToast: CommonDependentsToast): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadsManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UploadsManagerService>;
+}
+
+declare class HerumToastsComponent {
+    private toastsService;
+    private changeDetectorRef;
+    toastElements: QueryList<ElementRef>;
+    toasts: Toast[];
+    minimumOpacity: number;
+    transformDuration: number;
+    leavingDuration: number;
+    gap: number;
+    constructor(toastsService: ToastsService$1, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    handleNewToast(toast: Toast): void;
+    private reduceToastHeights;
+    _onHideToast(currentToast: Toast, lowToasts: boolean): void;
+    private removeToast;
+    private setToastLinearOpacity;
+    _toastStatusIcon(toastStatus: ToastStatus): string;
+    get successStatus(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumToastsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumToastsComponent, "herum-toasts", never, {}, {}, never, never, false, never>;
+}
+
+declare class HerumUploadsManagerComponent {
+    private uploadsManagerService;
+    destroySubject$: Subject<null>;
+    isContainerOpen: boolean;
+    loadingStatus: UploadProgressStatus;
+    errorStatus: UploadProgressStatus;
+    successStatus: UploadProgressStatus;
+    uploadsProgressMetadata: UploadProgressMetadata[];
+    averageProgressSum: number;
+    hasUploadProgressFinished: boolean;
+    numberOfFailedLoaders: number;
+    successProgressBarColor: string;
+    progressBarColor: string;
+    showConfirmationNativeMessage(event: any): void;
+    constructor(uploadsManagerService: UploadsManagerService$1);
+    ngOnInit(): void;
+    private setSuccessProgressBarColor;
+    private uploadsProgressMetadataSubscription;
+    _onRetryFailedUploads(): void;
+    _onRetryFailedUpload(uploadProgressId: string): void;
+    _onClose(): void;
+    _onToggleUploadsContainer(): void;
+    _isTruncatedTitleElement(element: HTMLElement): boolean;
+    _getUploadProgressDescription(uploadProgressMetadata: UploadProgressMetadata): string;
+    _isUploadProgressStatusError(uploadProgressStatus: UploadProgressStatus): boolean;
+    _getFileIcon(uploadProgressType: UploadProgressType): string;
+    _getUploadStatusIcon(uploadProgressType: UploadProgressType): string;
+    _trackByFn(index: number, uploadProgressMetadata: UploadProgressMetadata): any;
+    get containerTitle$(): Observable<string>;
+    calculateAverageProgressSum(uploadsProgressMetadata: UploadProgressMetadata[]): number;
+    calculateHasUploadProgressFinished(uploadsProgressMetadata: UploadProgressMetadata[]): boolean;
+    calculateNumberOfFailedLoaders(uploadsProgressMetadata: UploadProgressMetadata[]): number;
+    calculateProgressBarColor(uploadsProgressMetadata: UploadProgressMetadata[]): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HerumUploadsManagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HerumUploadsManagerComponent, "herum-uploads-manager", never, {}, {}, never, never, false, never>;
+}
+
+declare class MongoMoleculesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MongoMoleculesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MongoMoleculesModule, [typeof HerumToastsComponent, typeof HerumUploadsManagerComponent], [typeof i2.CommonModule, typeof i4$1.PipesModule, typeof i4.AtomsModule], [typeof HerumToastsComponent, typeof HerumUploadsManagerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MongoMoleculesModule>;
+}
+
+declare class MongoModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MongoModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MongoModule, never, [typeof i2.CommonModule, typeof MongoMoleculesModule], [typeof MongoMoleculesModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MongoModule>;
+}
+
+declare namespace AudioConfigurationConstants {
+    const maxValue = 100;
+    const defaultSecondsSkip = 15;
+    const canvasBackgroundColor = "#FAFAFA";
+    const gapBetweenBars = 0;
+    const barWidth = 1;
+    const barRadius = 4;
+    const timeLabelPadding = 10;
+    const timeLabelColor = "#8d96a6";
+    const currentTimeIndicatorWidth = 2;
+    const currentTimeIndicatorColor = "#FF0A4D";
+    const leftNodePassiveColor = "#D7D6DA";
+    const leftNodeActiveColor = "#2D7ABE";
+    const rightNodePassiveColor = "#E4E4E4";
+    const rightNodeActiveColor = "#3B2DBE";
+}
+declare const CollegeAudioConfiguration: AudioVisualConfiguration;
+declare const HadrachaAudioConfiguration: AudioVisualConfiguration;
+
+declare class TimeFormatPipe implements PipeTransform {
+    transform(value: number): string;
+    private padNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeFormatPipe, "timeFormat", false>;
+}
+
+declare const speedOptions: number[];
+
+declare function setDynamicElementStyle(readOnlyStylingObject: any, styleDictionary: {
+    [key: string]: any;
+}): void;
+declare const tooltipStyle: {
+    position: string;
+    top: string;
+    left: string;
+    background: string;
+    color: string;
+    padding: string;
+    borderRadius: string;
+    boxShadow: string;
+    display: string;
+    zIndex: string;
+};
+declare const commentTextStyle: {
+    width: string;
+    margin: string;
+};
+declare const buttonsContainerStyle: {
+    display: string;
+    justifyContent: string;
+    height: string;
+};
+declare const editButtonStyle: {
+    marginRight: string;
+    cursor: string;
+};
+declare const deleteButtonStyle: {
+    marginRight: string;
+    padding: string;
+    cursor: string;
+};
+
+export { AnswerNotesToTextChangesPipe, AtomsModule, AudioConfigurationConstants, AudioPlayerComponent, AudioSliderComponent, AudioVisualizationService, BlockedFormComponent, CheckboxCellComponent, ChipsCellComponent, CollectionSubscriptionToCollectionBasePipe, CollectionToCollectionBasePipe, CollegeAudioConfiguration, CollegeLoaderComponent, ConditionalFormControlNameDirective, CopyableCellComponent, DeleteRowComponent, DependentsService, DialogsModule, DisplayedSubmissionsCounterPipe, EditRowComponent, EllipsisPipe, ErrorMessageDialogComponent, ErrorsHandlerService, ErrorsModule, FetchedMessageDialog, FetchedMessageModule, FetchedMessageService, HadrachaAudioConfiguration, HerumActiveLinkComponent, HerumActiveMenuComponent, HerumAgGridFilterComponent, HerumAutocompleteComponent, HerumBreadcrumbsComponent, HerumButtonComponent, HerumCheckboxComponent, HerumChipComponent, HerumCircularProgressBarComponent, HerumClosedListMultiSelectComponent, HerumClosedListSelectComponent, HerumDatePickerComponent, HerumDateTimeInputComponent, HerumDateTimePickerComponent, HerumDateTimePickerSelectComponent, HerumDownloadFileComponent, HerumDropZoneComponent, HerumEllipsisLoaderComponent, HerumExpendablePanelComponent, HerumFilesViewerComponent, HerumFilesViewerDialogComponent, HerumFormControl, HerumHierarchyTreeComponent, HerumHierarchyTreeNodeComponent, HerumHighlightDirective, HerumIconLabelComponent, HerumIndeterminateComponent, HerumInputFieldComponent, HerumListCentralizerComponent, HerumLoaderComponent, HerumLocalLoaderComponent, HerumLogoComponent, HerumMiniTableComponent, HerumMultiProgressBarComponent, HerumMultiSelectComponent, HerumNarrowCollectionMenuItemComponent, HerumNavigatorComponent, HerumNoResultMessageComponent, HerumOptionsListComponent, HerumPaginatorComponent, HerumPanelLinksComponent, HerumPdfViewerComponent, HerumPresentationViewerComponent, HerumProgressBarComponent, HerumQuizComponent, HerumQuizHeaderItemComponent, HerumRadioButtonComponent, HerumRecursiveHierarchyOptionsListComponent, HerumSelectComponent, HerumSharedModule, HerumSliderComponent, HerumSpinnerComponent, HerumStepNavigatorComponent, HerumStepperComponent, HerumStoryViewerComponent, HerumSwitchComponent, HerumTableComponent, HerumTextAreaComponent, HerumTextualVerticalTreeComponent, HerumTimePickerComponent, HerumTimeRangeSelectComponent, HerumTimeSelectComponent, HerumToastsComponent, HerumToggleButtonComponent, HerumToolTipDirective, HerumUploadFileComponent, HerumUploadsManagerComponent, HerumUserProfileComponent, HerumUserProgressComponent, HerumVideoPlayerComponent, HerumVideoRangeBarComponent, HerumVideoSelectComponent, InputCellComponent, InsuranceDialogComponent, KeyValueListComponent, LabelsWithIconsListComponent, MoleculesModule, MongoModule, MongoMoleculesModule, PipesModule, ProgressesOverViewComponent, QuizGradeSheetComponent, QuizHeaderComponent, QuizIntroComponent, QuizLoaderComponent, QuizMultiAnswerQuestionComponent, QuizOneAnswerQuestionComponent, QuizOpenAnswerQuestionComponent, QuizSubmissionComponent, QuizTwoAnswersQuestionComponent, RecursiveTreeComponent, ResourceSubscriptionToResourcePipe, ResourceToResourceSubscriptionPipe, RoundedVerticalMenuComponent, RowActionButtonsComponent, SafeHtmlPipe, SafePipe, SliceBreadcrumbsPipe, StringArrayToSignUpFieldArrayPipe, SvgOnHoverDirective, SwitchCellComponent, TableModule, TimeFormatPipe, ToIntegerPipe, ToastsService, TrackTextChangesComponent, TrackTextChangesNotesComponent, UploadsManagerService, UserActionDirective, UserIdentifiedEntitiesToBackendModelsPipe, UserProfileImageComponent, UsersProfilePreviewComponent, buttonsContainerStyle, commentTextStyle, deleteButtonStyle, editButtonStyle, openClose, setDynamicElementStyle, speedOptions, tooltipStyle };
+export type { IHerumInterface };