@netgrif/components-core 6.0.1

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

@@ -0,0 +1,9 @@
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { Case } from '../../resources/interface/case';
+export declare class TreeCaseViewService implements OnDestroy {
+    loadTask$: BehaviorSubject<Case>;
+    reloadCase$: Subject<void>;
+    constructor();
+    ngOnDestroy(): void;
+}

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

@@ -0,0 +1,99 @@
+import { EventEmitter } from '@angular/core';
+import { NestedTreeControl } from '@angular/cdk/tree';
+import { Filter } from '../../../filter/models/filter';
+import { CaseTreeService } from './case-tree.service';
+import { CaseTreeNode } from './model/case-tree-node';
+import { MatTreeNestedDataSource } from '@angular/material/tree';
+import { CaseTreePath } from './model/case-tree-path';
+export declare abstract class AbstractTreeComponent {
+    protected _treeService: CaseTreeService;
+    /**
+     * `true` is emitted whenever the tree's root node is in it's loading state.
+     *
+     * `false` is emitted when the root node is no longer in the loading state.
+     *
+     * The first value emitted from this Output is `false`, when the tree finishes initializing.
+     *
+     * The root node enters it's loading state when it's children are being loaded.
+     */
+    treeRootLoading: EventEmitter<boolean>;
+    /**
+     * `true` is emitted whenever the tree's root node is adding a new child node.
+     *
+     * `false` is emitted when the root node is no longer adding a new child node.
+     *
+     * The first value emitted from this Output is `false`, when the tree finishes initializing.
+     *
+     * No further calls to add a child node should be made, while a child is being added.
+     */
+    treeRootAddingChild: EventEmitter<boolean>;
+    protected constructor(_treeService: CaseTreeService);
+    /**
+     * The {@link Filter} that determines the root node of the tree.
+     *
+     * The tree can only have one root. If more than one case is returned by the Filter.
+     * The first result will be used as the tree root.
+     *
+     * If you want to have multiple nodes in the first level checkout the [showTreeRoot]{@link AbstractTreeComponent#showTreeRoot} property.
+     * @param filter Case Filter that determines the tree root
+     */
+    set filter(filter: Filter);
+    /**
+     * Whether the tree root should be displayed as a node or not.
+     *
+     * `true` displays the root as the only node in the first level.
+     *
+     * `false` displays the root's child nodes in the first level.
+     *
+     * If you want to add more children while the root is hidden use the [addRootChildNode]
+     * {@link AbstractTreeComponent#addRootChildNode} method.
+     * @param showTreeRoot whether the root node should be displayed in the tree or not
+     */
+    set showTreeRoot(showTreeRoot: boolean);
+    /**
+     * Weather the tree is eager loaded or not.
+     *
+     * Defaults to `false`.
+     *
+     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
+     *
+     * @param eager the new setting for eager loading
+     */
+    set eagerLoaded(eager: boolean);
+    /**
+     * @ignore
+     */
+    get dataSource(): MatTreeNestedDataSource<CaseTreeNode>;
+    /**
+     * @ignore
+     */
+    get treeControl(): NestedTreeControl<CaseTreeNode>;
+    /**
+     * @ignore
+     */
+    hasChild: (_: number, node: CaseTreeNode) => boolean;
+    /**
+     * @ignore
+     */
+    caseNodeClicked(node: CaseTreeNode): void;
+    /**
+     * @ignore
+     */
+    toggleCaseNode(event: Event, node: CaseTreeNode): void;
+    /**
+     * @ignore
+     */
+    selectedCaseNode(node: CaseTreeNode): boolean;
+    /**
+     * Adds a child to the root node.
+     *
+     * Useful if you set the [showTreeRoot]{@link AbstractTreeComponent#showTreeRoot} property to `false`.
+     */
+    addRootChildNode(): void;
+    /**
+     * Expands all nodes in the tree dictated by the argument.
+     *
+     * @param path nodes that should be expanded along with their path from the root node
+     */
+    expandPath(path: CaseTreePath): void;
+}

package/lib/view/tree-case-view/tree-component/add-child-node/abstract-add-child-node.component.d.ts

@@ -0,0 +1,8 @@
+import { CaseTreeService } from '../case-tree.service';
+import { CaseTreeNode } from '../model/case-tree-node';
+export declare abstract class AbstractAddChildNodeComponent {
+    protected _treeService: CaseTreeService;
+    node: CaseTreeNode;
+    constructor(_treeService: CaseTreeService);
+    addChild(event: Event): void;
+}

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

