@netgrif/components-core 6.0.1

package/lib/side-menu/content-components/public-api.d.ts

@@ -0,0 +1,17 @@
+export * from './import-net/abstract-import-net.component';
+export * from './new-case/abstract-new-case.component';
+export * from './user-assign/abstract-user-assign.component';
+export * from './user-assign/user-assign-list/abstract-user-assign-list.component';
+export * from './user-assign/user-assign-list/user-assign-item/abstract-user-assign-item.component';
+export * from './filter-selector/abstract-filter-selector.component';
+export * from './filter-selector/filter-selector-list-item/abstract-filter-selector-list-item.component';
+export * from './option-selector/abstract-option-selector.component';
+export * from './save-filter/abstract-save-filter.component';
+export * from './load-filter/abstract-load-filter.component';
+export * from './filter-selector/model/filter-selector-injection-data';
+export * from './option-selector/model/option-selector-injection-data';
+export * from './user-assign/model/user-list-injected-data';
+export * from './save-filter/model/save-filter-injection-data';
+export * from './load-filter/model/load-filter-injection-data';
+export * from './injection-tokens';
+export * from './new-case/model/new-case-injection-data';

package/lib/side-menu/content-components/save-filter/abstract-save-filter.component.d.ts

@@ -0,0 +1,15 @@
+import { SideMenuControl } from '../../models/side-menu-control';
+import { SaveFilterInjectionData } from './model/save-filter-injection-data';
+import { AbstractTaskView } from '../../../view/task-view/abstract-task-view';
+import { TaskViewService } from '../../../view/task-view/service/task-view.service';
+import { TaskEventNotification } from '../../../task-content/model/task-event-notification';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { UserFiltersService } from '../../../filter/user-filters.service';
+export declare abstract class AbstractSaveFilterComponent extends AbstractTaskView {
+    protected _sideMenuControl: SideMenuControl;
+    protected _userFilterService: UserFiltersService;
+    protected _log: LoggerService;
+    protected _injectedData: SaveFilterInjectionData;
+    protected constructor(_sideMenuControl: SideMenuControl, _userFilterService: UserFiltersService, _log: LoggerService, taskViewService: TaskViewService);
+    processTaskEvents(notification: TaskEventNotification): void;
+}

package/lib/side-menu/content-components/save-filter/model/save-filter-injection-data.d.ts

@@ -0,0 +1,4 @@
+import { SideMenuInjectionData } from '../../../models/side-menu-injection-data';
+export interface SaveFilterInjectionData extends SideMenuInjectionData {
+    newFilterCaseId: string;
+}

package/lib/side-menu/content-components/user-assign/abstract-user-assign.component.d.ts

@@ -0,0 +1,46 @@
+import { UserValue } from '../../../data-fields/user-field/models/user-value';
+import { FormControl } from '@angular/forms';
+import { SideMenuControl } from '../../models/side-menu-control';
+import { UserListInjectedData } from './model/user-list-injected-data';
+import { ProcessRole } from '../../../resources/interface/process-role';
+/**
+ * Is the main - parent component of the entire user assignment in the side menu.
+ *
+ * Holds logic link of the [UserAssignListComponent]{@link AbstractUserAssignListComponent}
+ * along with searching, selecting, and then assigning to the user field.
+ */
+export declare abstract class AbstractUserAssignComponent {
+    protected _sideMenuControl: SideMenuControl;
+    /**
+     * Form control for user search value.
+     */
+    searchUserControl: FormControl;
+    /**
+     * Data about preselected user send from [UserFieldComponent]{@link AbstractUserFieldComponent}.
+     */
+    injectedData: UserListInjectedData;
+    /**
+     * Value of the current selected user.
+     */
+    protected _currentUser: UserValue;
+    /**
+     * Inject and set data send from [UserFieldComponent]{@link AbstractUserFieldComponent} if the user is preselected.
+     * @param _sideMenuControl Contains [Roles]{@link ProcessRole} and [UserValue]{@link UserValue}.
+     */
+    protected constructor(_sideMenuControl: SideMenuControl);
+    /**
+     * The user that is initially selected, or `undefined` if none is
+     */
+    get initiallySelectedUser(): UserValue | undefined;
+    get roles(): Array<string> | Array<ProcessRole>;
+    get negativeRoles(): Array<string> | Array<ProcessRole>;
+    /**
+     * On select user from users assign list publish side menu with selected user as data and message about selection.
+     * @param user Select current user as [UserValue]{@link UserValue}
+     */
+    userWasSelected(user: UserValue): void;
+    /**
+     * On assign button close side menu with selected user as data and message about confirm.
+     */
+    assign(): void;
+}

