@netgrif/components-core 6.0.1

package/lib/filter/user-filters.service.d.ts

@@ -0,0 +1,116 @@
+import { OnDestroy, Type } from '@angular/core';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import { CaseResourceService } from '../resources/engine-endpoint/case-resource.service';
+import { TaskResourceService } from '../resources/engine-endpoint/task-resource.service';
+import { SearchService } from '../search/search-service/search.service';
+import { ProcessService } from '../process/process.service';
+import { LoggerService } from '../logger/services/logger.service';
+import { Task } from '../resources/interface/task';
+import { CallChainService } from '../utility/call-chain/call-chain.service';
+import { TaskSetDataRequestBody, TaskSetDataRequestFields } from '../resources/interface/task-set-data-request-body';
+import { Category } from '../search/models/category/category';
+import { Net } from '../process/net';
+import { SideMenuService } from '../side-menu/services/side-menu.service';
+import { ComponentType } from '@angular/cdk/portal';
+import { FilterType } from './models/filter-type';
+import { Filter } from './models/filter';
+import { SavedFilterMetadata } from '../search/models/persistance/saved-filter-metadata';
+import { FilterMetadata } from '../search/models/persistance/filter-metadata';
+import { CategoryResolverService } from '../search/category-factory/category-resolver.service';
+import { DataGroup } from '../resources/interface/data-groups';
+/**
+ * Service that manages filters created by users of the application.
+ */
+export declare class UserFiltersService implements OnDestroy {
+    protected _caseService: CaseResourceService;
+    protected _taskService: TaskResourceService;
+    protected _processService: ProcessService;
+    protected _callChainService: CallChainService;
+    protected _sideMenuService: SideMenuService;
+    protected _log: LoggerService;
+    protected _categoryResolverService: CategoryResolverService;
+    protected _saveFilterComponent: ComponentType<unknown>;
+    protected _loadFilterComponent: ComponentType<unknown>;
+    protected _initialized$: ReplaySubject<boolean>;
+    protected _filterNet: Net;
+    constructor(_caseService: CaseResourceService, _taskService: TaskResourceService, _processService: ProcessService, _callChainService: CallChainService, _sideMenuService: SideMenuService, _log: LoggerService, _categoryResolverService: CategoryResolverService, _saveFilterComponent: ComponentType<unknown>, _loadFilterComponent: ComponentType<unknown>);
+    ngOnDestroy(): void;
+    /**
+     * Deletes the specified filter case by its case id.
+     * @param filterCaseId StringId of the filter case that should be deleted
+     * @returns an Observable that emits `true` if the case was successfully deleted and `false` otherwise
+     */
+    delete(filterCaseId: string): Observable<boolean>;
+    /**
+     * Opens a side menu with filter cases and allows the user to select one of them.
+     *
+     * The default filter constrains the cases to be instances of the filter process and to be filters of the specified type
+     * (`Case` or `Task`).
+     *
+     * @param filterType whether `Case` or `Task` user filters should be loaded
+     * @param additionalFilter additional constrains on the displayed user filter cases. Must be of type `Case`
+     * otherwise the method throws an error. If it is a {@link MergedFilter} must use the `AND` {@link MergeOperator} otherwise an error
+     * will be thrown
+     * @returns an Observable that emits the data necessary to reconstruct the selected filter, or `undefined` if no filter was selected
+     */
+    load(filterType: FilterType, additionalFilter?: Filter): Observable<any>;
+    /**
+     * Saves the predicate filter contained in the provided {@link SearchService} instance.
+     *
+     * The base filter of the search service is not saved.
+     *
+     * A new filter case is created and the necessary filter information is set into it.
+     *
+     * Then a side menu with the filter is opened for the user to enter the name and other properties.
+     * The user can confirm or cancel the save by finishing the task in the side menu, or by canceling/closing.
+     *
+     * @param searchService search service containing a predicate filter, we want to save
+     * @param allowedNets allowed nets of the view, that contains the search service
+     * @param searchCategories search categories available in the saved advanced search component
+     * @param viewId the viewId of the view which contained the filter.
+     * If neither the `viewId` nor the `navigationItemTaskData` attribute is set the filter will be created as a new root filter
+     * without any parent filter link. This will most likely result in the filter being less restrictive than what
+     * the user sees in the current view, since the base filter of the view will NOT be saved alongside the saved filter.
+     * @param additionalData set data request body, that is sent to the filter in addition to the default body.
+     * The default body is applied first and can be overridden by this argument.
+     * @param withDefaultCategories Whether the saved filter should be saved with
+     * the [defaultSearchCategories]{@link FilterMetadata#defaultSearchCategories} flag set to `true`, or `false`.
+     * @param inheritAllowedNets Whether the saved filter should merge its allowed nets with the allowed nets provided by
+     * the {@link BaseAllowedNetsService}.
+     * @param navigationItemTaskData if provided then it implies the filter has a parent filter that created its host dynamic view.
+     * If this is the case the case ID of the parent filter will be set into the newly created filter case.
+     * If not set it implies this is a filter originating in an in-app view and its view id will be set into the created filter.
+     * @returns an observable that emits the id of the created Filter case instance or `undefined` if the user canceled the save process,
+     * or the filter could not be saved
+     */
+    save(searchService: SearchService, allowedNets: ReadonlyArray<string>, searchCategories: ReadonlyArray<Type<Category<any>>>, viewId?: string, additionalData?: TaskSetDataRequestFields, withDefaultCategories?: boolean, inheritAllowedNets?: boolean, navigationItemTaskData?: Array<DataGroup>): Observable<SavedFilterMetadata>;
+    /**
+     * Saves the predicate filter contained in the provided {@link SearchService} instance.
+     *
+     * The base filter of the search service is not saved.
+     *
+     * A new filter case is created and the necessary filter information is set into it.
+     *
+     * @param searchService search service containing a predicate filter, we want to save
+     * @param allowedNets allowed nets of the view, that contains the search service
+     * @param searchCategories search categories available in the saved advanced search component
+     * @param viewId the viewId of the view which contained the filter.
+     * If neither the `viewId` nor the `navigationItemTaskData` attribute is set the filter will be created as a new root filter
+     * without any parent filter link. This will most likely result in the filter being less restrictive than what
+     * the user sees in the current view, since the base filter of the view will NOT be saved alongside the saved filter.
+     * @param additionalData set data request body, that is sent to the filter in addition to the default body.
+     * The default body is applied first and can be overridden by this argument.
+     * @param withDefaultCategories Whether the saved filter should be saved with
+     * the [defaultSearchCategories]{@link FilterMetadata#defaultSearchCategories} flag set to `true`, or `false`.
+     * @param inheritAllowedNets Whether the saved filter should merge its allowed nets with the allowed nets provided by
+     * the {@link BaseAllowedNetsService}.
+     * @param navigationItemTaskData if provided then it implies the filter has a parent filter that created its host dynamic view.
+     * If this is the case the case ID of the parent filter will be set into the newly created filter case.
+     * If not set it implies this is a filter originating in an in-app view and its view id will be set into the created filter.
+     * @returns an observable that emits the id of the created Filter case instance
+     */
+    createFilterCaseAndSetData(searchService: SearchService, allowedNets: ReadonlyArray<string>, searchCategories: ReadonlyArray<Type<Category<any>>>, viewId?: string, additionalData?: TaskSetDataRequestFields, withDefaultCategories?: boolean, inheritAllowedNets?: boolean, navigationItemTaskData?: Array<DataGroup>): Observable<string>;
+    protected whenInitialized(onSuccess: () => void, method?: string, onFailure?: () => void): void;
+    protected assignSetDataFinish(task: Task, data: TaskSetDataRequestBody, callChain: Subject<boolean>): void;
+    protected filterMetadataFromSearchService(searchService: SearchService, searchCategories: ReadonlyArray<Type<Category<any>>>, withDefaultCategories: boolean, inheritAllowedNets: boolean): FilterMetadata;
+}