@@ -0,0 +1,300 @@
+import { OnDestroy } from '@angular/core';
+import { Filter } from '../../../filter/models/filter';
+import { CaseResourceService } from '../../../resources/engine-endpoint/case-resource.service';
+import { CaseTreeNode } from './model/case-tree-node';
+import { TreeCaseViewService } from '../tree-case-view.service';
+import { TaskResourceService } from '../../../resources/engine-endpoint/task-resource.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { ImmediateData } from '../../../resources/interface/immediate-data';
+import { Case } from '../../../resources/interface/case';
+import { ProcessService } from '../../../process/process.service';
+import { SideMenuService } from '../../../side-menu/services/side-menu.service';
+import { Observable, Subject } from 'rxjs';
+import { Page } from '../../../resources/interface/page';
+import { TranslateService } from '@ngx-translate/core';
+import { NestedTreeControl } from '@angular/cdk/tree';
+import { MatTreeNestedDataSource } from '@angular/material/tree';
+import { CaseGetRequestBody } from '../../../resources/interface/case-get-request-body';
+import { CaseTreePath } from './model/case-tree-path';
+import { ExpansionTree } from './model/expansion-tree';
+import { ResultWithAfterActions } from '../../../utility/result-with-after-actions';
+export declare class CaseTreeService implements OnDestroy {
+    protected _caseResourceService: CaseResourceService;
+    protected _treeCaseViewService: TreeCaseViewService;
+    protected _taskResourceService: TaskResourceService;
+    protected _logger: LoggerService;
+    protected _processService: ProcessService;
+    protected _sideMenuService: SideMenuService;
+    protected _translateService: TranslateService;
+    protected _optionSelectorComponent: any;
+    protected _currentNode: CaseTreeNode;
+    private _rootNodesFilter;
+    private readonly _treeDataSource;
+    private readonly _treeControl;
+    private _treeRootLoaded$;
+    private _rootNode;
+    private _showRoot;
+    /**
+     * Weather the tree is eager loaded or not.
+     *
+     * Defaults to `false`.
+     *
+     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
+     */
+    private _isEagerLoaded;
+    /**
+     * string id of the case, that is currently being reloaded, `undefined` if no case is currently being reloaded
+     */
+    private _reloadedCaseId;
+    constructor(_caseResourceService: CaseResourceService, _treeCaseViewService: TreeCaseViewService, _taskResourceService: TaskResourceService, _logger: LoggerService, _processService: ProcessService, _sideMenuService: SideMenuService, _translateService: TranslateService, _optionSelectorComponent: any);
+    ngOnDestroy(): void;
+    set rootFilter(filter: Filter);
+    get dataSource(): MatTreeNestedDataSource<CaseTreeNode>;
+    get treeControl(): NestedTreeControl<CaseTreeNode>;
+    get currentNode(): CaseTreeNode;
+    /**
+     * Emits a value whenever a new root node Filter is set.
+     *
+     * `true` is emitted if the root node was successfully loaded. `false` otherwise.
+     *
+     * On subscription emits the last emitted value (if any) to the subscriber.
+     */
+    get treeRootLoaded$(): Observable<boolean>;
+    protected get _currentCase(): Case | undefined;
+    /**
+     * @returns an `Observable` of the {@link LoadingEmitter} representing the loading state of the root node.
+     * Returns `undefined` if the tree has not yet been initialized.
+     *
+     * Wait for an emission on the [treeRootLoaded$]{@link CaseTreeService#treeRootLoaded$} stream before getting this Observable.
+     *
+     * The first value emitted by the Observable is `false`, when the tree finishes initializing.
+     */
+    get rootNodeLoading$(): Observable<boolean> | undefined;
+    /**
+     * @returns an `Observable` of the {@link LoadingEmitter} representing whether the root node is currently
+     * in the process of adding a new child node or not.
+     * Returns `undefined` if the tree has not yet been initialized.
+     *
+     * Wait for an emission on the [treeRootLoaded$]{@link CaseTreeService#treeRootLoaded$} stream before getting this Observable.
+     *
+     * The first value emitted by the Observable is `false`, when the tree finishes initializing.
+     */
+    get rootNodeAddingChild$(): Observable<boolean> | undefined;
+    /**
+     * Weather the tree is eager loaded or not.
+     *
+     * Defaults to `false`.
+     *
+     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
+     */
+    get isEagerLoaded(): boolean;
+    /**
+     * Weather the tree is eager loaded or not.
+     *
+     * Defaults to `false`.
+     *
+     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
+     *
+     * @param eager the new setting for eager loading
+     */
+    set isEagerLoaded(eager: boolean);
+    /**
+     * Loads and populates the topmost level of the tree.
+     *
+     * The displayed cases are determined by this object's [rootFilter]{@link CaseTreeService#rootFilter}.
+     *
+     * Cases are loaded one page at a time and the tree is refreshed after each page.
+     * [finishedLoadingFirstLevel$]{@link CaseTreeService#treeRootLoaded$}
+     * will emit `true` once the last page loads successfully.
+     * `false` will be emitted if any of the requests fail.
+     */
+    protected loadTreeRoot(): void;
+    /**
+     * Adds the loaded tree root to the display based on the setting.
+     * @param showRoot whether the root of the tree should be displayed in the tree or not.
+     * If the root is not displayed it's children will be displayed on the first level.
+     * @returns an Observable that emits when the tree finishes initialization.
+     */
+    initializeTree(showRoot: boolean): Observable<void>;
+    /**
+     * Notifies the parent TreeCaseView that a case was clicked in the tree and it's Task should be displayed
+     */
+    changeActiveNode(node: CaseTreeNode | undefined): void;
+    /**
+     * Toggles the expansion state of a node
+     * @param node the {@link CaseTreeNode} who's content should be toggled
+     */
+    toggleNode(node: CaseTreeNode): void;
+    /**
+     * Expands the target node in the tree and reloads it's children if they are marked as dirty
+     * @param node the {@link CaseTreeNode} that should be expanded
+     * @returns emits `true` if the node is expanded and `false` if not. If the expansion causes more node expansions
+     * (e.g. eager loaded tree) then, the Observable emits after all the subtree expansions complete.
+     */
+    protected expandNode(node: CaseTreeNode): Observable<boolean>;
+    /**
+     * Checks whether dirty children need to be reloaded and reloads them if needed.
+     * @param node the {@link CaseTreeNode} who's children are updated
+     * @returns emits when loading finishes
+     */
+    protected updateNodeChildren(node: CaseTreeNode): Observable<void>;
+    /**
+     * Loads every page of children from the given number and updates the existing children.
+     *
+     * Missing nodes are removed. Existing nodes are marked as dirty. New nodes are added.
+     *
+     * Nodes are returned in their insertion order.
+     * @param node the {@link CaseTreeNode} who's children are updated
+     * @param pageNumber the number of the first page that should be loaded. All following pages are loaded as well
+     * @returns next is emitted when loading of all pages completes (regardless of the outcome)
+     */
+    protected updatePageOfChildren(node: CaseTreeNode, pageNumber: number): Observable<void>;
+    /**
+     * Updates the children of the given {@link CaseTreeNode} with [Cases]{@link Case} from the provided {@link Page}.
+     * @param node the {@link CaseTreeNode} who's children are updated
+     * @param page the {@link Page} that contains the updated children
+     */
+    protected updateCurrentChildrenWithNewPage(node: CaseTreeNode, page: Page<Case>): void;
+    /**
+     * @param node the {@link CaseTreeNode} who's children the {@link Filter} should return
+     * @returns a request body that finds all child cases of the given `node`.
+     * Returns `undefined` if the provided `node` doesn't contain enough information to create the request body.
+     */
+    protected createChildRequestBody(node: CaseTreeNode): CaseGetRequestBody;
+    /**
+     * Adds a child to the root node.
+     *
+     * Useful if you are using the layout where the root node is hidden.
+     * @returns emits `true` if the child was successfully added, `false` if not
+     */
+    addRootChildNode(): Observable<boolean>;
+    /**
+     * Adds a new child node to the given node based on the properties of the node's case
+     * @returns emits `true` if the child was successfully added, `false` if not
+     */
+    addChildNode(clickedNode: CaseTreeNode): Observable<boolean>;
+    /**
+     * Creates a new case and adds it to the children of the specified node
+     * @param processIdentifier identifier of the process that should be created
+     * @param clickedNode the node that is the parent of the new case
+     * @param operationResult the result of the operation will be emitted into this stream when the operation completes
+     */
+    protected createAndAddChildCase(processIdentifier: string, clickedNode: CaseTreeNode, operationResult: Subject<boolean>): void;
+    /**
+     * Updates the tree after adding a new child
+     * @param clickedNode the parent node
+     * @param newCaseRefValue the new value of the parent node's case ref
+     * @param operationResult the result of the operation will be emitted into this stream when the operation completes
+     */
+    protected updateTreeAfterChildAdd(clickedNode: CaseTreeNode, newCaseRefValue: Array<string>, operationResult: Subject<boolean>): void;
+    /**
+     * removes the provided non-root node if the underlying case allows it.
+     *
+     * The underlying case is removed from the case ref of it's parent element with the help from the `remove`
+     * operation provided by case ref itself.
+     * @param node the node that should be removed from the tree
+     */
+    removeNode(node: CaseTreeNode): void;
+    /**
+     * Expands all nodes in the tree dictated by the argument.
+     *
+     * @param path nodes that should be expanded along with their path from the root node
+     */
+    expandPath(path: CaseTreePath): void;
+    /**
+     * Transforms a {@Link CaseTreePath} object into an {@link ExpansionTree} object.
+     * The result has all the common paths merged into single branches of the resulting tree structure.
+     *
+     * @param paths nodes that should be expanded along with their path from the root node
+     * @returns an {@link ExpansionTree} equivalent to the provided {@link CaseTreePath}
+     */
+    protected convertPathToExpansionTree(paths: CaseTreePath): ExpansionTree;
+    /**
+     * Recursively expands all nodes from the provided array of nodes, that appear in the top level of the {@link ExpansionTree} object.
+     *
+     * @param levelNodes nodes from which the expansion should start
+     * @param targets a tree structure representing the nodes that are to be expanded recursively.
+     * The top level nodes are expanded first, from the provided `levelNodes`.
+     */
+    protected expandLevel(levelNodes: Array<CaseTreeNode>, targets: ExpansionTree): void;
+    /**
+     * Deletes the subtrees rooted at the nodes that are present in the parent node's child case ref values,
+     * but are no longer present in the new value
+     * @param parentNode an inner node of the tree that had some of it's children removed
+     * @param newCaseRefValue the new value of the parent node's case ref
+     */
+    protected deleteRemovedNodes(parentNode: CaseTreeNode, newCaseRefValue: Array<string>): void;
+    /**
+     * Deselects the currently selected node if it is a descendant of the provided node
+     * @param node the node who's descendants should be deselected
+     */
+    protected deselectNodeIfDescendantOf(node: CaseTreeNode): void;
+    /**
+     * Performs a backend call on the given case, and sets the value of the case ref field in the transition defined by
+     * [CASE_REF_TRANSITION]{@link TreePetriflowIdentifiers#CASE_REF_TRANSITION}.
+     * @param caseId string ID of the case that should have it's tree case ref set
+     * @param newCaseRefValue the new value of the case ref field
+     */
+    private performCaseRefCall;
+    /**
+     * Performs an update after adding or removing a node from the tree.
+     *
+     * If only one node was added adds it into the tree
+     *
+     * If only one node was removed removes it from the tree
+     *
+     * Otherwise collapses the affected node and marks it's children as dirty
+     *
+     * @param affectedNode node that had it's children changed
+     * @param newCaseRefValue new value of the caseRef field returned by backend
+     * @returns an `Observable` that emits an object with the [result]{@link ResultWithAfterActions#result} attribute set to `true` if
+     * the update completes successfully and `false` otherwise.
+     */
+    private updateNodeChildrenFromChangedFields;
+    /**
+     * Adds a new child node to the `affectedNode` by adding the last Case from the `newCaseRefValue`
+     * @param affectedNode the node in the tree that had a child added - the parent node
+     * @param caseRefField the case ref field of the affected node
+     * @param newCaseRefValue the new value of the case ref field in the node
+     * @returns an `Observable` that emits `true` if a node was successfully added, `false` otherwise.
+     */
+    protected processChildNodeAdd(affectedNode: CaseTreeNode, caseRefField: ImmediateData, newCaseRefValue: Array<string>): Observable<ResultWithAfterActions<boolean>>;
+    /**
+     * Adds a new child node to the target parent node.
+     * @param parentNode the nodes whose child should be added
+     * @param childCase the child case
+     * @returns the newly added node
+     */
+    protected pushChildToTree(parentNode: CaseTreeNode, childCase: Case): CaseTreeNode;
+    /**
+     * Removes the deleted node from the children of the `affectedNode`
+     * @param affectedNode the node in the tree that had it's child removed
+     * @param caseRefField the case ref field of the affected node
+     * @param newCaseRefValues the new value of the case ref field in the node
+     * @returns an `Observable` that emits `true` when the remove operation completes.
+     */
+    protected processChildNodeRemove(affectedNode: CaseTreeNode, caseRefField: ImmediateData, newCaseRefValues: Set<string>): Observable<ResultWithAfterActions<boolean>>;
+    /**
+     * @ignore
+     * Forces a rerender of the tree content
+     */
+    private refreshTree;
+    /**
+     * Reloads the currently selected case node. The {@link Case} object held in the {@link CaseTreeNode} instance is not replaced,
+     * but the new Case is `Object.assign`-ed into it. This means that the reference to the Case instance is unchanged but references
+     * to all it's non-primitive attributes are changed.
+     *
+     * If a reload of the current node is initiated before the previous one completed, the new one is ignored.
+     *
+     * If the currently selected case changed before a response from backend was received the response is ignored.
+     *
+     * Note that the parent node, nor the child nodes are reloaded.
+     */
+    protected reloadCurrentCase(): void;
+    /**
+     * Determines if anny of the case attributes that are visible on the tree changed.
+     * @param oldCase the previous version of the Case object, that is currently displayed on the tree
+     * @param newCase the new version of the Case object, that should replace the old one
+     */
+    private determineCaseUpdate;
+}