package/lib/side-menu/content-components/user-assign/model/user-list-injected-data.d.ts

@@ -0,0 +1,11 @@
+import { SideMenuInjectionData } from '../../../models/side-menu-injection-data';
+import { ProcessRole } from '../../../../resources/interface/process-role';
+import { UserValue } from '../../../../data-fields/user-field/models/user-value';
+/**
+ * Interface that represents the input data to the side menu for the user assign component.
+ */
+export interface UserListInjectedData extends SideMenuInjectionData {
+    roles: Array<string> | Array<ProcessRole>;
+    value: UserValue;
+    negativeRoles?: Array<string> | Array<ProcessRole>;
+}

package/lib/side-menu/content-components/user-assign/user-assign-list/abstract-user-assign-list.component.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { FormControl } from '@angular/forms';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { RolesObject, UserListItem, UserListService } from '../../../../user/services/user-list.service';
+import { UserValue } from '../../../../data-fields/user-field/models/user-value';
+/**
+ * Is responsible for displaying, filtering, loading and selecting users.
+ */
+export declare abstract class AbstractUserAssignListComponent implements OnInit, OnDestroy {
+    protected _userListService: UserListService;
+    /**
+     * The time that must elapse since last keypress in search input before a search request is sent
+     */
+    protected SEARCH_DEBOUNCE_TIME: number;
+    /**
+     * The user that is initially selected, or `undefined` if none is
+     */
+    initiallySelectedUser: UserValue | undefined;
+    /**
+     * Search user form control from parent component.
+     */
+    searchUserControl: FormControl;
+    /**
+     * Roles for user search
+     */
+    roles: RolesObject | Array<string>;
+    /**
+     * Negative Roles for user search
+     */
+    negativeRoles: RolesObject | Array<string>;
+    /**
+     * Emit selected user to parent component.
+     */
+    userSelected: EventEmitter<UserValue>;
+    /**
+     * Viewport reference to virtual scroll.
+     */
+    viewport: CdkVirtualScrollViewport;
+    /**
+     * UserValue array stream, that represents users loading from backend.
+     */
+    users$: Observable<Array<UserListItem>>;
+    /**
+     * Stream of selected user with his value that we can subscribe to like the observable.
+     */
+    protected _selectedUser$: ReplaySubject<string>;
+    /**
+     * Inject and initialize attributes.
+     * @param _userListService Service to get paginated loading users from backend.
+     */
+    constructor(_userListService: UserListService);
+    /**
+     * On initialize component set value to stream selectedUser with preselected user.
+     * Observes search user control stream on value change.
+     */
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    trackBy(index: number, item: UserValue): any;
+    get loading(): boolean;
+    /**
+     * ID of the currently selected user
+     */
+    get selectedUser$(): Observable<string>;
+    /**
+     * Sets current user to the selected user.
+     *
+     * Emit selected user to parent component.
+     *
+     * Marks selected user in users list.
+     * @param selectedUser [UserValue]{@link UserValue}
+     */
+    select(selectedUser: UserListItem): void;
+    /**
+     * Load next page after scroll at end in cdkVirtualScroll element.
+     */
+    loadNextPage(): void;
+    /**
+     * Marks user as selected in users list.
+     * @param selectedUser Current select user value.
+     */
+    protected _markSelectedUser(selectedUser: UserListItem): void;
+}

package/lib/side-menu/content-components/user-assign/user-assign-list/user-assign-item/abstract-user-assign-item.component.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { UserListItem } from '../../../../../user/services/user-list.service';
+/**
+ * Includes avatar user icon and full username in the side menu.
+ */
+export declare abstract class AbstractUserAssignItemComponent {
+    /**
+     * Value of the user held in this item component
+     */
+    user: UserListItem;
+    /**
+     * ID of the currently selected user
+     */
+    selectedId$: Observable<string>;
+    constructor();
+}

