@netgrif/components-core 6.0.1

package/lib/utility/tests/utility/create-mock-immediate-data.d.ts

@@ -0,0 +1,8 @@
+import { ImmediateData } from '../../../resources/interface/immediate-data';
+/**
+ * Creates a mock ImmediateData instance with the given attributes.
+ *
+ * The attributes are filled with mostly empty values, if you want to make a test that uses some of them,
+ * we recommend setting them yourself, as the returned object might change between versions.
+ */
+export declare function createMockImmediateData(importId?: string, value?: any, allowedNets?: Array<string>): ImmediateData;

package/lib/utility/tests/utility/create-mock-net.d.ts

@@ -0,0 +1,17 @@
+import { Net } from '../../../process/net';
+import NetRole from '../../../process/netRole';
+import { ImmediateData } from '../../../resources/interface/immediate-data';
+/**
+ * A mock transition representation used by the {@link createMockNet} function to populate the mock net with mock transition objects
+ */
+export interface MockTransition {
+    stringId: string;
+    title: string;
+}
+/**
+ * Creates a mock Net instance with the given attributes.
+ *
+ * The attributes are filled with mostly empty values, if you want to make a test that uses some of them,
+ * we recommend setting them yourself, as the returned object might change between versions.
+ */
+export declare function createMockNet(stringId?: string, identifier?: string, title?: string, roles?: Array<NetRole>, transitions?: Array<MockTransition>, immediateData?: Array<ImmediateData>): Net;

package/lib/utility/tests/utility/create-mock-page.d.ts

@@ -0,0 +1,7 @@
+import { Page } from '../../../resources/interface/page';
+/**
+ * @param content the contents of the page
+ * @returns a mock Page object with the size equivalent to the number of elements provided in the attribute.
+ * If the content is empty the `content` attribute of the returned object is set to an empty object to mimic backend behavior.
+ */
+export declare function createMockPage<T>(content?: Array<T>): Page<T>;

package/lib/utility/tests/utility/create-mock-petri-net-outcome.d.ts

@@ -0,0 +1,9 @@
+import { PetriNetEventOutcome } from '../../../event/model/event-outcomes/petrinet-outcomes/petri-net-event-outcome';
+import { Net } from '../../../process/net';
+import { EventOutcome } from '../../../resources/interface/event-outcome';
+/**
+ * Creates a mock PetriNetEventOutcome with given net and outcomes attributes.
+ *
+ * If attributes are not specified, default values are used.
+ */
+export declare function createMockPetriNetOutcome(net?: Net, outcomes?: Array<EventOutcome>): PetriNetEventOutcome;

package/lib/utility/tests/utility/create-mock-set-data-outcome.d.ts

@@ -0,0 +1,12 @@
+import { SetDataEventOutcome } from '../../../event/model/event-outcomes/data-outcomes/set-data-event-outcome';
+import { Task } from '../../../resources/interface/task';
+import { Net } from '../../../process/net';
+import { Case } from '../../../resources/interface/case';
+import { EventOutcome } from '../../../resources/interface/event-outcome';
+import { ChangedFieldContainer } from '../../../resources/interface/changed-field-container';
+/**
+ * Creates a mock TaskEventOutcome with given changedFields, task, net, case and outcomes attributes.
+ *
+ * If attributes are not specified, default values are used.
+ */
+export declare function createMockSetDataOutcome(changedFields?: ChangedFieldContainer, task?: Task, net?: Net, aCase?: Case, outcomes?: Array<EventOutcome>): SetDataEventOutcome;

package/lib/utility/tests/utility/create-mock-task-outcome.d.ts

@@ -0,0 +1,11 @@
+import { TaskEventOutcome } from '../../../event/model/event-outcomes/task-outcomes/task-event-outcome';
+import { Net } from '../../../process/net';
+import { Case } from '../../../resources/interface/case';
+import { EventOutcome } from '../../../resources/interface/event-outcome';
+import { Task } from '../../../resources/interface/task';
+/**
+ * Creates a mock TaskEventOutcome with given task, net, case and outcomes attributes.
+ *
+ * If attributes are not specified, default values are used.
+ */
+export declare function createMockTaskOutcome(task?: Task, net?: Net, aCase?: Case, outcomes?: Array<EventOutcome>): TaskEventOutcome;