package/lib/view/tree-case-view/tree-component/model/case-tree-node.d.ts

@@ -0,0 +1,57 @@
+import { Case } from '../../../../resources/interface/case';
+import { LoadingEmitter } from '../../../../utility/loading-emitter';
+export declare class CaseTreeNode {
+    case: Case;
+    children: Array<CaseTreeNode>;
+    dirtyChildren: boolean;
+    loadingChildren: LoadingEmitter;
+    removingNode: LoadingEmitter;
+    addingNode: LoadingEmitter;
+    parent: CaseTreeNode;
+    constructor(nodeCase: Case, parentNode: CaseTreeNode);
+    /**
+     * @returns whether this node has the value `true` in it's [immediate data field]{@link TreePetriflowIdentifiers#CAN_ADD_CHILDREN}
+     * that controls this behavior.
+     */
+    canAddChildren(): boolean;
+    /**
+     * @returns whether this node has the value `true` in it's [immediate data field]{@link TreePetriflowIdentifiers#CAN_REMOVE_NODE}
+     * that controls this behavior.
+     */
+    canBeRemoved(): boolean;
+    /**
+     * @returns whether this node's children are currently being loaded
+     */
+    isLoadingChildren(): boolean;
+    /**
+     * @returns whether this node is being removed from the tree
+     */
+    isBeingRemoved(): boolean;
+    /**
+     * @returns whether children are being added to this node
+     */
+    isAddingNode(): boolean;
+    /**
+     * @returns return node value, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#BEFORE_TEXT_ICON} type exists
+     */
+    beforeTextIcon(): string;
+    /**
+     * @returns return node value, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#TREE_ADD_ICON} type exists
+     */
+    treeAddTextIcon(): string;
+    /**
+     * @returns return node title, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#BEFORE_TEXT_ICON} type exists
+     */
+    beforeTextIconTitle(): string;
+    /**
+     * @returns return node title if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#TREE_ADD_ICON} type exists
+     */
+    treeAddTextIconTitle(): string;
+    private searchImmediateData;
+    /**
+     * @returns an object representing the same CaseTreeNode, but with circular references removed, so that it can be serialized and logged.
+     * The [parent]{@link CaseTreeNode#parent} reference is replaced by the parents case stringId (if defined).
+     * The [children]{@link CaseTreeNode#children} references are replaced by the child's case stringId (if defined).
+     */
+    toLoggableForm(): object;
+}