package/lib/forms/email-submission/abstract-email-submission-form.component.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { FormSubmitEvent, HasForm } from '../has-form';
+export declare abstract class AbstractEmailSubmissionFormComponent implements HasForm, OnDestroy {
+    rootFormGroup: FormGroup;
+    displayLegalNotice: boolean;
+    formSubmit: EventEmitter<FormSubmitEvent>;
+    goBackButton: EventEmitter<void>;
+    protected constructor(formBuilder: FormBuilder);
+    ngOnDestroy(): void;
+    emitGoBack(): void;
+    onSubmit(): void;
+}

package/lib/forms/forgotten-password/abstract-forgotten-password.component.d.ts

@@ -0,0 +1,16 @@
+import { AbstractRegistrationComponent } from '../models/abstract-registration.component';
+import { SignUpService } from '../../authentication/sign-up/services/sign-up.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { FormBuilder } from '@angular/forms';
+import { UserRegistrationRequest } from '../../authentication/sign-up/models/user-registration-request';
+import { Observable } from 'rxjs';
+import { MessageResource } from '../../resources/interface/message-resource';
+import { TranslateService } from '@ngx-translate/core';
+import { OnDestroy } from '@angular/core';
+export declare abstract class AbstractForgottenPasswordComponent extends AbstractRegistrationComponent implements OnDestroy {
+    displayLegalNotice: boolean;
+    protected constructor(formBuilder: FormBuilder, signupService: SignUpService, log: LoggerService, translate: TranslateService);
+    ngOnDestroy(): void;
+    protected createRequestBody(): UserRegistrationRequest;
+    protected callRegistration(requestBody: UserRegistrationRequest): Observable<MessageResource>;
+}