package/lib/utility/tests/utility/create-mock-task.d.ts

@@ -0,0 +1,8 @@
+import { Task } from '../../../resources/interface/task';
+/**
+ * Creates a mock Task instance with the given attributes.
+ *
+ * The attributes are filled with mostly empty values, if you want to make a test that uses some of them,
+ * we recommend setting them yourself, as the returned object might change between versions.
+ */
+export declare function createMockTask(stringId?: string, title?: string, transitionId?: string, cols?: number): Task;

package/lib/view/abstract/page-load-request-context.d.ts

@@ -0,0 +1,40 @@
+import { Filter } from '../../filter/models/filter';
+import { Pagination } from '../../resources/interface/pagination';
+/**
+ * Holds the information that accompanies a page load request. These information are held outside of the
+ * service that handles the requests, so that state information about multiple requests can be handled independently of each other.
+ */
+export declare class PageLoadRequestContext {
+    /**
+     * Stores the {@link Filter} object that was used with the request.
+     */
+    filter: Filter;
+    /**
+     * Stores the pagination information that was used with the request.
+     */
+    pagination: Pagination;
+    /**
+     * Whether the existing tasks or cases should be replaced by the result of this request.
+     */
+    clearLoaded: boolean;
+    /**
+     * Whether the tasks on the current page should be reloaded by this request.
+     *
+     * This option does not affect case requests.
+     */
+    reloadCurrentTaskPage: boolean;
+    /**
+     * Used for forcing the request after queued Assign or Cancel.
+     */
+    force: boolean;
+    /**
+     * @param requestFilter the {@link Filter} that is used by the request. Context holds the passed reference.
+     * @param requestPagination the {@link Pagination} that is used by the request.
+     * Context creates a local copy of the passed objects content.
+     * @param clearLoaded whether the existing tasks or cases should be cleared and replaced by the result of this request.
+     * @param reloadCurrentTaskPage whether the current page of tasks should be updated with the result of the current request.
+     * Does not affect case requests.
+     */
+    constructor(requestFilter: Filter, requestPagination: Pagination, clearLoaded?: boolean, reloadCurrentTaskPage?: boolean, force?: boolean);
+    get pageNumber(): number;
+}

package/lib/view/abstract/sortable-view.d.ts

@@ -0,0 +1,19 @@
+import { SortChangeDescription } from '../../header/models/user-changes/sort-change-description';
+import { Observable, Subscription } from 'rxjs';
+import { HeaderChange } from '../../header/models/user-changes/header-change';
+import { HttpParams } from '@angular/common/http';
+import { OnDestroy } from '@angular/core';
+import { SearchIndexResolverService } from '../../search/search-keyword-resolver-service/search-index-resolver.service';
+export declare abstract class SortableView implements OnDestroy {
+    protected _resolver: SearchIndexResolverService;
+    protected _lastHeaderSearchState: SortChangeDescription;
+    protected _subHeader: Subscription;
+    protected constructor(_resolver: SearchIndexResolverService);
+    ngOnDestroy(): void;
+    registerHeaderChange(headerChange$: Observable<HeaderChange>): void;
+    abstract reload(): void;
+    protected addSortParams(params: HttpParams): HttpParams;
+    protected getSortId(): string;
+    protected abstract getMetaFieldSortId(): string;
+    protected abstract getDefaultSortParam(): string;
+}

package/lib/view/abstract/view-with-headers.d.ts