package/lib/view/tree-case-view/tree-component/model/case-tree-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A path in a case ref tree structure.
+ *
+ * Attributes are stringIds of child cases. Their values are arrays containing the path from root to the child.
+ */
+export interface CaseTreePath {
+    [childId: string]: Array<string>;
+}

package/lib/view/tree-case-view/tree-component/model/expansion-tree.d.ts

@@ -0,0 +1,6 @@
+/**
+ * An object that represents a tree of {@link CaseTreeNode} that should be expanded.
+ */
+export interface ExpansionTree {
+    [nodeId: string]: ExpansionTree;
+}

package/lib/view/tree-case-view/tree-component/remove-node/abstract-remove-node.component.d.ts

@@ -0,0 +1,8 @@
+import { CaseTreeNode } from '../model/case-tree-node';
+import { CaseTreeService } from '../case-tree.service';
+export declare abstract class AbstractRemoveNodeComponent {
+    protected _treeService: CaseTreeService;
+    node: CaseTreeNode;
+    constructor(_treeService: CaseTreeService);
+    removeNode(event: Event): void;
+}

package/lib/view/tree-case-view/tree-task-content/abstract-tree-task-content.component.d.ts

@@ -0,0 +1,32 @@
+import { AfterViewInit } from '@angular/core';
+import { TaskContentService } from '../../../task-content/services/task-content.service';
+import { AssignTaskService } from '../../../task/services/assign-task.service';
+import { TaskEventService } from '../../../task-content/services/task-event.service';
+import { CancelTaskService } from '../../../task/services/cancel-task.service';
+import { FinishTaskService } from '../../../task/services/finish-task.service';
+import { TreeTaskContentService } from './tree-task-content.service';
+import { Observable } from 'rxjs';
+import { PermissionService } from '../../../authorization/permission/permission.service';
+export declare abstract class AbstractTreeTaskContentComponent implements AfterViewInit {
+    protected _treeTaskContentService: TreeTaskContentService;
+    protected _taskEventService: TaskEventService;
+    protected _assign: AssignTaskService;
+    protected _cancel: CancelTaskService;
+    protected _finish: FinishTaskService;
+    protected _taskContentService: TaskContentService;
+    protected _permissionService: PermissionService;
+    displayTaskControlButtons: boolean;
+    constructor(_treeTaskContentService: TreeTaskContentService, _taskEventService: TaskEventService, _assign: AssignTaskService, _cancel: CancelTaskService, _finish: FinishTaskService, _taskContentService: TaskContentService, _permissionService: PermissionService);
+    ngAfterViewInit(): void;
+    canAssign(): boolean;
+    canCancel(): boolean;
+    canFinish(): boolean;
+    assign(): void;
+    cancel(): void;
+    finish(): void;
+    getAssignTitle(): string;
+    getCancelTitle(): string;
+    getFinishTitle(): string;
+    get processingTaskChange(): boolean;
+    get taskContentText$(): Observable<string>;
+}