package/lib/forms/has-form.d.ts

@@ -0,0 +1,10 @@
+import { FormGroup } from '@angular/forms';
+import { EventEmitter } from '@angular/core';
+export interface HasForm {
+    rootFormGroup: FormGroup;
+    formSubmit: EventEmitter<FormSubmitEvent>;
+    onSubmit(): void;
+}
+export interface FormSubmitEvent {
+    [k: string]: any;
+}

package/lib/forms/login/abstract-login-form.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { FormSubmitEvent, HasForm } from '../has-form';
+import { UserService } from '../../user/services/user.service';
+import { User } from '../../user/models/user';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+export declare abstract class AbstractLoginFormComponent implements HasForm, OnDestroy {
+    protected _userService: UserService;
+    rootFormGroup: FormGroup;
+    hidePassword: boolean;
+    loading: LoadingEmitter;
+    showSignUpButton: boolean;
+    showForgottenPasswordButton: boolean;
+    login: EventEmitter<User>;
+    resetPassword: EventEmitter<void>;
+    signUp: EventEmitter<void>;
+    formSubmit: EventEmitter<FormSubmitEvent>;
+    protected constructor(formBuilder: FormBuilder, _userService: UserService);
+    ngOnDestroy(): void;
+    onSubmit(): void;
+    resetEmit(): void;
+    signUpEmit(): void;
+    getButtonsFxLayoutAlign(): string;
+}

