@netgrif/components-core 6.0.1

package/lib/tabs/interfaces.d.ts

@@ -0,0 +1,135 @@
+import { Type } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+/**
+ * Stores information about content of one opened tab in tab view.
+ *
+ * See {@link TabView} for more information about the usage of this interface.
+ */
+export interface TabContent {
+    /**
+     * Contents of the tab label.
+     *
+     * Only attributes with defined values are displayed in the label.
+     * You can have both icon and text displayed, either one, or neither.
+     * Icon is displayed in front of the text.
+     */
+    label?: TabLabel;
+    /**
+     * A close button will be displayed after the text in the label if the tab can be closed.
+     */
+    canBeClosed: boolean;
+    /**
+     * Class name of the Component that should be displayed as the tab content.
+     */
+    tabContentComponent: Type<any>;
+    /**
+     * Data that you want to make available for injection to the tab content component.
+     *
+     * The data can be injected trough the `NAE_TAB_DATA` injection token.
+     *
+     * See [InjectedTabData]{@link InjectedTabData} for more information about the format of the injected object.
+     */
+    injectedObject?: object;
+    /**
+     * Determines the natural ordering of the tabs.
+     *
+     * Tabs are ordered from left to right in ascending order.
+     * If two tabs have the same order the one that was created later will appear further to the right.
+     *
+     * Defaults to `0`.
+     */
+    order?: number;
+    /**
+     * Whether the tab was initially opened. Only initially opened tabs have their view ID defined.
+     * Tabs that are opened dynamically don't have a view ID and thus cannot save their state into user preferences.
+     *
+     * This attribute is only used when initial tabs are created. The [openTab]{@link TabView#openTab} method ignores this attribute
+     * and logs a warning if it is set on the provided object.
+     */
+    initial?: boolean;
+    /**
+     * When we need to know, tho which tab we need to switch when we close current tab, we need a parent unique id, its
+     * a unique ID of tab, from which we open current tab. Initial tabs and case tabs dont have those property.
+     */
+    parentUniqueId?: string;
+}
+/**
+ * Stores information about the label of a tab in tab view.
+ *
+ * See {@link TabContent#label} for more information.
+ */
+export interface TabLabel {
+    /**
+     * Material design icon name.
+     *
+     * See [material website]{@link https://material.io/resources/icons} for supported icon list.
+     */
+    icon?: string;
+    /**
+     * Tab name that is displayed in it's label.
+     *
+     * The text is passed trough the translate pipe. If you want the tab label to be translated simply pass the translation key as value.
+     */
+    text?: string;
+    /**
+     * Tab count is displayed in it's label, ich stream is provided
+     */
+    count?: ReplaySubject<number>;
+}
+/**
+ * The base interface for data injected into tabs.
+ * This information is made available for injection to any tab content component trough the `NAE_TAB_DATA` injection token.
+ * If {@link TabContent} has the `injectedObject` defined, then that data is provided as well.
+ * Should there be a key conflict in the objects, then values from this interface take precedence and replace the provided data.
+ */
+export interface InjectedTabData {
+    /**
+     * Uniquely identifies the tab within the tab view.
+     */
+    tabUniqueId: string;
+    /**
+     * Reference to the parent tab view allowing some control over it from the tab content component.
+     */
+    tabViewRef: TabViewInterface;
+    /**
+     * `true` is emitted into this stream when the tab is switched into.
+     *
+     * `false` is emitted into this stream when the tab is switched away from.
+     */
+    tabSelected$: Observable<boolean>;
+    /**
+     * stream emits when the tab is closed by any means except for the destruction of the parent component
+     */
+    tabClosed$: Observable<void>;
+}
+/**
+ * Methods of parent tab view, that tabs can access.
+ *
+ * See {@link TabView} for more information.
+ */
+export interface TabViewInterface {
+    /**
+     * See [TabView.currentlySelectedTab]{@link TabView#currentlySelectedTab}
+     */
+    currentlySelectedTab(): number;
+    /**
+     * See [TabView.openTab]{@link TabView#openTab}
+     */
+    openTab(tabContent: TabContent, autoswitch?: boolean, openExising?: boolean): string;
+    /**
+     * See [TabView.switchToTabIndex]{@link TabView#switchToTabIndex}
+     */
+    switchToTabIndex(index: number): void;
+    /**
+     * See [TabView.uniqueId]{@link TabView#uniqueId}
+     */
+    switchToTabUniqueId(uniqueId: string): void;
+    /**
+     * See [TabView.closeTabIndex]{@link TabView#closeTabIndex}
+     */
+    closeTabIndex(index: number, force?: boolean): void;
+    /**
+     * See [TabView.closeTabUniqueId]{@link TabView#closeTabUniqueId}
+     */
+    closeTabUniqueId(uniqueId: string, force?: boolean): void;
+}

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

