@netgrif/components-core 6.0.1

package/lib/task-content/task-content/abstract-task-content.component.d.ts

@@ -0,0 +1,263 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { DatafieldGridLayoutElement } from '../model/datafield-grid-layout-element';
+import { FieldConverterService } from '../services/field-converter.service';
+import { TaskContentService } from '../services/task-content.service';
+import { PaperViewService } from '../../navigation/quick-panel/components/paper-view.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskEventNotification } from '../model/task-event-notification';
+import { TaskEventService } from '../services/task-event.service';
+import { DataGroup } from '../../resources/interface/data-groups';
+import { DataField } from '../../data-fields/models/abstract-data-field';
+import { DataGroupCompact, DataGroupHideEmptyRows, DataGroupLayout, DataGroupLayoutType } from '../../resources/interface/data-group-layout';
+import { FieldAlignment } from '../../resources/interface/field-alignment';
+import { FieldTypeResource } from '../model/field-type-resource';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { BehaviorSubject, Observable, Subscription } from 'rxjs';
+import { AsyncRenderingConfiguration } from '../model/async-rendering-configuration';
+import { SplitDataGroup } from '../model/split-data-group';
+import { Subgrid } from '../model/subgrid';
+import { IncrementingCounter } from '../../utility/incrementing-counter';
+export declare abstract class AbstractTaskContentComponent implements OnDestroy {
+    protected _fieldConverter: FieldConverterService;
+    taskContentService: TaskContentService;
+    protected _paperView: PaperViewService;
+    protected _logger: LoggerService;
+    protected _taskEventService: TaskEventService;
+    readonly DEFAULT_LAYOUT_TYPE = DataGroupLayoutType.LEGACY;
+    readonly DEFAULT_FIELD_ALIGNMENT = FieldAlignment.CENTER;
+    readonly DEFAULT_ASYNC_RENDERING_CONFIGURATION: AsyncRenderingConfiguration;
+    readonly DEFAULT_COMPACT_DIRECTION = DataGroupCompact.NONE;
+    readonly DEFAULT_HIDE_EMPTY_ROWS = DataGroupHideEmptyRows.ALL;
+    /**
+     * Indicates whether data is being loaded from backend, or if it is being processed.
+     */
+    loading$: LoadingEmitter;
+    /**
+     * Emits `true` if there is at least one data field, that should be displayed. Emits `false` otherwise.
+     */
+    hasDataToDisplay$: Observable<boolean>;
+    /**
+     * Exists to allow references to the enum in the HTML
+     */
+    fieldTypeResource: typeof FieldTypeResource;
+    /**
+     * The translate text that should be displayed when the task contains no data.
+     *
+     * If a falsy value is provided the default text is displayed
+     */
+    noDataText: string;
+    /**
+     * The icon that should be displayed when the task contains no data.
+     *
+     * If a falsy value is provided the default icon is displayed
+     */
+    noDataIcon: string;
+    /**
+     * Whether an icon should be displayed when the no data message is shown.
+     *
+     * An icon is displayed by default
+     */
+    displayNoDataIcon: boolean;
+    /**
+     * Emits notifications about task events
+     */
+    taskEvent: EventEmitter<TaskEventNotification>;
+    /**
+     * The data fields that are currently displayed
+     */
+    protected _dataSource$: BehaviorSubject<Array<Subgrid>>;
+    protected _subTaskContent: Subscription;
+    protected _subTaskEvent: Subscription;
+    protected _asyncRenderingConfig: AsyncRenderingConfiguration;
+    protected _asyncRenderTimeout: number;
+    protected _defaultAlignment: FieldAlignment;
+    protected _defaultCompactDirection: DataGroupCompact;
+    protected _defaultHideEmptyRows: DataGroupHideEmptyRows;
+    protected _defaultNumberOfCols: number;
+    protected _subgridIdCounter: IncrementingCounter;
+    protected _existingSubgridIds: Set<string>;
+    /**
+     * Defines the row height of one row in task content
+     */
+    protected rowHeight: number;
+    protected constructor(_fieldConverter: FieldConverterService, taskContentService: TaskContentService, _paperView: PaperViewService, _logger: LoggerService, _taskEventService?: TaskEventService, asyncRenderingConfiguration?: AsyncRenderingConfiguration);
+    ngOnDestroy(): void;
+    get taskId(): string;
+    get dataSource(): Array<Subgrid>;
+    /**
+     * @returns the number of columns as specified by the tasks layout property, or 4 if no value is specified.
+     */
+    getNumberOfFormColumns(): number;
+    isPaperView(): boolean;
+    /**
+     * @param item an object containing grid element information
+     * @returns the Angular flex layouts alignment property for individual data fields based on
+     * the layout configuration specified by the process
+     */
+    getItemAlignment(item: DatafieldGridLayoutElement): string;
+    /**
+     * Computes component height if the rows attribute of task layout is set.
+     */
+    resolveContentHeightCss(): string;
+    /**
+     * Decides whether there is a fixed number of rows and it need-s scrolling
+     */
+    scrollingNeeded(): boolean;
+    /**
+     * @returns the default alignment for the displayed task that can be overridden by fields individual property.
+     * If te task specifies no default value the [global default]{@link AbstractTaskContentComponent#DEFAULT_FIELD_ALIGNMENT}
+     * value is returned.
+     */
+    protected computeDefaultLayoutConfiguration(): void;
+    /**
+     * Computes the layout data for the tasks grid layout and sets the result to the public properties
+     * of this class that are then bound to HTML.
+     * @param dataGroups the data groups that should be laid out
+     */
+    computeLayoutData(dataGroups: Array<DataGroup>): void;
+    protected renderFields(subgrids: Map<string, Subgrid>): void;
+    protected spreadFieldRenderingOverTime(subgrids: Array<Subgrid>, iteration?: number): void;
+    /**
+     * Clones the content of the data groups to prevent unintentional memory accesses to source data.
+     * Rearranges the data groups to accommodate taskrefs. Filters out hidden and forbidden fields.
+     * @param dataGroups
+     * @returns the preprocesses data groups
+     */
+    protected preprocessDataGroups(dataGroups: Array<DataGroup>): Array<DataGroup>;
+    /**
+     * Creates a duplicate of the provided data group array and filters away any fields and data groups that are marked as hidden.
+     * Because of the duplication the filtering doesn't affect the original instances and they remain unchanged.
+     * @param dataGroups the data groups that should be filtered
+     * @returns the filtered duplicated data groups
+     */
+    protected cloneAndFilterHidden(dataGroups: Array<DataGroup>): Array<DataGroup>;
+    protected isTaskRef(field: DataField<unknown>): boolean;
+    /**
+     * Sorts the input data group based on the Y coordinate of the fields and splits it into parts on the first task ref.
+     * If some fields appear before the first task ref they are extracted into a new [startGroup]{@link SplitDataGroup#startGroup}.
+     * If some fields appear after the first task ref they are extracted into a new [endGroup]{@link SplitDataGroup#endGroup}.
+     * @param dataGroup
+     * @protected
+     */
+    protected splitDataGroupOnTaskRef(dataGroup: DataGroup): SplitDataGroup;
+    /**
+     * Computes the layout data for a single data group with grid layout. The resulting layout is saved into the input objects.
+     * @param dataGroup the data group that should be laid out into a grid
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    protected computeGridLayout(dataGroup: DataGroup, subgrid: Subgrid): void;
+    /**
+     * Applies the empty row removal and field compacting rules based on the provided layout configuration.
+     *
+     * The input grid is modified in place.
+     * @param grid the state of the grid that should be modified
+     * @param layout configuration of the applied compacting rules
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    protected collapseGridEmptySpace(grid: Array<Array<string>>, layout: DataGroupLayout, subgrid: Subgrid): void;
+    /**
+     * Moves any element as far UP as it can go. Elements that were originally declared in the same row might end up in different rows.
+     * Resulting trailing empty rows are removed.
+     *
+     * The input grid is modified in place.
+     * @param grid the state of the grid that should be modified
+     * @param hideRows configuration for empty row removal during the compacting process
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    protected compactFieldsUp(grid: Array<Array<string>>, hideRows: DataGroupHideEmptyRows, subgrid: Subgrid): void;
+    /**
+     * Removes rows from the grid that only contain empty elements (are empty). The grid is modified in place.
+     * @param grid the grid that should have it's empty rows removed
+     * @param firstRow the 0 based index of the first row that should be checked. Use 0 to start from the beginning of the grid.
+     *
+     * If no value is provided, the grid will be checked from the first row.
+     *
+     * @param lastRow the 0 based index of the row where the checking should end. The row with this index is not checked.
+     *
+     * If no value is provided the entire grid from the `firstRow` will be checked.
+     *
+     * If a value that is smaller or equal to the `firstRow` is provided no checks will be preformed.
+     */
+    protected removeEmptyRows(grid: Array<Array<string>>, firstRow?: number, lastRow?: number): void;
+    /**
+     * Determines the dimensions of the element in the grid with its top-left corner at the specified position
+     * @param grid the grid of elements
+     * @param x the X coordinate of the desired elements top-left corner
+     * @param y the Y coordinate of the desired elements top-left corner
+     * @param subgrid the object that holds the context of the computed layouting unit
+     * @returns the width and height of the specified element
+     */
+    protected getElementDimensions(grid: Array<Array<string>>, x: number, y: number, subgrid: Subgrid): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Determines whether the specified area in the grid contains no elements, or not
+     * @param grid the grid of elements
+     * @param x the X coordinate of the tested areas top-left corner
+     * @param y the Y coordinate of the tested areas top-left corner
+     * @param width the width of the tested area
+     * @param height the height of the tested area
+     */
+    protected isAreaEmpty(grid: Array<Array<string>>, x: number, y: number, width: number, height: number): boolean;
+    /**
+     * Computes the layout data for a single data group with flow layout. The resulting layout is saved into the input objects.
+     * @param dataGroup the data group that should be laid out into a grid using the flow algorithm
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    protected computeFlowLayout(dataGroup: DataGroup, subgrid: Subgrid): void;
+    /**
+     * Computes the layout data for a single data group with legacy layout. The resulting layout is saved into the input objects.
+     *
+     * The legacy layout forces the number of columns to be 4 and logs a warning if this was not the case.
+     * @param dataGroup the data group that should be laid out into a grid using the legacy algorithm used in NAE versions < 4.0.0
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    protected computeLegacyLayout(dataGroup: DataGroup, subgrid: Subgrid): void;
+    /**
+     * Lays out the fields from left to right, from top to bottom. If the width is greater than 1 and the block of flowed fields doesn't fit
+     * neatly into the columns (if the width of a single field is not a divisor of column count), then the entire block of fields is
+     * left aligned. The last row of fields is aligned to the left, center or right based on the data groups property.
+     * If the last row cannot be aligned to the exact center it is offset one grid tile to the left.
+     * @param dataGroup the data group that should be laid out into a grid
+     * @param subgrid the object that holds the context of the computed layouting unit
+     * @param fieldWidth the number of grid tiles, that should be occupied by each field
+     */
+    protected flowFields(dataGroup: DataGroup, subgrid: Subgrid, fieldWidth: number): void;
+    /**
+     * @param width width of the row
+     * @param content the value that should be used to fill all elements in the row
+     */
+    protected newGridRow(width: number, content?: string): Array<string>;
+    /**
+     * Fills the specified rectangular area with the specified value in the provided grid.
+     *
+     * If the specified area contains values other than the empty string an error will be thrown.
+     * @param grid the grid that should be modified
+     * @param y the 0 based row index of the top-left corner of the filled area
+     * @param x the 0 based column index of the top-left corner of the filled area
+     * @param width the width of the filled area
+     * @param value the value that is set into every cell of the grid inside the specified area
+     * @param height the height of the filled area
+     * @param checkOccupants whether the filled area should be checked for other elements.
+     * If a check is performed an error will be thrown if elements are found.
+     */
+    protected occupySpace(grid: Array<Array<string>>, y: number, x: number, width: number, value: string, height?: number, checkOccupants?: boolean): void;
+    /**
+     * @param index the index of the checked element within its data group
+     * @param dataGroup the checked data group
+     * @param fieldsPerRow the number of fields that is required to fill an entire row
+     * @returns whether the field at the given index is within the last row of elements of the provided data group.
+     * Note that if the last row contains enough elements to be completely filled this method returns `false`.
+     */
+    protected isLastRow(index: number, dataGroup: DataGroup, fieldsPerRow: number): boolean;
+    /**
+     * Destroys the previous content and pushes the new content into the stream
+     * @param content the new content
+     */
+    protected renderContent(content?: Array<Subgrid>): void;
+    protected createSubgridId(dataGroup: DataGroup): string;
+    trackBySubgridFn: (index: number, subgrid: Subgrid) => string;
+    trackByFn: (index: number, element: DatafieldGridLayoutElement) => string;
+    protected trackByDatafields(index: number, element: DatafieldGridLayoutElement): string;
+}

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

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { LanguageService } from '../translate/language.service';
+export declare abstract class AbstractToolbarComponent implements OnInit {
+    protected translate: TranslateService;
+    protected selectLangService: LanguageService;
+    loggedUser: string;
+    appName: string;
+    logoSrc: string;
+    logoAlt: string;
+    constructor(translate: TranslateService, selectLangService: LanguageService);
+    ngOnInit(): void;
+    setLang(lang: string): void;
+    activeLang(lang: string): boolean;
+}

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