@@ -0,0 +1,13 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { HeaderColumn } from '../../header/models/header-column';
+import { AbstractHeaderComponent } from '../../header/abstract-header.component';
+import { SortableView } from './sortable-view';
+import { OnDestroy } from '@angular/core';
+export declare abstract class ViewWithHeaders implements OnDestroy {
+    private _sortableView?;
+    protected _selectedHeaders$: ReplaySubject<Array<HeaderColumn>>;
+    protected constructor(_sortableView?: SortableView);
+    get selectedHeaders$(): Observable<Array<HeaderColumn>>;
+    protected initializeHeader(headerComponent: AbstractHeaderComponent): void;
+    ngOnDestroy(): void;
+}

package/lib/view/case-view/abstract-case-view.d.ts

@@ -0,0 +1,25 @@
+import { Case } from '../../resources/interface/case';
+import { Observable } from 'rxjs';
+import { HeaderType } from '../../header/models/header-type';
+import { CaseViewService } from './service/case-view-service';
+import { ViewWithHeaders } from '../abstract/view-with-headers';
+import { Authority } from '../../resources/interface/authority';
+import { OverflowService } from '../../header/services/overflow.service';
+import { NewCaseCreationConfigurationData } from '../../side-menu/content-components/new-case/model/new-case-injection-data';
+export declare abstract class AbstractCaseView extends ViewWithHeaders {
+    protected _caseViewService: CaseViewService;
+    protected _overflowService?: OverflowService;
+    protected _authority: Array<Authority>;
+    protected _newCaseCreationConfig: NewCaseCreationConfigurationData;
+    readonly MINIMAL_OFFSET = 120;
+    readonly headerType: HeaderType;
+    cases$: Observable<Array<Case>>;
+    loading: boolean;
+    authorityToCreate: Array<string>;
+    protected constructor(_caseViewService: CaseViewService, _overflowService?: OverflowService, _authority?: Array<Authority>, _newCaseCreationConfig?: NewCaseCreationConfigurationData);
+    createNewCase(): Observable<Case>;
+    abstract handleCaseClick(clickedCase: Case): void;
+    hasAuthority(): boolean;
+    getWidth(): string;
+    getOverflowStatus(): boolean;
+}

package/lib/view/case-view/components/case-list/abstract-case-list.component.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { CaseViewService } from '../../service/case-view-service';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { Observable } from 'rxjs';
+import { Case } from '../../../../resources/interface/case';
+import { HeaderColumn } from '../../../../header/models/header-column';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { TabbedVirtualScrollComponent } from '../../../../panel/abstract/tabbed-virtual-scroll.component';
+import { InjectedTabData } from '../../../../tabs/interfaces';
+import { ActivatedRoute } from '@angular/router';
+export declare abstract class AbstractCaseListComponent extends TabbedVirtualScrollComponent implements OnDestroy {
+    protected _caseViewService: CaseViewService;
+    protected _log: LoggerService;
+    protected route?: ActivatedRoute;
+    selectedHeaders$: Observable<Array<HeaderColumn>>;
+    responsiveBody: boolean;
+    caseClick: EventEmitter<Case>;
+    showCasePanelIcon: boolean;
+    showDeleteMenu: boolean;
+    textEllipsis: boolean;
+    width: string;
+    redirectEnabled: boolean;
+    viewport: CdkVirtualScrollViewport;
+    cases$: Observable<Array<Case>>;
+    loading$: Observable<boolean>;
+    private redirectCaseId;
+    private unsubscribe$;
+    protected constructor(_caseViewService: CaseViewService, _log: LoggerService, injectedTabData: InjectedTabData, route?: ActivatedRoute);
+    ngOnDestroy(): void;
+    trackBy(i: any): any;
+    get loadedDataSize(): number;
+    loadNextPage(): void;
+    onCaseClick(case_: Case): void;
+    onRedirect(): void;
+}

package/lib/view/case-view/models/case-page-load-request-result.d.ts

@@ -0,0 +1,14 @@
+import { Case } from '../../../resources/interface/case';
+import { PageLoadRequestContext } from '../../abstract/page-load-request-context';
+/**
+ * Holds the information returned by a case page load request alongside the context of the request.
+ */
+export interface CasePageLoadRequestResult {
+    /**
+     * Keys are case `stringId`s
+     */
+    cases: {
+        [k: string]: Case;
+    };
+    requestContext: PageLoadRequestContext;
+}