package/lib/forms/models/abstract-registration.component.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { FormSubmitEvent, HasForm } from '../has-form';
+import { FormGroup } from '@angular/forms';
+import { MessageResource } from '../../resources/interface/message-resource';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { SignUpService } from '../../authentication/sign-up/services/sign-up.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { UserRegistrationRequest } from '../../authentication/sign-up/models/user-registration-request';
+import { Observable } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+/**
+ * Holds the logic that is shared between `RegistrationFormComponent` and `ForgottenPasswordFormComponent`.
+ */
+export declare abstract class AbstractRegistrationComponent implements HasForm, OnDestroy {
+    protected _signupService: SignUpService;
+    protected _log: LoggerService;
+    protected _translate: TranslateService;
+    protected readonly MIN_PASSWORD_LENGTH = 8;
+    rootFormGroup: FormGroup;
+    hidePassword: boolean;
+    hideRepeatPassword: boolean;
+    formSubmit: EventEmitter<FormSubmitEvent>;
+    register: EventEmitter<MessageResource>;
+    /**
+     * Emits whenever the provided token gets resolved as invalid
+     */
+    invalidToken: EventEmitter<void>;
+    private _token;
+    private _tokenVerified;
+    loadingToken: LoadingEmitter;
+    userEmail: string;
+    protected constructor(_signupService: SignUpService, _log: LoggerService, _translate: TranslateService);
+    ngOnDestroy(): void;
+    set token(token: string);
+    get token(): string;
+    get tokenVerified(): boolean;
+    onSubmit(): void;
+    isFieldValid(formControlName: string): boolean;
+    getErrorMessage(formControlName: string): string;
+    protected abstract createRequestBody(): UserRegistrationRequest;
+    protected abstract callRegistration(requestBody: UserRegistrationRequest): Observable<MessageResource>;
+}

package/lib/forms/models/password.validator.d.ts

@@ -0,0 +1,7 @@
+import { AbstractControl } from '@angular/forms';
+/**
+ * Validator to check that passwords are the same
+ */
+export declare function passwordValidator(control: AbstractControl): {
+    [key: string]: boolean;
+} | null;

package/lib/forms/public-api.d.ts

@@ -0,0 +1,6 @@
+export * from './email-submission/abstract-email-submission-form.component';
+export * from './login/abstract-login-form.component';
+export * from './registration/abstract-registration-form.component';
+export * from './forgotten-password/abstract-forgotten-password.component';
+export * from './models/abstract-registration.component';
+export * from './has-form';

package/lib/forms/registration/abstract-registration-form.component.d.ts

@@ -0,0 +1,19 @@
+import { FormBuilder } from '@angular/forms';
+import { SignUpService } from '../../authentication/sign-up/services/sign-up.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { AbstractRegistrationComponent } from '../models/abstract-registration.component';
+import { UserRegistrationRequest } from '../../authentication/sign-up/models/user-registration-request';
+import { Observable } from 'rxjs';
+import { MessageResource } from '../../resources/interface/message-resource';
+import { TranslateService } from '@ngx-translate/core';
+import { OnDestroy } from '@angular/core';
+/**
+ * Holds the logic of the `RegistrationFormComponent`.
+ */
+export declare abstract class AbstractRegistrationFormComponent extends AbstractRegistrationComponent implements OnDestroy {
+    displayLegalNotice: boolean;
+    protected constructor(formBuilder: FormBuilder, signupService: SignUpService, log: LoggerService, translate: TranslateService);
+    ngOnDestroy(): void;
+    protected createRequestBody(): UserRegistrationRequest;
+    protected callRegistration(requestBody: UserRegistrationRequest): Observable<MessageResource>;
+}

package/lib/groups/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './services/next-group.service';
+export * from './services/active-group.service';

package/lib/groups/services/active-group.service.d.ts