package/lib/side-menu/models/portal-wrapper.d.ts

@@ -0,0 +1,9 @@
+import { Portal } from '@angular/cdk/portal';
+import { SideMenuSize } from './side-menu-size';
+export declare class PortalWrapper<T = any> {
+    private _portal;
+    private _width?;
+    constructor(_portal: Portal<T>, _width?: SideMenuSize);
+    get portal(): Portal<T>;
+    get size(): SideMenuSize;
+}

package/lib/side-menu/models/side-menu-control.d.ts

@@ -0,0 +1,15 @@
+import { Observable, Subject } from 'rxjs';
+import { SideMenuEvent } from './side-menu-event';
+import { SideMenuInjectionData } from './side-menu-injection-data';
+import { MatDrawerToggleResult } from '@angular/material/sidenav';
+export declare class SideMenuControl {
+    private sideMenuCloseFunction;
+    private readonly _injectionData?;
+    isVersionVisible?: boolean;
+    allVersionEnabled?: boolean;
+    private _event$;
+    constructor(bindingsFunction: (event$: Subject<SideMenuEvent>) => void, sideMenuOpenedStateChange: Observable<boolean>, sideMenuCloseFunction: () => Observable<MatDrawerToggleResult>, _injectionData?: SideMenuInjectionData, isVersionVisible?: boolean, allVersionEnabled?: boolean);
+    get data(): SideMenuInjectionData;
+    publish(event: SideMenuEvent): void;
+    close(event: SideMenuEvent): Observable<MatDrawerToggleResult>;
+}

package/lib/side-menu/models/side-menu-event.d.ts

@@ -0,0 +1,6 @@
+export interface SideMenuEvent {
+    opened: boolean;
+    message?: string;
+    data?: any;
+    [k: string]: any;
+}

package/lib/side-menu/models/side-menu-injection-data.d.ts

@@ -0,0 +1,3 @@
+export interface SideMenuInjectionData {
+    [k: string]: any;
+}

package/lib/side-menu/models/side-menu-ref.d.ts

@@ -0,0 +1,8 @@
+import { Observable, Subject } from 'rxjs';
+import { SideMenuEvent } from './side-menu-event';
+export declare class SideMenuRef {
+    private _event$;
+    constructor(_event$: Subject<SideMenuEvent>);
+    get onEvent(): Observable<SideMenuEvent>;
+    get onClose(): Observable<SideMenuEvent>;
+}

package/lib/side-menu/models/side-menu-size.d.ts

@@ -0,0 +1,5 @@
+export declare enum SideMenuSize {
+    SMALL = "side-menu-width-small",
+    MEDIUM = "side-menu-width-medium",
+    LARGE = "side-menu-width-large"
+}

package/lib/side-menu/net-version-visible-injection-token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export declare const NAE_NET_VERSION_VISIBLE: InjectionToken<boolean>;
+export declare const NAE_NET_ALL_VERSIONS: InjectionToken<boolean>;

package/lib/side-menu/public-api.d.ts

@@ -0,0 +1,10 @@
+export * from './content-components/public-api';
+export * from './side-menu-container/abstract-side-menu-container.component';
+export * from './services/side-menu.service';
+export * from './side-menu-injection-token';
+export * from './net-version-visible-injection-token';
+export * from './models/side-menu-control';
+export * from './models/side-menu-event';
+export * from './models/side-menu-injection-data';
+export * from './models/side-menu-ref';
+export * from './models/side-menu-size';

package/lib/side-menu/services/side-menu.service.d.ts