package/lib/view/case-view/models/case-view-params.d.ts

@@ -0,0 +1,3 @@
+export interface CaseViewParams {
+    allowedNets: Array<string>;
+}

package/lib/view/case-view/models/new-case-configuration-injection-token.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import { NewCaseConfiguration } from './new-case-configuration';
+/**
+ * Can be used to provide case views with configuration of the {@link CaseViewService#createNewCase}[createNewCase()] method without
+ * having to extend the service and override the method.
+ */
+export declare const NAE_NEW_CASE_CONFIGURATION: InjectionToken<NewCaseConfiguration>;

package/lib/view/case-view/models/new-case-configuration.d.ts

@@ -0,0 +1,9 @@
+export interface NewCaseConfiguration {
+    /**
+     * Whether the process cache should be used when creating new cases or not.
+     *
+     * Disabling the cache can have detrimental effect on the performance of the application but will result
+     * in a very small window in which the process metadata can be desynchronized between frontend and backend.
+     */
+    useCachedProcesses: boolean;
+}

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

@@ -0,0 +1,73 @@
+import { OnDestroy } from '@angular/core';
+import { SideMenuService } from '../../../side-menu/services/side-menu.service';
+import { CaseResourceService } from '../../../resources/engine-endpoint/case-resource.service';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { Case } from '../../../resources/interface/case';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { SnackBarService } from '../../../snack-bar/services/snack-bar.service';
+import { SearchService } from '../../../search/search-service/search.service';
+import { TranslateService } from '@ngx-translate/core';
+import { Pagination } from '../../../resources/interface/pagination';
+import { PageLoadRequestContext } from '../../abstract/page-load-request-context';
+import { Filter } from '../../../filter/models/filter';
+import { ListRange } from '@angular/cdk/collections';
+import { LoadingWithFilterEmitter } from '../../../utility/loading-with-filter-emitter';
+import { CasePageLoadRequestResult } from '../models/case-page-load-request-result';
+import { UserService } from '../../../user/services/user.service';
+import { NewCaseConfiguration } from '../models/new-case-configuration';
+import { ProcessService } from '../../../process/process.service';
+import { PetriNetReferenceWithPermissions } from '../../../process/petri-net-reference-with-permissions';
+import { SearchIndexResolverService } from '../../../search/search-keyword-resolver-service/search-index-resolver.service';
+import { AllowedNetsService } from '../../../allowed-nets/services/allowed-nets.service';
+import { SortableView } from '../../abstract/sortable-view';
+import { NewCaseCreationConfigurationData } from '../../../side-menu/content-components/new-case/model/new-case-injection-data';
+import { PermissionService } from '../../../authorization/permission/permission.service';
+export declare class CaseViewService extends SortableView implements OnDestroy {
+    protected _allowedNetsService: AllowedNetsService;
+    protected _sideMenuService: SideMenuService;
+    protected _caseResourceService: CaseResourceService;
+    protected _log: LoggerService;
+    protected _snackBarService: SnackBarService;
+    protected _searchService: SearchService;
+    protected _translate: TranslateService;
+    protected _user: UserService;
+    protected _processService: ProcessService;
+    protected _newCaseComponent: any;
+    protected _permissionService: PermissionService;
+    readonly DEFAULT_NEW_CASE_CONFIGURATION: NewCaseConfiguration;
+    protected _loading$: LoadingWithFilterEmitter;
+    protected _cases$: Observable<Array<Case>>;
+    protected _nextPage$: BehaviorSubject<PageLoadRequestContext>;
+    protected _endOfData: boolean;
+    protected _pagination: Pagination;
+    protected _newCaseConfiguration: NewCaseConfiguration;
+    constructor(_allowedNetsService: AllowedNetsService, _sideMenuService: SideMenuService, _caseResourceService: CaseResourceService, _log: LoggerService, _snackBarService: SnackBarService, _searchService: SearchService, _translate: TranslateService, _user: UserService, _processService: ProcessService, resolver: SearchIndexResolverService, _newCaseComponent: any, newCaseConfig: NewCaseConfiguration, _permissionService: PermissionService);
+    ngOnDestroy(): void;
+    get loading(): boolean;
+    get loading$(): Observable<boolean>;
+    get cases$(): Observable<Array<Case>>;
+    protected get activeFilter(): Filter;
+    loadPage(requestContext: PageLoadRequestContext): Observable<CasePageLoadRequestResult>;
+    nextPage(renderedRange: ListRange, totalLoaded: number, requestContext?: PageLoadRequestContext): void;
+    private isLoadingRelevantFilter;
+    createNewCase(newCaseCreationConfiguration?: NewCaseCreationConfigurationData): Observable<Case>;
+    createDefaultNewCase(): Observable<Case>;
+    protected getNewCaseAllowedNets(): Observable<Array<PetriNetReferenceWithPermissions>>;
+    /**
+     * Returns number of allowed nets of case view
+     * @returns length of allowedNets array if it is defined, 0 if it is undefined
+     */
+    getAllowedNetsCount(): number;
+    protected addPageParams(params: HttpParams, pagination: Pagination): HttpParams;
+    protected getDefaultSortParam(): string;
+    protected getMetaFieldSortId(): string;
+    reload(): void;
+    hasAuthority(authority: Array<string> | string): boolean;
+    /**
+     * Determines whether the current user has the [VIEW]{@link PermissionType#VIEW} permission on the current case
+     * @param aCase the tested case
+     * @returns `true` if the current user has the `VIEW` permission on the tested case, `false` otherwise.
+     */
+    viewEnabled(aCase: Case): boolean;
+}