@@ -0,0 +1,49 @@
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Case } from '../../resources/interface/case';
+import { NextGroupService } from './next-group.service';
+/**
+ * This service to the groups that are "active" for the logged user.
+ *
+ * The meaning of "active" can wary from application to application. And this service provides the utility to track this state.
+ *
+ * The active groups are assumed to be a subset of the groups the logged user is a member of,
+ * but this assumption is not enforced nor checked.
+ *
+ * If at most one group can be active at a time, this service provides utility methods to access this group directly.
+ *
+ * The groups are assumed to be instances of the engine group process, this is never checked nor enforced.
+ *
+ * In the default implementation the initially active groups are all the groups the logged user is a member of.
+ */
+export declare class ActiveGroupService implements OnDestroy {
+    protected _groupService: NextGroupService;
+    protected _activeGroups$: BehaviorSubject<Array<Case>>;
+    private _groupSub;
+    constructor(_groupService: NextGroupService);
+    ngOnDestroy(): void;
+    /**
+     * In the default implementation this stream copies the values of the [memberGroups$]{@link NextGroupService#memberGroups$} stream
+     * of the {@link NextGroupService}. Whenever the copies stream emits, the underlying stream in this class emits the same value.
+     *
+     * @returns an Observable of all the groups that are currently active
+     */
+    get activeGroups$(): Observable<Array<Case>>;
+    get activeGroups(): Array<Case>;
+    set activeGroups(activeGroups: Array<Case>);
+    /**
+     * @returns an Observable containing the first element of the [activeGroups$]{@link ActiveGroupService#activeGroups$} observable,
+     * or `undefined` if the contained array is empty
+     */
+    get activeGroup$(): Observable<Case | undefined>;
+    /**
+     * @returns the first element of the [activeGroups]{@link ActiveGroupService#activeGroups} array, or `undefined` if the array is empty
+     */
+    get activeGroup(): Case | undefined;
+    /**
+     * Emits a new array into the [activeGroups$]{@link ActiveGroupService#activeGroups$} observable, that contains only
+     * the provided {@link Case} object. If `undefined` is passed as argument, an empty array will be pushed into the observable.
+     * @param activeGroup the new active group case reference
+     */
+    set activeGroup(activeGroup: Case);
+}

package/lib/groups/services/next-group.service.d.ts

@@ -0,0 +1,52 @@
+import { OnDestroy } from '@angular/core';
+import { UserService } from '../../user/services/user.service';
+import { CaseResourceService } from '../../resources/engine-endpoint/case-resource.service';
+import { Case } from '../../resources/interface/case';
+import { BehaviorSubject, Observable } from 'rxjs';
+/**
+ * This service allows access to information about the groups of the currently logged user.
+ *
+ * If no user is logged an empty array is provided.
+ *
+ * If a user can be owner of at most one group, this service provides utility methods to access this group directly.
+ *
+ * The groups are assumed to be instances of the engine group process, this is never checked nor enforced.
+ */
+export declare class NextGroupService implements OnDestroy {
+    protected _userService: UserService;
+    protected _caseResourceService: CaseResourceService;
+    protected _memberGroups$: BehaviorSubject<Array<Case>>;
+    protected _ownerGroups$: BehaviorSubject<Array<Case>>;
+    private _userSub;
+    constructor(_userService: UserService, _caseResourceService: CaseResourceService);
+    ngOnDestroy(): void;
+    /**
+     * @returns an Observable of all the groups the currently logged user is a member of
+     */
+    get memberGroups$(): Observable<Array<Case>>;
+    /**
+     * @returns an Observable of all the groups the currently logged user is an owner of
+     */
+    get ownerGroups$(): Observable<Array<Case>>;
+    /**
+     * @returns an Array of all the groups the currently logged user is a member of
+     */
+    get memberGroups(): Array<Case>;
+    /**
+     * @returns an Array of all the groups the currently logged user is an owner of
+     */
+    get ownerGroups(): Array<Case>;
+    /**
+     * @returns an Observable containing the first element of the [ownerGroups$]{@link NextGroupService#ownerGroups$} observable,
+     * or `undefined` if the contained array is empty
+     */
+    get firstOwnerGroup$(): Observable<Case | undefined>;
+    /**
+     * @returns the first element of the [ownerGroups]{@link NextGroupService#ownerGroups} array, or `undefined` if the array is empty
+     */
+    get firstOwnerGroup(): Case | undefined;
+    /**
+     * @deprecated in NAE 5.6.0 - use [ownerGroups]{@link NextGroupService#ownerGroups} instead
+     */
+    get groupOfUser(): Array<Case>;
+}

package/lib/header/abstract-header-service.d.ts