@@ -0,0 +1,35 @@
+import { TemplateRef } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { Observable } from 'rxjs';
+import { SideMenuSize } from '../models/side-menu-size';
+import { SideMenuRef } from '../models/side-menu-ref';
+import { SideMenuInjectionData } from '../models/side-menu-injection-data';
+import { SideMenuEvent } from '../models/side-menu-event';
+import { MatDrawerToggleResult } from '@angular/material/sidenav';
+export declare class SideMenuService {
+    private _sideMenuComponent;
+    private _controlObject;
+    private readonly isVersionVisible;
+    private readonly allVersionEnabled;
+    constructor(isVersionVisible: boolean, allVersionEnabled: boolean);
+    /**
+     * register SideMenuContainerComponent
+     *
+     * params menu is SideMenuContainerComponent
+     */
+    registerSideMenu(menu: any): void;
+    isOpened(): boolean;
+    /**
+     * Open this _sideMenu, and return a Observable that will resolve when it's fully opened (or get rejected if it didn't).
+     *
+     * @returns Observable<MatDrawerToggleResult>
+     */
+    open<T>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>, width?: SideMenuSize, injectionData?: SideMenuInjectionData): SideMenuRef;
+    private _createPortal;
+    /**
+     * Close this _sideMenu, and return a Observable that will resolve when it's fully closed (or get rejected if it didn't).
+     *
+     * @returns Observable<MatDrawerToggleResult>
+     */
+    close(closeEvent?: SideMenuEvent): Observable<MatDrawerToggleResult>;
+}

package/lib/side-menu/side-menu-container/abstract-side-menu-container.component.d.ts

@@ -0,0 +1,16 @@
+import { AfterViewInit } from '@angular/core';
+import { PortalWrapper } from '../models/portal-wrapper';
+import { SideMenuService } from '../services/side-menu.service';
+import { Observable } from 'rxjs';
+import { MatDrawerToggleResult, MatSidenav } from '@angular/material/sidenav';
+export declare abstract class AbstractSideMenuContainerComponent implements AfterViewInit {
+    protected _sideMenuService: SideMenuService;
+    sideMenu: MatSidenav;
+    portalWrapper: PortalWrapper;
+    constructor(_sideMenuService: SideMenuService);
+    ngAfterViewInit(): void;
+    open(portalWrapper: PortalWrapper): Observable<MatDrawerToggleResult>;
+    close(context: AbstractSideMenuContainerComponent): Observable<MatDrawerToggleResult>;
+    isOpened(): boolean;
+    openedChange(): Observable<boolean>;
+}

package/lib/side-menu/side-menu-injection-token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { SideMenuControl } from './models/side-menu-control';
+export declare const NAE_SIDE_MENU_CONTROL: InjectionToken<SideMenuControl>;

package/lib/snack-bar/components/error-snack-bar/error-snack-bar.component.d.ts

@@ -0,0 +1,8 @@
+import { SnackBar } from '../../models/abstract-snack-bar';
+import { SnackBarInjectionData } from '../../models/snack-bar-injection-data';
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+export declare class ErrorSnackBarComponent extends SnackBar<ErrorSnackBarComponent> {
+    snackBarRef: MatSnackBarRef<ErrorSnackBarComponent>;
+    data: SnackBarInjectionData;
+    constructor(snackBarRef: MatSnackBarRef<ErrorSnackBarComponent>, data: SnackBarInjectionData);
+}

package/lib/snack-bar/components/generic-snack-bar/generic-snack-bar.component.d.ts

@@ -0,0 +1,8 @@
+import { SnackBar } from '../../models/abstract-snack-bar';
+import { SnackBarInjectionData } from '../../models/snack-bar-injection-data';
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+export declare class GenericSnackBarComponent extends SnackBar<GenericSnackBarComponent> {
+    snackBarRef: MatSnackBarRef<GenericSnackBarComponent>;
+    data: SnackBarInjectionData;
+    constructor(snackBarRef: MatSnackBarRef<GenericSnackBarComponent>, data: SnackBarInjectionData);
+}

package/lib/snack-bar/components/success-snack-bar/success-snack-bar.component.d.ts

@@ -0,0 +1,8 @@
+import { SnackBar } from '../../models/abstract-snack-bar';
+import { SnackBarInjectionData } from '../../models/snack-bar-injection-data';
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+export declare class SuccessSnackBarComponent extends SnackBar<SuccessSnackBarComponent> {
+    snackBarRef: MatSnackBarRef<SuccessSnackBarComponent>;
+    data: SnackBarInjectionData;
+    constructor(snackBarRef: MatSnackBarRef<SuccessSnackBarComponent>, data: SnackBarInjectionData);
+}