@@ -0,0 +1 @@
+export * from './abstract-toolbar.component';

package/lib/translate/language.service.d.ts

@@ -0,0 +1,20 @@
+import { OnDestroy } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable, Subscription } from 'rxjs';
+import { UserPreferenceService } from '../user/services/user-preference.service';
+import { LoggerService } from '../logger/services/logger.service';
+export declare class LanguageService implements OnDestroy {
+    private _translate;
+    private _preferenceService;
+    private _logger;
+    private _langChange$;
+    private readonly _LANG_MATCHER;
+    private readonly _DEFAULT_LANG;
+    protected subPreference: Subscription;
+    protected subTranslate: Subscription;
+    constructor(_translate: TranslateService, _preferenceService: UserPreferenceService, _logger: LoggerService);
+    ngOnDestroy(): void;
+    setLanguage(lang: string, saveToPreferences?: boolean): void;
+    getLanguage(): string;
+    getLangChange$(): Observable<string>;
+}

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

@@ -0,0 +1,2 @@
+export * from './language.service';
+export * from './translate-lib.module';

package/lib/translate/translate-interceptor.d.ts

@@ -0,0 +1,8 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { LanguageService } from './language.service';
+export declare class TranslateInterceptor implements HttpInterceptor {
+    private _select;
+    constructor(_select: LanguageService);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+}