package/lib/view/tree-case-view/tree-task-content/tree-task-content.service.d.ts

@@ -0,0 +1,112 @@
+import { OnDestroy } from '@angular/core';
+import { TaskContentService } from '../../../task-content/services/task-content.service';
+import { TaskDataService } from '../../../task/services/task-data.service';
+import { CancelTaskService } from '../../../task/services/cancel-task.service';
+import { TaskEventService } from '../../../task-content/services/task-event.service';
+import { TaskResourceService } from '../../../resources/engine-endpoint/task-resource.service';
+import { TreeCaseViewService } from '../tree-case-view.service';
+import { Case } from '../../../resources/interface/case';
+import { Task } from '../../../resources/interface/task';
+import { AssignPolicyService } from '../../../task/services/assign-policy.service';
+import { SubjectTaskOperations } from '../../../task/models/subject-task-operations';
+import { UserComparatorService } from '../../../user/services/user-comparator.service';
+import { CallChainService } from '../../../utility/call-chain/call-chain.service';
+import { Observable } from 'rxjs';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { SelectedCaseService } from '../../../task/services/selected-case.service';
+import { Filter } from '../../../filter/models/filter';
+import { PermissionService } from '../../../authorization/permission/permission.service';
+import { ChangedFieldsService } from '../../../changed-fields/services/changed-fields.service';
+export declare class TreeTaskContentService implements OnDestroy {
+    protected _treeCaseService: TreeCaseViewService;
+    protected _taskDataService: TaskDataService;
+    protected _taskContentService: TaskContentService;
+    protected _taskResourceService: TaskResourceService;
+    protected _taskEventService: TaskEventService;
+    protected _assignPolicy: AssignPolicyService;
+    protected _cancel: CancelTaskService;
+    protected _userComparator: UserComparatorService;
+    protected _callchain: CallChainService;
+    protected _logger: LoggerService;
+    protected _selectedCaseService: SelectedCaseService;
+    protected _changedFieldsService: ChangedFieldsService;
+    protected _permissionService: PermissionService;
+    protected _taskOperations: SubjectTaskOperations;
+    private _processingTaskChange;
+    private _displayedTaskText$;
+    /**
+     * a unique identifier consisting of caseId and transition ID
+     *
+     * Is set if a reload of the given task is currently taking place, `undefined` otherwise.
+     */
+    private _reloadedTaskUniqueIdentifier;
+    constructor(_treeCaseService: TreeCaseViewService, _taskDataService: TaskDataService, _taskContentService: TaskContentService, _taskResourceService: TaskResourceService, _taskEventService: TaskEventService, _assignPolicy: AssignPolicyService, _cancel: CancelTaskService, _userComparator: UserComparatorService, _callchain: CallChainService, _logger: LoggerService, _selectedCaseService: SelectedCaseService, _changedFieldsService: ChangedFieldsService, _permissionService: PermissionService, _taskOperations: SubjectTaskOperations);
+    get taskContentText$(): Observable<string>;
+    get processingTaskChange(): boolean;
+    displayEmptyTaskContent(): void;
+    /**
+     * Cancels the currently selected {@link Task} if any. And then loads and assigns the new Task.
+     * @param selectedCase the Case who's task should be now displayed
+     */
+    protected cancelAndLoadFeaturedTask(selectedCase: Case | undefined): void;
+    /**
+     * Changes the currently displayed {@link Task} based on the selected {@link Case} from the Tree.
+     * @param selectedCase the Case who's task should be now displayed
+     */
+    protected loadFeaturedTask(selectedCase: Case | undefined): void;
+    /**
+     * Checks whether the currently displayed task differs from the new one
+     * @param newCase [Case]{@link Case} object that holds the newly selected {@link Task}
+     * @returns `true` if the currently selected Case has a different ID from the newly selected Case.
+     * If the IDs are the same returns `true` if the transition IDs are different.
+     * Returns `false` otherwise.
+     */
+    private taskChanged;
+    /**
+     * Checks whether a Task object is currently selected and if it can be cancelled by the user
+     */
+    private get shouldCancelTask();
+    /**
+     * Creates a {@link Filter} object that finds the specified Task for the currently selected Case in a Tree Case View
+     * @returns a request body that finds tasks of the given case with task id that corresponds to the value in the `treeTaskTransitionId`
+     * immediate data field. Returns `undefined` if the request body cannot be created.
+     */
+    protected getTaskFilter(): Filter | undefined;
+    /**
+     * @param examinedCase the {@link Case} object from which we want to extract the transition ID
+     * @returns the ID of the transition that should be displayed in the {@link AbstractTaskContentComponent},
+     * or `undefined` if the currently selected case doesn't define it
+     */
+    protected getTransitionId(examinedCase: Case): string | undefined;
+    /**
+     * Changes the currently selected {@link Task}.
+     * @param task the Task that should now be selected
+     */
+    protected switchToTask(task: Task): void;
+    /**
+     * Notifies all connected Services that no Task is currently selected
+     */
+    protected clearCurrentTask(): void;
+    /**
+     * Updates the state of the current Task from backend
+     */
+    protected updateTaskState(): void;
+    /**
+     * If the current {@link Task} is assigned to the current user it is unblocked. Otherwise it is blocked.
+     */
+    protected resolveTaskBlockState(): void;
+    /**
+     * Sets the noData text in the task content to it's default value
+     */
+    protected setStandardTaskText(): void;
+    /**
+     * Attempts to cancel the currently opened Task if the Task is in such state that allows cancellation.
+     */
+    ngOnDestroy(): void;
+    /**
+     * @returns a unique identifier for the currently selected task, that consists of it's case's id and it's transition id.
+     *
+     * Returns `undefined`, if no task is currently selected.
+     */
+    protected getUniqueTaskIdentifier(): string;
+}