package/lib/snack-bar/components/warning-snack-bar/warning-snack-bar.component.d.ts

@@ -0,0 +1,8 @@
+import { SnackBar } from '../../models/abstract-snack-bar';
+import { SnackBarInjectionData } from '../../models/snack-bar-injection-data';
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+export declare class WarningSnackBarComponent extends SnackBar<WarningSnackBarComponent> {
+    snackBarRef: MatSnackBarRef<WarningSnackBarComponent>;
+    data: SnackBarInjectionData;
+    constructor(snackBarRef: MatSnackBarRef<WarningSnackBarComponent>, data: SnackBarInjectionData);
+}

package/lib/snack-bar/models/abstract-snack-bar.d.ts

@@ -0,0 +1,10 @@
+import { OnInit } from '@angular/core';
+import { SnackBarInjectionData } from './snack-bar-injection-data';
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+export declare abstract class SnackBar<T> implements OnInit {
+    snackBarRef: MatSnackBarRef<T>;
+    data: SnackBarInjectionData;
+    protected constructor(snackBarRef: MatSnackBarRef<T>, data: SnackBarInjectionData);
+    onDismiss(): void;
+    ngOnInit(): void;
+}

package/lib/snack-bar/models/injection-token-snackbar.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import { SnackBarHorizontalPosition, SnackBarVerticalPosition } from './snack-bar-enums';
+export declare const NAE_SNACKBAR_VERTICAL_POSITION: InjectionToken<SnackBarVerticalPosition>;
+export declare const NAE_SNACKBAR_HORIZONTAL_POSITION: InjectionToken<SnackBarHorizontalPosition>;

package/lib/snack-bar/models/snack-bar-enums.d.ts

@@ -0,0 +1,9 @@
+export declare enum SnackBarVerticalPosition {
+    BOTTOM = "bottom",
+    TOP = "top"
+}
+export declare enum SnackBarHorizontalPosition {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right"
+}

package/lib/snack-bar/models/snack-bar-injection-data.d.ts

@@ -0,0 +1,5 @@
+export interface SnackBarInjectionData {
+    message: string;
+    matIconName: string;
+    closable?: boolean;
+}

package/lib/snack-bar/public-api.d.ts

@@ -0,0 +1,10 @@
+export * from './components/generic-snack-bar/generic-snack-bar.component';
+export * from './components/success-snack-bar/success-snack-bar.component';
+export * from './components/warning-snack-bar/warning-snack-bar.component';
+export * from './components/error-snack-bar/error-snack-bar.component';
+export * from './snack-bar.module';
+export * from './services/snack-bar.service';
+export * from './models/snack-bar-injection-data';
+export * from './models/abstract-snack-bar';
+export * from './models/injection-token-snackbar';
+export * from './models/snack-bar-enums';

package/lib/snack-bar/services/snack-bar.service.d.ts