package/lib/view/case-view/tabbed-case-view.d.ts

@@ -0,0 +1,26 @@
+import { AbstractCaseView } from './abstract-case-view';
+import { Type } from '@angular/core';
+import { InjectedTabData } from '../../tabs/interfaces';
+import { Case } from '../../resources/interface/case';
+import { LoggerService } from '../../logger/services/logger.service';
+import { CaseViewService } from './service/case-view-service';
+import { OverflowService } from '../../header/services/overflow.service';
+import { NewCaseCreationConfigurationData } from '../../side-menu/content-components/new-case/model/new-case-injection-data';
+import { Observable } from 'rxjs';
+export interface InjectedTabbedCaseViewData extends InjectedTabData {
+    tabViewComponent: Type<any>;
+    tabViewOrder: number;
+}
+export declare abstract class TabbedCaseView extends AbstractCaseView {
+    protected _loggerService: LoggerService;
+    protected _injectedTabData: InjectedTabbedCaseViewData;
+    protected _overflowService?: OverflowService;
+    protected _autoswitchToTaskTab: boolean;
+    protected _openExistingTab: boolean;
+    protected _newCaseCreationConfig: NewCaseCreationConfigurationData;
+    private readonly _correctlyInjected;
+    protected constructor(caseViewService: CaseViewService, _loggerService: LoggerService, _injectedTabData: InjectedTabbedCaseViewData, _overflowService?: OverflowService, _autoswitchToTaskTab?: boolean, _openExistingTab?: boolean, _newCaseCreationConfig?: NewCaseCreationConfigurationData);
+    handleCaseClick(clickedCase: Case): void;
+    createNewCase(): Observable<Case>;
+    protected openTab(openCase: Case): void;
+}

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