@@ -0,0 +1,5 @@
+export * from './interfaces';
+export * from './tab-data-injection-token/tab-data-injection-token';
+export * from './tab-view/abstract-tab-view.component';
+export * from './tab-creation-detector/abstract-tab-creation-detector.component';
+export * from './classes/tab-view';

package/lib/tabs/tab-creation-detector/abstract-tab-creation-detector.component.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from '@angular/core';
+/**
+ * @ignore
+ * Class that detects tab content creation and then initializes then calls the provided `initializeTab` function.
+ * It is necessary if the tab content is lazy loaded, because the
+ * ComponentPortal's outlet must be initialized before the Portal itself is created.
+ */
+export declare abstract class AbstractTabCreationDetectorComponent implements OnInit {
+    /**
+     * function that should be called when the tab content is created
+     */
+    initializeTabFunction: (index: number) => void;
+    /**
+     * index of the tab that the `initializeTabFunction` should be called for
+     */
+    tabIndex: number;
+    ngOnInit(): void;
+}

package/lib/tabs/tab-data-injection-token/tab-data-injection-token.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+import { InjectedTabData } from '../interfaces';
+/**
+ * Injection token for injection of {@link InjectedTabData} into tabs in {@link TabView}.
+ *
+ * Also see {@link TabContent} for more information.
+ */
+export declare const NAE_TAB_DATA: InjectionToken<InjectedTabData>;

package/lib/tabs/tab-view/abstract-tab-view.component.d.ts