package/lib/translate/translate-lib.module.d.ts

@@ -0,0 +1,5 @@
+import { HttpClient } from '@angular/common/http';
+import { TranslateHttpLoader } from '@ngx-translate/http-loader';
+export declare function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader;
+export declare class TranslateLibModule {
+}

package/lib/user/components/user-card/abstract-user-card.component.d.ts

@@ -0,0 +1,22 @@
+import { Injector, OnDestroy, OnInit } from '@angular/core';
+import { User } from '../../models/user';
+import { TooltipPosition } from '@angular/material/tooltip';
+import { Subscription } from 'rxjs';
+import { AbstractNavigationResizableDrawerComponent } from '../../../navigation/navigation-drawer/abstract-navigation-resizable-drawer.component';
+export declare type Mode = 'full' | 'horizontal' | 'vertical' | 'icon';
+export declare type IconStyle = 'large' | 'small';
+export declare abstract class AbstractUserCardComponent extends AbstractNavigationResizableDrawerComponent implements OnInit, OnDestroy {
+    protected _injector: Injector;
+    user: User;
+    mode: Mode;
+    tooltipPosition: TooltipPosition;
+    iconStyle: IconStyle;
+    link: string;
+    protected subUser: Subscription;
+    constructor(_injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    userBannerExists(): boolean;
+    get userBanner(): string;
+    get userAvatar(): string;
+}

package/lib/user/models/iuser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A generic representation of a User object. All User and User-like instances implement this interface that holds the most
+ * basic User attributes.
+ */
+export interface IUser {
+    id: string;
+    /**
+     * **Example:** example@netgrif.com
+     */
+    email: string;
+    /**
+     * **Example:** Example
+     */
+    name: string;
+    /**
+     * **Example:** Netgrif
+     */
+    surname: string;
+}

package/lib/user/models/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './iuser';
+export * from './user';
+export * from './view-id-injection-tokens';

package/lib/user/models/user.d.ts

@@ -0,0 +1,29 @@
+import { ProcessRole } from '../../resources/interface/process-role';
+import { IUser } from './iuser';
+/**
+ * The user object that is used by the frontend in its logic.
+ */
+export declare class User implements IUser {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    authorities: Array<string>;
+    roles: Array<ProcessRole>;
+    groups?: Array<string>;
+    nextGroups?: Array<string>;
+    constructor(id: string, email: string, firstName: string, lastName: string, authorities: Array<string>, roles: Array<ProcessRole>, groups?: Array<string>, nextGroups?: Array<string>);
+    get fullName(): string;
+    /**
+     * Synonym for `firstName`.
+     */
+    get name(): string;
+    /**
+     * Synonym for `lastName`.
+     */
+    get surname(): string;
+    /**
+     * @returns `true` if the User object represents an empty user, `false` otherwise.
+     */
+    isEmpty(): boolean;
+}

package/lib/user/models/view-id-injection-tokens.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export declare const NAE_VIEW_ID: InjectionToken<string>;
+export declare const NAE_VIEW_ID_SEGMENT: InjectionToken<string>;

package/lib/user/profile/abstract-profile.component.d.ts

@@ -0,0 +1,14 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { User } from '../models/user';
+import { UserService } from '../services/user.service';
+import { Subscription } from 'rxjs';
+export declare abstract class AbstractProfileComponent implements OnInit, OnDestroy {
+    protected _userService: UserService;
+    user: User;
+    protected subUser: Subscription;
+    constructor(_userService: UserService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get userBanner(): string;
+    get userAvatar(): string;
+}

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

@@ -0,0 +1,8 @@
+export * from './models/public-api';
+export * from './services/user.service';
+export * from './services/user-preference.service';
+export * from './services/user-comparator.service';
+export * from './services/user-list.service';
+export * from './services/view-id.service';
+export * from './components/user-card/abstract-user-card.component';
+export * from './profile/abstract-profile.component';

package/lib/user/services/user-comparator.service.d.ts

@@ -0,0 +1,7 @@
+import { UserService } from './user.service';
+import { IUser } from '../models/iuser';
+export declare class UserComparatorService {
+    private _userService;
+    constructor(_userService: UserService);
+    compareUsers(user: IUser): boolean;
+}

package/lib/user/services/user-list.service.d.ts

@@ -0,0 +1,111 @@
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { MessageResource } from '../../resources/interface/message-resource';
+import { UserResource } from '../../resources/interface/user-resource';
+export interface UserListItem extends UserResource {
+    selected: boolean;
+    roles: Set<string>;
+    toggle(): void;
+}
+export interface RolesObject {
+    [k: string]: RoleObject;
+}
+interface RoleObject {
+    perform?: boolean;
+    delegate?: boolean;
+    view?: boolean;
+}
+/**
+ * Performs paged loading users from backend for [UserAssignComponent]{@link AbstractUserAssignComponent}.
+ */
+export declare class UserListService implements OnDestroy {
+    private _resources;
+    private _log;
+    private _snackbar;
+    private _translate;
+    /**
+     * UserValue array stream, that represents users loading from backend.
+     */
+    private readonly _users$;
+    /**
+     * Emit users loading status from backend.
+     */
+    private _loading$;
+    /**
+     * Number stream of next page users list, that to be requested from backend.
+     */
+    private _nextPage$;
+    /**
+     * Signals the end of loaded users.
+     */
+    private _endOfData;
+    /**
+     * Necessary for pagination parameters in user assign loading from backend.
+     */
+    private _pagination;
+    /**
+     * Signals if response is empty or no.
+     */
+    private _clear;
+    /**
+     * The search content that should be applied to the request
+     */
+    private _searchQuery;
+    /**
+     * Roles that should be applied to the request
+     */
+    rolesQuery: Array<string>;
+    /**
+     * negative Roles that should be applied to the request
+     */
+    negativeRolesQuery: Array<string>;
+    private _updateProgress$;
+    private _usersReload$;
+    /**
+     * Inject services.
+     * Initialize declared attributes.
+     *
+     * Loading and mapped stream of users.
+     * @param _resources Loading users from backend.
+     * @param _log Logging action status.
+     * @param _snackbar Display info about loading from backend for user.
+     * @param _translate Translate messages for user.
+     */
+    constructor(_resources: UserResourceService, _log: LoggerService, _snackbar: SnackBarService, _translate: TranslateService);
+    ngOnDestroy(): void;
+    get loading(): boolean;
+    get loading$(): Observable<boolean>;
+    get usersReload$(): Observable<void>;
+    get users$(): Observable<Array<UserListItem>>;
+    get updating$(): Observable<boolean>;
+    get totalUsers(): number;
+    /**
+     * Get all users from backend and mapped to [UserValue]{@link UserValue} interface with catching errors.
+     * @param page Page number that is requested. / Next page users list.
+     */
+    loadPage(page: number): Observable<{
+        [k: string]: UserListItem;
+    }>;
+    /**
+     * Set value to nextPage stream as next page users list.
+     * @param lastRendered Last rendered user index.
+     * @param totalRendered Total loaded size users.
+     */
+    nextPage(lastRendered: number, totalRendered: number): void;
+    /**
+     * Reload page with users.
+     */
+    reload(newSearchQuery?: string): void;
+    updateRoles(selectedUsers: Array<UserListItem>, selectedRoles?: Array<string>): Observable<Array<MessageResource>>;
+    /**
+     * Returns HttpParams with page params addition.
+     * @param params Existing HttpParams.
+     * @param page Page number that is requested. / Next page users list.
+     */
+    private addPageParams;
+}
+export {};

package/lib/user/services/user-preference.service.d.ts

@@ -0,0 +1,37 @@
+import { OnDestroy } from '@angular/core';
+import { Preferences } from '../../resources/interface/preferences';
+import { UserService } from './user.service';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { Observable, Subject, Subscription } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+export declare class UserPreferenceService implements OnDestroy {
+    protected _userService: UserService;
+    protected _userResourceService: UserResourceService;
+    protected _logger: LoggerService;
+    protected _snackbar: SnackBarService;
+    protected _translate: TranslateService;
+    protected _preferences: Preferences;
+    protected _preferencesChanged$: Subject<void>;
+    protected _sub: Subscription;
+    protected _subAnonym: Subscription;
+    _drawerWidthChanged$: Subject<number>;
+    protected _anonym: boolean;
+    constructor(_userService: UserService, _userResourceService: UserResourceService, _logger: LoggerService, _snackbar: SnackBarService, _translate: TranslateService);
+    ngOnDestroy(): void;
+    setTaskFilters(viewId: string, value: Array<string>): void;
+    getTaskFilters(viewId: string): Array<string> | undefined;
+    setCaseFilters(viewId: string, value: Array<string>): void;
+    getCaseFilters(viewId: string): Array<string> | undefined;
+    setHeaders(viewId: string, value: Array<string>): void;
+    getHeaders(viewId: string): Array<string> | undefined;
+    setLocale(locale: string): void;
+    getLocale(): string;
+    set drawerWidth(drawerWidth: number);
+    get drawerWidth(): number;
+    get preferencesChanged$(): Observable<void>;
+    protected _savePreferences(): void;
+    protected resultMessage(resultMessage: any): void;
+    protected _emptyPreferences(): Preferences;
+}

package/lib/user/services/user.service.d.ts

@@ -0,0 +1,65 @@
+import { OnDestroy } from '@angular/core';
+import { Observable, ReplaySubject, Subscription } from 'rxjs';
+import { ProcessRole } from '../../resources/interface/process-role';
+import { User } from '../models/user';
+import { Credentials } from '../../authentication/models/credentials';
+import { AuthenticationService } from '../../authentication/services/authentication/authentication.service';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { UserTransformer } from '../../authentication/models/user.transformer';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SessionService } from '../../authentication/session/services/session.service';
+import { AnonymousService } from '../../authentication/anonymous/anonymous.service';
+export declare class UserService implements OnDestroy {
+    protected _authService: AuthenticationService;
+    protected _userResource: UserResourceService;
+    protected _userTransform: UserTransformer;
+    protected _log: LoggerService;
+    protected _session: SessionService;
+    protected _anonymousService: AnonymousService;
+    protected _user: User;
+    protected _userChange$: ReplaySubject<User>;
+    protected _anonymousUserChange$: ReplaySubject<User>;
+    protected _loginCalled: boolean;
+    protected _subAuth: Subscription;
+    protected _subAnonym: Subscription;
+    private _publicLoadCalled;
+    constructor(_authService: AuthenticationService, _userResource: UserResourceService, _userTransform: UserTransformer, _log: LoggerService, _session: SessionService, _anonymousService: AnonymousService);
+    get user(): User;
+    get user$(): Observable<User>;
+    get anonymousUser$(): Observable<User>;
+    ngOnDestroy(): void;
+    /**
+     * Check if user has specified authority.
+     * @param authority - If provided authority is array of authorities.
+     *                    Method make intersection of the provided authorities and user's authorities.
+     *                    If calculated intersection isn't empty returns true, otherwise false.
+     */
+    hasAuthority(authority: Array<string> | string): boolean;
+    hasRole(role: ProcessRole): boolean;
+    /**
+     * Checks whether the user has role with a specific stringId
+     * @param roleStringId ID of the role we want to check
+     */
+    hasRoleById(roleStringId: string): boolean;
+    /**
+     * Checks whether the user has role with the specified identifier in a process with the specified identifier (any version)
+     * @param roleIdentifier identifier (import ID) of the role we want to check
+     * @param netIdentifier identifier (import ID) of the process the role is defined in
+     */
+    hasRoleByIdentifier(roleIdentifier: string, netIdentifier: string): boolean;
+    /**
+     * Checks whether the user has role with the specified name in a process with the specified identifier (any version)
+     * @param roleName name of the role we want to check
+     * @param netIdentifier identifier (import ID) of the process the role is defined in
+     */
+    hasRoleByName(roleName: string, netIdentifier: string): boolean;
+    login(credentials: Credentials): Observable<User>;
+    logout(): Observable<object>;
+    reload(): void;
+    protected emptyUser(): User;
+    protected loadUser(): void;
+    loadPublicUser(): void;
+    clearUser(): void;
+    protected publishUserChange(): void;
+    protected publishAnonymousUserChange(): void;
+}