@@ -0,0 +1,35 @@
+export * from './case-view/models/case-view-params';
+export * from './case-view/models/case-page-load-request-result';
+export * from './case-view/models/new-case-configuration';
+export * from './task-view/models/task-view-params';
+export * from './task-view/models/injected-tabbed-task-view-data';
+export * from './task-view/models/task-page-load-request-result';
+export * from './task-view/models/task-view-configuration';
+export * from './tree-case-view/tree-component/model/case-tree-node';
+export * from './tree-case-view/tree-component/model/case-tree-path';
+export * from './tree-case-view/tree-component/model/expansion-tree';
+export * from './tree-case-view/model/tree-petriflow-identifiers';
+export * from './task-view/models/task-endpoint';
+export * from './case-view/abstract-case-view';
+export * from './case-view/tabbed-case-view';
+export * from './task-view/abstract-task-view';
+export * from './task-view/tabbed-task-view';
+export * from './abstract/view-with-headers';
+export * from './abstract/sortable-view';
+export * from './abstract/page-load-request-context';
+export * from './case-view/models/new-case-configuration-injection-token';
+export * from './task-view/models/injection-token-task-endpoint';
+export * from './task-view/models/task-view-configuration-injection-token';
+export * from './workflow-view/models/injection-token-workflow-service';
+export * from './case-view/service/case-view-service';
+export * from './task-view/service/task-view.service';
+export * from './workflow-view/workflow-view.service';
+export * from './tree-case-view/tree-case-view.service';
+export * from './tree-case-view/tree-component/case-tree.service';
+export * from './tree-case-view/tree-task-content/tree-task-content.service';
+export * from './workflow-view/abstract-workflow-view.component';
+export * from './case-view/components/case-list/abstract-case-list.component';
+export * from './tree-case-view/tree-component/abstract-tree.component';
+export * from './tree-case-view/tree-component/add-child-node/abstract-add-child-node.component';
+export * from './tree-case-view/tree-component/remove-node/abstract-remove-node.component';
+export * from './tree-case-view/tree-task-content/abstract-tree-task-content.component';

package/lib/view/task-view/abstract-task-view.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { TaskPanelData } from '../../panel/task-panel-list/task-panel-data/task-panel-data';
+import { TaskViewService } from './service/task-view.service';
+import { ViewWithHeaders } from '../abstract/view-with-headers';
+export declare abstract class AbstractTaskView extends ViewWithHeaders implements OnDestroy {
+    protected taskViewService: TaskViewService;
+    tasks$: Observable<Array<TaskPanelData>>;
+    loading$: Observable<boolean>;
+    protected constructor(taskViewService: TaskViewService);
+    ngOnDestroy(): void;
+}

package/lib/view/task-view/models/injected-tabbed-task-view-data.d.ts

@@ -0,0 +1,12 @@
+import { InjectedTabData } from '../../../tabs/interfaces';
+import { Filter } from '../../../filter/models/filter';
+export interface InjectedTabbedTaskViewData extends InjectedTabData {
+    baseFilter: Filter;
+    /**
+     * Identifiers of the allowed nets. Allowed nets have no effect on the inner working of the task view at large.
+     * But search interface uses them to generate the autocomplete data.
+     * So by not providing the nets, task search will be severely limited.
+     */
+    allowedNets?: Array<string>;
+    initiallyOpenOneTask?: boolean;
+}

package/lib/view/task-view/models/injection-token-task-endpoint.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+import { TaskEndpoint } from './task-endpoint';
+/**
+ * @deprecated in 5.3.0 - Use {@link NAE_TASK_VIEW_CONFIGURATION} instead
+ */
+export declare const NAE_PREFERRED_TASK_ENDPOINT: InjectionToken<TaskEndpoint>;

package/lib/view/task-view/models/task-endpoint.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Used to determine which backend endpoint should be used to request tasks from
+ */
+export declare enum TaskEndpoint {
+    MONGO = 1,
+    ELASTIC = 2
+}

package/lib/view/task-view/models/task-page-load-request-result.d.ts

@@ -0,0 +1,14 @@
+import { TaskPanelData } from '../../../panel/task-panel-list/task-panel-data/task-panel-data';
+import { PageLoadRequestContext } from '../../abstract/page-load-request-context';
+/**
+ * Holds the information returned by a task page load request alongside the context of the request.
+ */
+export interface TaskPageLoadRequestResult {
+    /**
+     * Keys are task `stringId`s
+     */
+    tasks: {
+        [k: string]: TaskPanelData;
+    };
+    requestContext: PageLoadRequestContext;
+}