@@ -0,0 +1,38 @@
+import { Injector, OnDestroy, OnInit } from '@angular/core';
+import { TabContent } from '../interfaces';
+import { TabView } from '../classes/tab-view';
+import { ViewService } from '../../routing/view-service/view.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { ReplaySubject } from 'rxjs';
+/**
+ * Component that renders a tab view.
+ *
+ * See {@link TabView} for the class that holds the logic for this view.
+ */
+export declare abstract class AbstractTabViewComponent implements OnInit, OnDestroy {
+    protected _viewService: ViewService;
+    protected _logger: LoggerService;
+    protected _injector: Injector;
+    /**
+     * Tabs that are opened initially in the view
+     */
+    initialTabs: Array<TabContent>;
+    /**
+     * Flag if the height of the content has to stretch to fill the available window
+     */
+    stretch: boolean;
+    tabView: TabView;
+    align: string;
+    offset: string;
+    /**
+     * @ignore
+     * lambda function that is passed to the {@link AbstractTabCreationDetectorComponent}s
+     */
+    initializeTabLambda: (index: number) => void;
+    protected constructor(_viewService: ViewService, _logger: LoggerService, _injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    badgeHidden(tab: TabContent): ReplaySubject<boolean>;
+    badgeCount(tab: TabContent): ReplaySubject<string>;
+    private setOffset;
+}

package/lib/task/interfaces/task-operations.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Represents abstract operations on a task.
+ * The concrete implementation depends on the way the tasks are displayed and represented by some specific Component.
+ *
+ * For example if tasks are panels, then the [open]{@link TaskOperations#open} operation corresponds to the panels expansion
+ * and the [close]{@link TaskOperations#close} operation corresponds to the panel collapsing.
+ */
+export interface TaskOperations {
+    /**
+     * A function that opens the task's representation.
+     *
+     * Eg. a task panel expanding.
+     */
+    open: () => void;
+    /**
+     * A function that closes the Task's representation.
+     *
+     * Eg. a task panel collapsing.
+     */
+    close: () => void;
+    /**
+     * A function that reloads the Task's representation.
+     * If the representation contains more Tasks it is advised to reload all of them.
+     *
+     * Eg. the current page of a task list is reloaded
+     */
+    reload: () => void;
+    /**
+     * A function that reloads the Task's representation.
+     * If the representation contains more Tasks it is advised to reload all of them.
+     *
+     * Eg. the current page of a task list is reloaded
+     */
+    forceReload?: () => void;
+}

package/lib/task/models/null-task-operations.d.ts

@@ -0,0 +1,22 @@
+import { TaskOperations } from '../interfaces/task-operations';
+/**
+ * Null implementation of the {@link TaskOperations} interface.
+ */
+export declare class NullTaskOperations implements TaskOperations {
+    /**
+     * Calling this function does nothing
+     */
+    close(): void;
+    /**
+     * Calling this function does nothing
+     */
+    open(): void;
+    /**
+     * Calling this function does nothing
+     */
+    reload(): void;
+    /**
+     * Calling this function does nothing
+     */
+    forceReload(): void;
+}

package/lib/task/models/subject-task-operations.d.ts

@@ -0,0 +1,37 @@
+import { TaskOperations } from '../interfaces/task-operations';
+import { Observable, Subject } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+/**
+ * An implementation of the {@link TaskOperations} interface that provides a Subject for both operations.
+ */
+export declare class SubjectTaskOperations implements TaskOperations, OnDestroy {
+    protected _open: Subject<void>;
+    protected _close: Subject<void>;
+    protected _reload: Subject<void>;
+    protected _forceReload: Subject<void>;
+    constructor();
+    /**
+     * Emits into the [open$]{@link SubjectTaskOperations#open$} stream.
+     */
+    open(): void;
+    /**
+     * Emits into the [close$]{@link SubjectTaskOperations#close$} stream.
+     */
+    close(): void;
+    /**
+     * Emits into the [reload$]{@link SubjectTaskOperations#reload$} stream.
+     */
+    reload(): void;
+    /**
+     * Emits into the [forceReload$]{@link SubjectTaskOperations#forceReload$} stream.
+     */
+    forceReload(): void;
+    get open$(): Observable<void>;
+    get close$(): Observable<void>;
+    get reload$(): Observable<void>;
+    get forceReload$(): Observable<void>;
+    /**
+     * Completes the underlying streams
+     */
+    ngOnDestroy(): void;
+}

package/lib/task/models/task-operations-injection-token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { TaskOperations } from '../interfaces/task-operations';
+export declare const NAE_TASK_OPERATIONS: InjectionToken<TaskOperations>;

package/lib/task/models/task-set-data-request-context.d.ts

@@ -0,0 +1,11 @@
+import { TaskSetDataRequestBody } from '../../resources/interface/task-set-data-request-body';
+/**
+ * Holds the information about a `setData` request, alongside with the previous values,
+ * so that a queued request can be reverted, if it fails.
+ */
+export interface TaskSetDataRequestContext {
+    body: TaskSetDataRequestBody;
+    previousValues: {
+        [fieldId: string]: any;
+    };
+}

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

@@ -0,0 +1,15 @@
+export * from './services/assign-task.service';
+export * from './services/cancel-task.service';
+export * from './services/delegate-task.service';
+export * from './services/finish-task.service';
+export * from './services/task-request-state.service';
+export * from './services/task-data.service';
+export * from './services/data-focus-policy.service';
+export * from './services/assign-policy.service';
+export * from './services/finish-policy.service';
+export * from './services/task-handling-service';
+export * from './services/selected-case.service';
+export * from './models/task-operations-injection-token';
+export * from './models/subject-task-operations';
+export * from './models/null-task-operations';
+export * from './interfaces/task-operations';

package/lib/task/services/assign-policy.service.d.ts

@@ -0,0 +1,81 @@
+import { TaskHandlingService } from './task-handling-service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskDataService } from './task-data.service';
+import { AssignTaskService } from './assign-task.service';
+import { CancelTaskService } from './cancel-task.service';
+import { FinishPolicyService } from './finish-policy.service';
+import { TaskOperations } from '../interfaces/task-operations';
+import { CallChainService } from '../../utility/call-chain/call-chain.service';
+import { Subject } from 'rxjs';
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { AfterAction } from '../../utility/call-chain/after-action';
+import { PermissionService } from '../../authorization/permission/permission.service';
+/**
+ * Handles the sequence of actions that are performed when a task is being assigned, based on the task's configuration.
+ */
+export declare class AssignPolicyService extends TaskHandlingService {
+    protected _taskDataService: TaskDataService;
+    protected _assignTaskService: AssignTaskService;
+    protected _cancelTaskService: CancelTaskService;
+    protected _finishPolicyService: FinishPolicyService;
+    protected _callchain: CallChainService;
+    protected _userComparatorService: UserComparatorService;
+    protected _taskOperations: TaskOperations;
+    protected _permissionService: PermissionService;
+    private _isForced;
+    constructor(_taskDataService: TaskDataService, _assignTaskService: AssignTaskService, _cancelTaskService: CancelTaskService, _finishPolicyService: FinishPolicyService, _callchain: CallChainService, _userComparatorService: UserComparatorService, _taskOperations: TaskOperations, taskContentService: TaskContentService, _permissionService: PermissionService);
+    get forced(): boolean;
+    set forced(bool: boolean);
+    /**
+     * Performs the actions that correspond to the policy defined by the Task on it's assignment.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    performAssignPolicy(taskOpened: boolean, afterAction?: AfterAction): void;
+    /**
+     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    protected autoAssignPolicy(taskOpened: boolean, afterAction: AfterAction): void;
+    /**
+     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}
+     * when a task is 'opening' (eg. task panel is expanding).
+     *
+     * Assigns the task, reloads the current task page, loads task data and performs the finish policy.
+     *
+     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    protected autoAssignOpenedPolicy(afterAction: AfterAction): void;
+    /**
+     * Reloads the current page of tasks if the preceding assign operation succeeded. Then initializes the task's data fields.
+     * @param assignSuccess whether the preceding assign succeeded or not
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    protected afterAssignOpenPolicy(assignSuccess: boolean, afterAction: AfterAction): void;
+    /**
+     * Requests a reload of the task and then requests the task to be closed.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    protected autoAssignClosedPolicy(afterAction: Subject<boolean>): void;
+    /**
+     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    protected manualAssignPolicy(taskOpened: boolean, afterAction: AfterAction): void;
+    /**
+     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}
+     * when a task is 'opening' (eg. task panel is expanding).
+     *
+     * Loads task data and performs the [finish policy]{@link FinishPolicyService#performFinishPolicy}.
+     *
+     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    protected manualAssignOpenedPolicy(afterAction: AfterAction): void;
+}

package/lib/task/services/assign-task.service.d.ts

@@ -0,0 +1,78 @@
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { TaskRequestStateService } from './task-request-state.service';
+import { TaskHandlingService } from './task-handling-service';
+import { TaskOperations } from '../interfaces/task-operations';
+import { SelectedCaseService } from './selected-case.service';
+import { TaskEventService } from '../../task-content/services/task-event.service';
+import { TaskDataService } from './task-data.service';
+import { TaskViewService } from '../../view/task-view/service/task-view.service';
+import { EventQueueService } from '../../event-queue/services/event-queue.service';
+import { AfterAction } from '../../utility/call-chain/after-action';
+import { ChangedFieldsService } from '../../changed-fields/services/changed-fields.service';
+import { EventService } from '../../event/services/event.service';
+/**
+ * Service that handles the logic of assigning a task.
+ */
+export declare class AssignTaskService extends TaskHandlingService {
+    protected _log: LoggerService;
+    protected _taskResourceService: TaskResourceService;
+    protected _snackBar: SnackBarService;
+    protected _translate: TranslateService;
+    protected _taskState: TaskRequestStateService;
+    protected _taskEvent: TaskEventService;
+    protected _taskDataService: TaskDataService;
+    protected _eventQueue: EventQueueService;
+    protected _eventService: EventService;
+    protected _changedFieldsService: ChangedFieldsService;
+    protected _taskOperations: TaskOperations;
+    protected _taskViewService: TaskViewService;
+    constructor(_log: LoggerService, _taskResourceService: TaskResourceService, _snackBar: SnackBarService, _translate: TranslateService, _taskState: TaskRequestStateService, _taskEvent: TaskEventService, _taskDataService: TaskDataService, _eventQueue: EventQueueService, _eventService: EventService, _changedFieldsService: ChangedFieldsService, _taskOperations: TaskOperations, _selectedCaseService: SelectedCaseService, _taskViewService: TaskViewService, _taskContentService: TaskContentService);
+    /**
+     * Performs the 'assign' operation on the task held by {@link TaskContentService}.
+     *
+     * Doesn't send any requests if the loading indicator is in it's active state.
+     * Otherwise sets the indicator to the active state and disables it once the request response is received.
+     *
+     * The argument can be used to chain operations together,
+     * or to execute code conditionally based on the success state of the assign operation.
+     *
+     * If the task held within the {@link TaskContentService} changes before a response is received, the response will be ignored
+     * and the `afterAction` will not be executed.
+     * @param afterAction if assign completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted
+     */
+    assign(afterAction?: AfterAction): void;
+    /**
+     * Performs an `assign` request on the task currently stored in the `taskContent` service
+     * @param afterAction the action that should be performed after the request is processed
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param forceReload whether a force reload of the task data should be performed after assign.
+     * If set to `false` a regular reload is performed instead.
+     */
+    protected performAssignRequest(afterAction: AfterAction, nextEvent: AfterAction, forceReload: boolean): void;
+    /**
+     * Calls the endpoint and processes the possible responses.
+     * @param afterAction the action that should be performed after the request is processed
+     * @param assignedTaskId the id of the task that is being assigned
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param forceReload whether a force reload of the task data should be performed after assign.
+     * If set to `false` a regular reload is performed instead.
+     */
+    protected assignRequest(afterAction: AfterAction, assignedTaskId: string, nextEvent: AfterAction, forceReload: boolean): void;
+    /**
+     * Reloads the task and emits `true` to the `afterAction` stream
+     */
+    protected completeSuccess(afterAction: AfterAction, nextEvent: AfterAction): void;
+    /**
+     * complete all action streams and send notification with selected boolean
+     */
+    protected completeActions(afterAction: AfterAction, nextEvent: AfterAction, bool: boolean): void;
+    /**
+     * Publishes an assign notification to the {@link TaskEventService}
+     * @param success whether the assign operation was successful or not
+     */
+    protected sendNotification(success: boolean): void;
+}

package/lib/task/services/cancel-task.service.d.ts

@@ -0,0 +1,79 @@
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskEventService } from '../../task-content/services/task-event.service';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { TranslateService } from '@ngx-translate/core';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TaskRequestStateService } from './task-request-state.service';
+import { TaskHandlingService } from './task-handling-service';
+import { TaskOperations } from '../interfaces/task-operations';
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { SelectedCaseService } from './selected-case.service';
+import { TaskDataService } from './task-data.service';
+import { TaskViewService } from '../../view/task-view/service/task-view.service';
+import { EventQueueService } from '../../event-queue/services/event-queue.service';
+import { AfterAction } from '../../utility/call-chain/after-action';
+import { PermissionService } from '../../authorization/permission/permission.service';
+import { ChangedFieldsService } from '../../changed-fields/services/changed-fields.service';
+import { EventService } from '../../event/services/event.service';
+/**
+ * Service that handles the logic of canceling a task.
+ */
+export declare class CancelTaskService extends TaskHandlingService {
+    protected _log: LoggerService;
+    protected _taskEventService: TaskEventService;
+    protected _taskResourceService: TaskResourceService;
+    protected _translate: TranslateService;
+    protected _snackBar: SnackBarService;
+    protected _taskState: TaskRequestStateService;
+    protected _userComparator: UserComparatorService;
+    protected _taskEvent: TaskEventService;
+    protected _taskDataService: TaskDataService;
+    protected _eventQueue: EventQueueService;
+    protected _eventService: EventService;
+    protected _changedFieldsService: ChangedFieldsService;
+    protected _taskOperations: TaskOperations;
+    protected _taskViewService: TaskViewService;
+    protected permissionService: PermissionService;
+    constructor(_log: LoggerService, _taskEventService: TaskEventService, _taskResourceService: TaskResourceService, _translate: TranslateService, _snackBar: SnackBarService, _taskState: TaskRequestStateService, _userComparator: UserComparatorService, _taskEvent: TaskEventService, _taskDataService: TaskDataService, _eventQueue: EventQueueService, _eventService: EventService, _changedFieldsService: ChangedFieldsService, _taskOperations: TaskOperations, _selectedCaseService: SelectedCaseService, _taskViewService: TaskViewService, _taskContentService: TaskContentService, permissionService: PermissionService);
+    /**
+     * Performs the 'cancel' operation on the task held by {@link TaskContentService}.
+     *
+     * Doesn't send any requests if the loading indicator is in it's active state.
+     * Otherwise sets the indicator to the active state and disables it once the request response is received.
+     *
+     * The argument can be used to chain operations together,
+     * or to execute code conditionally based on the success state of the cancel operation.
+     *
+     * If the task held within the {@link TaskContentService} changes before a response is received, the response will be ignored
+     * and the `afterAction` will not be executed.
+     * @param afterAction if cancel completes successfully `true` will be emitted into this Subject, otherwise `false` will be emitted
+     */
+    cancel(afterAction?: AfterAction): void;
+    /**
+     * Performs a `cancel` request on the task currently stored in the `taskContent` service
+     * @param afterAction the action that should be performed after the request is processed
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param forceReload whether a force reload of the task data should be performed after cancel.
+     * If set to `false` a regular reload is performed instead.
+     */
+    protected performCancelRequest(afterAction: AfterAction, nextEvent: AfterAction, forceReload: boolean): void;
+    /**
+     * Calls the endpoint and processes the possible responses.
+     * @param afterAction the action that should be performed after the request is processed
+     * @param canceledTaskId the id of the task that is being canceled
+     * @param nextEvent indicates to the event queue that the next event can be processed
+     * @param forceReload whether a force reload of the task data should be performed after cancel.
+     * If set to `false` a regular reload is performed instead.
+     */
+    protected cancelRequest(afterAction: AfterAction, canceledTaskId: string, nextEvent: AfterAction, forceReload: boolean): void;
+    /**
+     * complete all action streams and send notification with selected boolean
+     */
+    protected completeActions(afterAction: AfterAction, nextEvent: AfterAction, bool: boolean): void;
+    /**
+     * Publishes a cancel notification to the {@link TaskEventService}
+     * @param success whether the cancel operation was successful or not
+     */
+    protected sendNotification(success: boolean): void;
+}

package/lib/task/services/data-focus-policy.service.d.ts

@@ -0,0 +1,16 @@
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskHandlingService } from './task-handling-service';
+/**
+ * Handles the sequence of actions that are performed when a task si [opened]{@link TaskOperations#open}.
+ */
+export declare class DataFocusPolicyService extends TaskHandlingService {
+    constructor(_taskContentService: TaskContentService);
+    /**
+     * Performs the selection of some data fields if the policy is set to [Auto Required]{@link DataFocusPolicy#autoRequired}.
+     */
+    performDataFocusPolicy(): void;
+    /**
+     * Currently does nothing
+     */
+    private autoRequiredDataFocusPolicy;
+}