@@ -0,0 +1,133 @@
+import { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';
+import { FieldsGroup } from './models/fields-group';
+import { HeaderState, HeaderStateInterface } from './header-state';
+import { OnDestroy } from '@angular/core';
+import { HeaderChange } from './models/user-changes/header-change';
+import { PetriNetReference } from '../resources/interface/petri-net-reference';
+import { HeaderType } from './models/header-type';
+import { HeaderMode } from './models/header-mode';
+import { HeaderColumn } from './models/header-column';
+import { UserPreferenceService } from '../user/services/user-preference.service';
+import { LoggerService } from '../logger/services/logger.service';
+import { LoadingEmitter } from '../utility/loading-emitter';
+import { SortDirection } from '@angular/material/sort';
+import { ViewIdService } from '../user/services/view-id.service';
+import { Net } from '../process/net';
+export declare abstract class AbstractHeaderService implements OnDestroy {
+    protected _headerType: HeaderType;
+    protected _preferences: UserPreferenceService;
+    private _viewIdService;
+    protected _logger: LoggerService;
+    static readonly DEFAULT_HEADER_COUNT = 5;
+    static readonly DEFAULT_HEADER_RESPONSIVITY = true;
+    protected _headerColumnCount$: BehaviorSubject<number>;
+    protected _preferenceColumnCount$: ReplaySubject<number>;
+    protected _responsiveHeaders$: BehaviorSubject<boolean>;
+    protected _headerState: HeaderState;
+    protected _headerChange$: Subject<HeaderChange>;
+    protected _clearHeaderSearch$: Subject<number>;
+    private _initDefaultHeaders;
+    private _initializedCount;
+    loading: LoadingEmitter;
+    fieldsGroup: Array<FieldsGroup>;
+    protected constructor(_headerType: HeaderType, _preferences: UserPreferenceService, _viewIdService: ViewIdService, _logger: LoggerService);
+    /**
+     * Provides Observable for all changes in header
+     */
+    get headerChange$(): Observable<HeaderChange>;
+    get selectedHeaders$(): Observable<Array<HeaderColumn>>;
+    get headerState(): HeaderStateInterface;
+    get headerType(): HeaderType;
+    get headerColumnCount(): number;
+    set headerColumnCount(maxColumns: number);
+    get headerColumnCount$(): Observable<number>;
+    get responsiveHeaders(): boolean;
+    set responsiveHeaders(responsiveHeaders: boolean);
+    get responsiveHeaders$(): Observable<boolean>;
+    get clearHeaderSearch$(): Observable<number>;
+    set initDefaultHeaders(defaultHeaders: Array<string>);
+    get initDefaultHeaders(): Array<string>;
+    get preferenceColumnCount$(): Observable<number>;
+    private initializeHeaderState;
+    protected initializeDefaultHeaderState(): void;
+    /**
+     * Adds `null` headers if the new count is greater than the current count.
+     *
+     * Removes extra headers if the new count is smaller than the current count.
+     */
+    protected updateHeaderColumnCount(): void;
+    setAllowedNets(allowedNets: Array<PetriNetReference>): void;
+    setTaskAllowedNets(allowedNets: Array<Net>): void;
+    /**
+     * If this view has som headers stored in it's preferences attempts to load them.
+     * If the preferences contain nonexistent headers they will be skipped.
+     *
+     * This function is NOT called by the abstract class' constructor.
+     * It is the responsibility of the child class to call it at an appropriate moment.
+     */
+    protected loadHeadersFromPreferences(): void;
+    protected abstract createMetaHeaders(): Array<HeaderColumn>;
+    /**
+     * Change sort mode for selected column all other column are set to default sort mode
+     * Emit request for sorted panels
+     * @param columnIndex index of the column that caused the sort change
+     * @param active Represents column identifier
+     * @param direction Represent one of sort modes: asd, desc and ''
+     */
+    sortHeaderChanged(columnIndex: number, active: string, direction: SortDirection): void;
+    /**
+     * Saves the search value in the appropriate column in the header
+     * Emit request for searched panels by user input query
+     */
+    headerSearchInputChanged(columnIndex: number, searchInput: any): void;
+    /**
+     * Change active header and titles of panels
+     */
+    headerColumnSelected(columnIndex: number, newHeaderColumn: HeaderColumn): void;
+    /**
+     * Change selected header mode there are three possible modes: SORT, SEARCH and EDIT
+     * @param newMode the mode that the header should change to
+     * @param saveLastMode whether the last state should be remembered.
+     * It can be restored with the [HeaderState.restoreLastMode()]{@link HeaderState#restoreLastMode} method.
+     */
+    changeMode(newMode: HeaderMode, saveLastMode?: boolean): void;
+    confirmEditMode(): void;
+    /**
+     * When user cancels the edit mode, the last saved headers state is loaded and emitted
+     * Last mode in header is reloaded as well. Possible reloaded modes: sort or search
+     */
+    revertEditMode(): void;
+    ngOnDestroy(): void;
+    /**
+     * @param newMode the {@link HeaderMode} that is being selected as the next mode
+     * @returnsa {@link HeaderChange} object with {@link ModeChangeDescription} object as it's `description`,
+     * where the `previousMode` is set to the currently selected mode and the `currentMode` is set to the provided argument
+     */
+    protected modeChangeFromCurrent(newMode: HeaderMode): HeaderChange;
+    /**
+     * @returns a {@link HeaderChange} object with {@link ModeChangeDescription} object as it's `description`,
+     * where the `previousMode` is set to [EDIT]{@link HeaderMode#EDIT} and the `currentMode` to the mode
+     * that is currently selected
+     */
+    protected modeChangeAfterEdit(): HeaderChange;
+    /**
+     * @param oldMode the {@link HeaderMode} that was previously selected
+     * @param newMode the {@link HeaderMode} that is selected now
+     * @returns a {@link HeaderChange} object with {@link ModeChangeDescription} object as it's `description`
+     * containing information about a change to the header mode
+     */
+    protected createModeChange(oldMode: HeaderMode, newMode: HeaderMode): HeaderChange;
+    /**
+     * Emits a new value into the [clearHeaderSearch$]{@link AbstractHeaderService#clearHeaderSearch$} stream, that notifies
+     * the header search component, that it should clear the input for the specified column.
+     * @param columnIndex the index of the column that should be cleared
+     */
+    clearHeaderSearch(columnIndex: number): void;
+    /**
+     * @returns the Id of the view, if the ViewIdService was injected. Returns `undefined` if the service was not injected.
+     */
+    protected getViewId(): string | undefined;
+    protected abstract saveState(): any;
+    protected abstract saveNewState(): any;
+    protected abstract restoreLastState(): any;
+}

package/lib/header/abstract-header.component.d.ts

@@ -0,0 +1,52 @@
+import { Injector, OnDestroy, OnInit } from '@angular/core';
+import { AbstractHeaderService } from './abstract-header-service';
+import { HeaderType } from './models/header-type';
+import { HeaderMode } from './models/header-mode';
+import { HeaderSearchService } from '../search/header-search-service/header-search.service';
+import { FormControl } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import { OverflowService } from './services/overflow.service';
+import { Subscription } from 'rxjs';
+export declare abstract class AbstractHeaderComponent implements OnInit, OnDestroy {
+    protected _injector: Injector;
+    protected _translate: TranslateService;
+    protected _overflowService: OverflowService;
+    protected readonly DEFAULT_COLUMN_COUNT = 6;
+    protected readonly DEFAULT_COLUMN_WIDTH = 190;
+    type: HeaderType;
+    hideEditMode: boolean;
+    headerService: AbstractHeaderService;
+    protected _headerSearch: HeaderSearchService;
+    readonly headerModeEnum: typeof HeaderMode;
+    readonly headerTypeEnum: typeof HeaderType;
+    overflowControl: FormControl;
+    columnCountControl: FormControl;
+    columnWidthControl: FormControl;
+    canOverflow: boolean;
+    subOverflowControl: Subscription;
+    subColumnCountControl: Subscription;
+    subColumnWidthControl: Subscription;
+    protected _initHeaderCount: number;
+    protected _initResponsiveHeaders: boolean;
+    constructor(_injector: Injector, _translate: TranslateService, _overflowService: OverflowService);
+    set maxHeaderColumns(count: number);
+    set responsiveHeaders(responsive: boolean);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Injects the correct {@link AbstractHeaderService} instance based on this component's type
+     */
+    protected resolveHeaderService(): void;
+    /**
+     * Sets the correct {@link AbstractHeaderService} instance to the {@link HeaderSearchService}
+     */
+    protected initializedHeaderSearch(): void;
+    clickStop($event: any): void;
+    getMinWidth(): string;
+    confirmEditMode(): void;
+    getErrorMessageWidth(): any;
+    getErrorMessageCount(): any;
+    buildErrorMessage(formControlRef: FormControl, minNumber: any): any;
+    protected initializeFormControls(exist: boolean): void;
+    protected initializeValueChanges(): void;
+}

package/lib/header/case-header/case-header.service.d.ts

@@ -0,0 +1,21 @@
+import { OnDestroy } from '@angular/core';
+import { AbstractHeaderService } from '../abstract-header-service';
+import { HeaderColumn } from '../models/header-column';
+import { UserPreferenceService } from '../../user/services/user-preference.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { Subscription } from 'rxjs';
+import { OverflowService } from '../services/overflow.service';
+import { ViewIdService } from '../../user/services/view-id.service';
+import { AllowedNetsService } from '../../allowed-nets/services/allowed-nets.service';
+export declare class CaseHeaderService extends AbstractHeaderService implements OnDestroy {
+    protected _allowedNetsService: AllowedNetsService;
+    protected overflowService: OverflowService;
+    protected subAllowedNets: Subscription;
+    constructor(_allowedNetsService: AllowedNetsService, preferences: UserPreferenceService, logger: LoggerService, viewIdService: ViewIdService, overflowService: OverflowService, naeDefaultHeaders: Array<string>);
+    protected createMetaHeaders(): Array<HeaderColumn>;
+    ngOnDestroy(): void;
+    updateColumnCount(): void;
+    protected saveState(): void;
+    protected saveNewState(): void;
+    protected restoreLastState(): void;
+}

package/lib/header/case-header/case-menta-enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum CaseMetaField {
+    MONGO_ID = "mongoId",
+    VISUAL_ID = "visualId",
+    TITLE = "title",
+    AUTHOR = "author",
+    CREATION_DATE = "creationDate"
+}

package/lib/header/header-modes/abstract-header-mode.component.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class AbstractHeaderModeComponent {
+    overflowWidth: string;
+    constructor();
+    getMinWidth(): string;
+}

package/lib/header/header-modes/edit-mode/abstract-edit-mode.component.d.ts

@@ -0,0 +1,28 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { AbstractHeaderService } from '../../abstract-header-service';
+import { HeaderColumn } from '../../models/header-column';
+import { FormControl } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable, Subscription } from 'rxjs';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+export interface HeaderOption {
+    groupTitle: string;
+    fields: Array<HeaderColumn>;
+}
+export declare abstract class AbstractEditModeComponent extends AbstractHeaderModeComponent implements OnInit, OnDestroy {
+    protected _translate: TranslateService;
+    protected _log: LoggerService;
+    formControls: Array<FormControl>;
+    filterOptions: Array<Observable<Array<HeaderOption>>>;
+    protected subHeader: Subscription;
+    headerService: AbstractHeaderService;
+    protected constructor(_translate: TranslateService, _log: LoggerService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected updateHeaderCount(newCount: number): void;
+    protected _filter(value: any): Array<HeaderOption>;
+    headerColumnSelected(columnIndex: number, newHeaderColumn: HeaderColumn): void;
+    renderSelection: (header: any) => any;
+    private checkImmediateTitle;
+}

package/lib/header/header-modes/loading-mode/abstract-loading-mode.component.d.ts

@@ -0,0 +1,8 @@
+import { OnInit } from '@angular/core';
+import { AbstractHeaderService } from '../../abstract-header-service';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+export declare abstract class AbstractLoadingModeComponent extends AbstractHeaderModeComponent implements OnInit {
+    headerService: AbstractHeaderService;
+    constructor();
+    ngOnInit(): void;
+}