package/lib/view/task-view/models/task-view-configuration-injection-token.d.ts

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+import { TaskViewConfiguration } from './task-view-configuration';
+import { InjectedTabbedTaskViewData } from './injected-tabbed-task-view-data';
+export declare const NAE_TASK_VIEW_CONFIGURATION: InjectionToken<TaskViewConfiguration>;
+/**
+ * Convenience method that can be used as a task view configuration object factory for tabbed task views.
+ *
+ * If the injected tab data contain information that is included in the {@link TaskViewConfiguration} interface,
+ * this factory will forward this information into the provided object.
+ *
+ * @param injectedTabData
+ */
+export declare function tabbedTaskViewConfigurationFactory(injectedTabData: InjectedTabbedTaskViewData): TaskViewConfiguration;

package/lib/view/task-view/models/task-view-configuration.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { TaskEndpoint } from './task-endpoint';
+/**
+ * Configuration of behavior of task list managed by task view
+ */
+export interface TaskViewConfiguration {
+    /**
+     * If both this and the deprecated {@link NAE_PREFERRED_TASK_ENDPOINT} is provided, this option takes precedence.
+     */
+    preferredEndpoint?: TaskEndpoint;
+    /**
+     * If not present defaults to `of(true)`
+     */
+    initiallyOpenOneTask?: Observable<boolean>;
+    /**
+     * If not present defaults to `of(true)`
+     */
+    closeTaskTabOnNoTasks?: Observable<boolean>;
+}

package/lib/view/task-view/models/task-view-params.d.ts

@@ -0,0 +1,3 @@
+export interface TaskViewParams {
+    allowedNets: Array<string>;
+}

package/lib/view/task-view/service/task-view.service.d.ts

@@ -0,0 +1,68 @@
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable, ReplaySubject, Subject, Subscription } from 'rxjs';
+import { TaskPanelData } from '../../../panel/task-panel-list/task-panel-data/task-panel-data';
+import { TaskResourceService } from '../../../resources/engine-endpoint/task-resource.service';
+import { UserService } from '../../../user/services/user.service';
+import { SnackBarService } from '../../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { HttpParams } from '@angular/common/http';
+import { Pagination } from '../../../resources/interface/pagination';
+import { SearchService } from '../../../search/search-service/search.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { ListRange } from '@angular/cdk/collections';
+import { UserComparatorService } from '../../../user/services/user-comparator.service';
+import { TaskEndpoint } from '../models/task-endpoint';
+import { PageLoadRequestContext } from '../../abstract/page-load-request-context';
+import { Filter } from '../../../filter/models/filter';
+import { TaskPageLoadRequestResult } from '../models/task-page-load-request-result';
+import { LoadingWithFilterEmitter } from '../../../utility/loading-with-filter-emitter';
+import { SearchIndexResolverService } from '../../../search/search-keyword-resolver-service/search-index-resolver.service';
+import { SortableView } from '../../abstract/sortable-view';
+import { TaskViewConfiguration } from '../models/task-view-configuration';
+import { ChangedFieldsMap } from '../../../event/services/interfaces/changed-fields-map';
+export declare class TaskViewService extends SortableView implements OnDestroy {
+    protected _taskService: TaskResourceService;
+    private _userService;
+    private _snackBarService;
+    private _translate;
+    protected _searchService: SearchService;
+    private _log;
+    private _userComparator;
+    protected readonly _preferredEndpoint: TaskEndpoint;
+    protected _tasks$: Observable<Array<TaskPanelData>>;
+    protected _changedFields$: Subject<ChangedFieldsMap>;
+    protected _requestedPage$: BehaviorSubject<PageLoadRequestContext>;
+    protected _loading$: LoadingWithFilterEmitter;
+    protected _endOfData: boolean;
+    protected _pagination: Pagination;
+    protected _initiallyOpenOneTask: boolean;
+    protected _closeTaskTabOnNoTasks: boolean;
+    protected _panelUpdate$: BehaviorSubject<Array<TaskPanelData>>;
+    protected _closeTab$: ReplaySubject<void>;
+    protected _subInitiallyOpen: Subscription;
+    protected _subCloseTask: Subscription;
+    protected _subSearch: Subscription;
+    protected _allowMultiOpen: boolean;
+    private readonly _initializing;
+    constructor(_taskService: TaskResourceService, _userService: UserService, _snackBarService: SnackBarService, _translate: TranslateService, _searchService: SearchService, _log: LoggerService, _userComparator: UserComparatorService, resolver: SearchIndexResolverService, _preferredEndpoint?: TaskEndpoint, taskViewConfig?: TaskViewConfiguration);
+    ngOnDestroy(): void;
+    get tasks$(): Observable<Array<TaskPanelData>>;
+    get changedFields$(): Subject<ChangedFieldsMap>;
+    get loading$(): Observable<boolean>;
+    get loading(): boolean;
+    get panelUpdate(): Observable<Array<TaskPanelData>>;
+    get closeTab(): Observable<void>;
+    protected get activeFilter(): Filter;
+    set allowMultiOpen(bool: boolean);
+    get allowMultiOpen(): boolean;
+    loadPage(requestContext: PageLoadRequestContext): Observable<TaskPageLoadRequestResult>;
+    private updateTask;
+    private blockTaskFields;
+    nextPage(renderedRange: ListRange, totalLoaded: number, requestContext?: PageLoadRequestContext): void;
+    private isLoadingRelevantFilter;
+    reload(): void;
+    reloadCurrentPage(force?: boolean): void;
+    protected getMetaFieldSortId(): string;
+    protected getDefaultSortParam(): string;
+    protected addPageParams(params: HttpParams, pagination: Pagination): HttpParams;
+}