@@ -0,0 +1,18 @@
+import { GenericSnackBarComponent } from '../components/generic-snack-bar/generic-snack-bar.component';
+import { SuccessSnackBarComponent } from '../components/success-snack-bar/success-snack-bar.component';
+import { ErrorSnackBarComponent } from '../components/error-snack-bar/error-snack-bar.component';
+import { WarningSnackBarComponent } from '../components/warning-snack-bar/warning-snack-bar.component';
+import { SnackBarInjectionData } from '../models/snack-bar-injection-data';
+import { MatSnackBar, MatSnackBarConfig, MatSnackBarRef } from '@angular/material/snack-bar';
+import { SnackBarHorizontalPosition, SnackBarVerticalPosition } from '../models/snack-bar-enums';
+export declare class SnackBarService {
+    private _snackBar;
+    private _defaultTimeout;
+    private _verticalPosition;
+    private _horizontalPosition;
+    constructor(_snackBar: MatSnackBar, naeVerticalPosition: SnackBarVerticalPosition, naeHorizontalPosition: SnackBarHorizontalPosition);
+    openSuccessSnackBar(message: string, verticalPosition?: SnackBarVerticalPosition, horizontalPosition?: SnackBarHorizontalPosition, durationInSeconds?: number, config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<SuccessSnackBarComponent>;
+    openErrorSnackBar(message: string, verticalPosition?: SnackBarVerticalPosition, horizontalPosition?: SnackBarHorizontalPosition, config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<ErrorSnackBarComponent>;
+    openWarningSnackBar(message: string, verticalPosition?: SnackBarVerticalPosition, horizontalPosition?: SnackBarHorizontalPosition, durationInSeconds?: number, config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<WarningSnackBarComponent>;
+    openGenericSnackBar(message: string, matIconName: string, verticalPosition?: SnackBarVerticalPosition, horizontalPosition?: SnackBarHorizontalPosition, durationInSeconds?: number, config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<GenericSnackBarComponent>;
+}

package/lib/snack-bar/snack-bar.module.d.ts

@@ -0,0 +1,2 @@
+export declare class SnackBarModule {
+}

package/lib/tabs/classes/opened-tab.d.ts

@@ -0,0 +1,67 @@
+import { TabContent, TabLabel } from '../interfaces';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Type } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+/**
+ * Holds the information of tab opened in a tab view.
+ *
+ * See {@link TabView} for more information.
+ */
+export declare class OpenedTab implements TabContent {
+    uniqueId: string;
+    /**
+     * See {@link TabContent#label}.
+     */
+    label: TabLabel;
+    /**
+     * See [TabContent.canBeClosed]{@link TabContent#canBeClosed}.
+     */
+    canBeClosed: boolean;
+    /**
+     * See [TabContent.tabContentComponent]{@link TabContent#tabContentComponent}.
+     */
+    tabContentComponent: Type<any>;
+    /**
+     * See [TabContent.injectedObject]{@link TabContent#injectedObject}.
+     */
+    injectedObject: object;
+    /**
+     * See [TabContent.order]{@link TabContent#order}.
+     */
+    order: number;
+    /**
+     * See [TabContent.initial]{@link TabContent#initial}.
+     */
+    initial: boolean;
+    /**
+     * See [TabContent.parentUniqueId]{@link TabContent#parentUniqueId}.
+     */
+    parentUniqueId: any;
+    /**
+     * Reference to the component portal that is used to display the tab content
+     */
+    portal: ComponentPortal<any>;
+    /**
+     * Whether the tab was initialized after it's creation.
+     *
+     * See [TabGroup.initializeTab()]{@link TabView#initializeTab} for more information.
+     */
+    isTabInitialized: boolean;
+    /**
+     * A stream that is injected into each tab and is used to inform that tab whenever it is selected or deselected
+     */
+    tabSelected$: BehaviorSubject<boolean>;
+    /**
+     * A stream that is injected into each tab and is used to inform the tab about its termination
+     */
+    tabClosed$: Subject<void>;
+    /**
+     * @param tabContent - content of the tab
+     * @param uniqueId - unique identifier for the tab
+     */
+    constructor(tabContent: TabContent, uniqueId: string);
+    /**
+     * Closes the stream held in this object
+     */
+    destroy(): void;
+}

package/lib/tabs/classes/tab-view.d.ts

@@ -0,0 +1,123 @@
+import { TabContent, TabViewInterface } from '../interfaces';
+import { OpenedTab } from './opened-tab';
+import { Injector } from '@angular/core';
+import { ViewService } from '../../routing/view-service/view.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { MatTabChangeEvent } from '@angular/material/tabs';
+/**
+ * Holds the logic for tab management in {@link AbstractTabViewComponent}.
+ * If you want to implement your own TabViewComponent, you might want to extend this class to hold your logic.
+ */
+export declare class TabView implements TabViewInterface {
+    private _viewService;
+    private _logger;
+    private _initialTabs;
+    private _parentInjector;
+    static readonly DYNAMIC_TAB_VIEW_ID_SEGMENT = "dynamic";
+    /**
+     * Holds the tabs that are opened in the tab view, and allows them to be bound to HTML.
+     */
+    openedTabs: Array<OpenedTab>;
+    /**
+     * Holds the index of the currently selected tab.
+     *
+     * Selected index initializes to `0`.
+     */
+    selectedIndex: number;
+    private uniqueIdCounter;
+    /**
+     * @ignore
+     * Holds a reference to an object that hides some public attributes and methods from tabs.
+     */
+    private tabViewInterface;
+    /**
+     * @param _viewService [ViewService]{@link ViewService} reference
+     * @param _logger [Logger]{@link LoggerService} reference
+     * @param _initialTabs Tabs that should be initially opened in the tab view
+     * @param _parentInjector `Injector` instance of the [TabViewComponent]{@link AbstractTabViewComponent},
+     * to be passed onto each tab, so that the dependency injection tree is not broken
+     */
+    constructor(_viewService: ViewService, _logger: LoggerService, _initialTabs: Array<TabContent>, _parentInjector: Injector);
+    /**
+     * @returns the index of the currently selected tab
+     */
+    currentlySelectedTab(): number;
+    /**
+     * Opens a new tab with the provided content.
+     * @param tabContent - content of the new tab
+     * @param autoswitch - whether the newly opened tab should be switched to. Defaults to `false`.
+     * @param openExisting - whether the opened tab already existing should be switched to existing one. Defaults to `true`.
+     * @returns the `tabUniqueId` of the newly opened tab
+     */
+    openTab(tabContent: TabContent, autoswitch?: boolean, openExisting?: boolean): string;
+    protected findIndexExistingTab(newTab: OpenedTab): number;
+    private searchesForOneCaseId;
+    private getSearchedCaseId;
+    private getSearchedCase;
+    private hasCaseFilterParamSet;
+    private hasBaseFilter;
+    private hasInjectedObject;
+    /**
+     * Adds a new tab into the correct position based on its `order` property.
+     * @param newTab the tab that should be opened
+     * @param autoswitch whether the new tab should be switched to after it is created
+     * @returns the `uniqueId` of the opened tab
+     */
+    protected openNewTab(newTab: OpenedTab, autoswitch: boolean): string;
+    /**
+     * Switches to a tab with the given `index`.
+     *
+     * Throws an error if the `index` is invalid.
+     * @param index - index of the tab that should be switched to
+     */
+    switchToTabIndex(index: number): void;
+    /**
+     * Switches to a tab with the given `uniqueId`.
+     *
+     * Throws an error if the `uniqueId` is invalid.
+     * @param uniqueId - id of the tab that should be switched to
+     */
+    switchToTabUniqueId(uniqueId: string): void;
+    /**
+     * Closes the tab with the given `index`.
+     *
+     * Throws an error if the `index` is invalid.
+     *
+     * Throws an error if the tab has it's `canBeClosed` property set to `false`.
+     * @param index index of the tab that should be closed
+     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`
+     */
+    closeTabIndex(index: number, force?: boolean): void;
+    /**
+     * Closes the tab with the given `uniqueId`. Throws an error if the `uniqueId` is invalid.
+     * Throws an error if the tab has it's `canBeClosed` property set to `false`.
+     * @param uniqueId - id of the tab that should be closed
+     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`
+     */
+    closeTabUniqueId(uniqueId: string, force?: boolean): void;
+    /**
+     * Closes the tab at the given index.
+     *
+     * If the conditions for closing a tab are not met throws an `Error` with the given message.
+     * @param index index of the tab that should be closed
+     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`
+     * @param error the message that should be displayed if the conditions for closing a tab are not met
+     */
+    protected closeTab(index: number, force: boolean, error: string): void;
+    /**
+     * Initializes the tab if it wasn't initialized yet.
+     * Creates a new {@link ComponentPortal} for the tab and provides the data for the tab under the `NAE_TAB_DATA` injection token.
+     * @param index - index of the tab that should be initialized
+     */
+    initializeTab(index: number): void;
+    tabChange(event: MatTabChangeEvent): void;
+    /**
+     * Transforms a tab `uniqueId` into it's index.
+     *
+     * Throws an error if no tab with the given `uniqueId` exists.
+     * @param uniqueId - id of the tab that we want to find index for
+     * @returns index of the tab with the given id
+     */
+    private getTabIndex;
+    private checkIndexRange;
+}