package/lib/view/task-view/tabbed-task-view.d.ts

@@ -0,0 +1,11 @@
+import { AbstractTaskView } from './abstract-task-view';
+import { TaskViewService } from './service/task-view.service';
+import { OnDestroy } from '@angular/core';
+import { InjectedTabbedTaskViewData } from './models/injected-tabbed-task-view-data';
+import { Subscription } from 'rxjs';
+export declare abstract class TabbedTaskView extends AbstractTaskView implements OnDestroy {
+    protected _injectedTabData: InjectedTabbedTaskViewData;
+    protected subTaskView: Subscription;
+    protected constructor(taskViewService: TaskViewService, _injectedTabData: InjectedTabbedTaskViewData);
+    ngOnDestroy(): void;
+}

package/lib/view/tree-case-view/model/tree-petriflow-identifiers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Contains the ids of the elements in Petriflow process that are used to represent the tree structure
+ */
+export declare enum TreePetriflowIdentifiers {
+    /**
+     * Immediate case ref data variable that contains the children of this tree node
+     */
+    CHILDREN_CASE_REF = "treeChildCases",
+    /**
+     * Immediate boolean data variable that determines whether the option to can add new child nodes should be displayed.
+     *
+     * The type of node added is determined by the `allowedNets` property of the case ref field that holds the children
+     */
+    CAN_ADD_CHILDREN = "canAddTreeChildren",
+    /**
+     * Immediate text data variable that contains the id of the transition who's task should be displayed when the case node is selected.
+     */
+    FEATURED_TRANSITION = "treeTaskTransitionId",
+    /**
+     * Immediate boolean data variable that determines whether the option to remove this node from the tree should be displayed
+     */
+    CAN_REMOVE_NODE = "canRemoveTreeNode",
+    /**
+     * Immediate text data variable that contains the default case title for this node's children.
+     *
+     * If no value is provided an appropriate translation of 'New Node' will be used instead.
+     */
+    CHILD_NODE_TITLE = "childNodeCaseTitle",
+    /**
+     * Id of the transition that is executed to set the new child data
+     */
+    CASE_REF_TRANSITION = "treeCaseRefAccessor",
+    /**
+     * Before text icon
+     */
+    BEFORE_TEXT_ICON = "beforeTextIcon",
+    /**
+     * Add icon in tree
+     */
+    TREE_ADD_ICON = "treeAddIcon"
+}