@valtimo/task 0.0.0-test

package/fesm2022/valtimo-task.mjs

@@ -0,0 +1,2675 @@
+import * as i6 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Injectable, EventEmitter, ViewContainerRef, Output, Input, ViewChild, Optional, Inject, ChangeDetectionStrategy, Component, signal, ViewEncapsulation, HostListener, NgModule } from '@angular/core';
+import { RecentlyViewed16, CalendarAdd16, Edit16, FolderDetailsReference16 } from '@carbon/icons';
+import * as i4$1 from '@ngx-translate/core';
+import { TranslateModule, TranslateLoader } from '@ngx-translate/core';
+import * as i9 from '@valtimo/components';
+import { ViewType, FormioOptionsImpl, FormIoModule, ConfirmationModalModule, TooltipModule, RemoveClassnamesDirective, runAfterCarbonModalClosed, CarbonListModule, PageHeaderModule, WidgetModule, SpinnerModule, CamundaFormModule, RenderInPageHeaderDirective, SearchFieldsModule, AssignmentComponent, ValtimoCdsModalDirective } from '@valtimo/components';
+import * as i1$1 from '@valtimo/shared';
+import { BaseApiService, TaskListTab, InterceptorSkip, FORM_VIEW_MODEL_TOKEN, ROLE_USER, HttpLoaderFactory } from '@valtimo/shared';
+import * as i7 from '@valtimo/process-link';
+import { FORM_CUSTOM_COMPONENT_TOKEN, ProcessLinkModule, formSizeToCarbonModalSizeMap } from '@valtimo/process-link';
+import * as i2$1 from 'carbon-components-angular';
+import { LoadingModule, NotificationModule, ButtonModule, IconModule, ModalModule, ToggletipModule, DatePickerModule, LayerModule, LinkModule, TabsModule, ContentSwitcherModule, DropdownModule, TooltipModule as TooltipModule$1 } from 'carbon-components-angular';
+import { BehaviorSubject, combineLatest, tap, filter, switchMap, of, map as map$1, catchError, Subscription, take as take$1, distinctUntilChanged, Subject, shareReplay, EMPTY } from 'rxjs';
+import * as i2 from '@valtimo/document';
+import * as i4 from 'ngx-logger';
+import * as i3 from '@valtimo/access-control';
+import * as i1$2 from '@angular/router';
+import { RouterModule } from '@angular/router';
+import * as i1 from '@angular/common/http';
+import { HttpParams, HttpHeaders, HttpClient } from '@angular/common/http';
+import { map, take, filter as filter$1, startWith, distinctUntilChanged as distinctUntilChanged$1, switchMap as switchMap$1, catchError as catchError$1 } from 'rxjs/operators';
+import { omit, isEqual } from 'lodash';
+import moment from 'moment';
+import * as i6$1 from '@valtimo/sse';
+import * as i11 from '@valtimo/teams';
+import * as i13 from '@ng-bootstrap/ng-bootstrap';
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+import { FormsModule } from '@angular/forms';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { AuthGuardService } from '@valtimo/security';
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var PERMISSION_ACTION;
+(function (PERMISSION_ACTION) {
+    PERMISSION_ACTION["assign"] = "assign";
+    PERMISSION_ACTION["view"] = "view";
+    PERMISSION_ACTION["modify"] = "modify";
+})(PERMISSION_ACTION || (PERMISSION_ACTION = {}));
+var TASK_DETAIL_PERMISSION_RESOURCE;
+(function (TASK_DETAIL_PERMISSION_RESOURCE) {
+    TASK_DETAIL_PERMISSION_RESOURCE["jsonSchemaDocument"] = "com.ritense.document.domain.impl.JsonSchemaDocument";
+    TASK_DETAIL_PERMISSION_RESOURCE["task"] = "com.ritense.valtimo.operaton.domain.OperatonTask";
+})(TASK_DETAIL_PERMISSION_RESOURCE || (TASK_DETAIL_PERMISSION_RESOURCE = {}));
+const CAN_ASSIGN_TASK_PERMISSION = {
+    action: PERMISSION_ACTION.assign,
+    resource: TASK_DETAIL_PERMISSION_RESOURCE.task,
+};
+const CAN_VIEW_TASK_PERMISSION = {
+    action: PERMISSION_ACTION.view,
+    resource: TASK_DETAIL_PERMISSION_RESOURCE.task,
+};
+const CAN_VIEW_CASE_PERMISSION = {
+    action: PERMISSION_ACTION.view,
+    resource: TASK_DETAIL_PERMISSION_RESOURCE.jsonSchemaDocument,
+};
+const CAN_MODIFY_TASK_PERMISSION = {
+    action: PERMISSION_ACTION.modify,
+    resource: TASK_DETAIL_PERMISSION_RESOURCE.task,
+};
+
+/*
+ * Copyright 2015-2026 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Enriches a task with assignee and due date from a process link result,
+ * only filling in fields that are missing on the task itself.
+ * Returns a new task object if any fields were enriched, or the original task if unchanged.
+ */
+function enrichTaskFromProcessLink(task, processLink) {
+    if (!processLink)
+        return task;
+    const needsAssignee = processLink.assignee && !task.assignee;
+    const needsDue = processLink.due && !task.due;
+    if (!needsAssignee && !needsDue)
+        return task;
+    return {
+        ...task,
+        ...(needsAssignee && { assignee: processLink.assignee }),
+        ...(needsDue && { due: processLink.due }),
+    };
+}
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskService extends BaseApiService {
+    constructor(httpClient, configService) {
+        super(httpClient, configService);
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    queryTasks(params) {
+        return this.httpClient.get(this.getApiUrl('/v1/task'), {
+            observe: 'response',
+            params,
+        });
+    }
+    queryTasksPage(params) {
+        return this.httpClient.get(this.getApiUrl('/v2/task'), {
+            params,
+        });
+    }
+    queryTasksPageV3(assigneeFilter = TaskListTab.ALL, pageParams, caseDefinitionKey, otherFilters) {
+        let httpParams = new HttpParams().set('page', pageParams.page).set('size', pageParams.size);
+        if (pageParams.sort) {
+            httpParams = httpParams.append('sort', pageParams.sort);
+        }
+        if (caseDefinitionKey && (otherFilters || []).length > 0) {
+            return this.searchTasks(httpParams, caseDefinitionKey, otherFilters, assigneeFilter);
+        }
+        httpParams = httpParams.append('filter', assigneeFilter.toUpperCase());
+        return this.httpClient.post(this.getApiUrl('/v3/task'), { ...(caseDefinitionKey && { caseDefinitionKey }) }, { params: httpParams });
+    }
+    searchTasks(params, caseDefinitionKey, otherFilters, assigneeFilter = TaskListTab.ALL) {
+        return this.httpClient.post(this.getApiUrl(`/v1/document-definition/${caseDefinitionKey}/task/search`), {
+            caseDefinitionKey,
+            assigneeFilter: assigneeFilter.toUpperCase(),
+            ...(otherFilters && { otherFilters }),
+        }, { params });
+    }
+    getTasks() {
+        return this.httpClient.get(this.getApiUrl('/v1/task?filter=all'));
+    }
+    getTask(id) {
+        return this.httpClient.get(this.getApiUrl(`/v1/task/${id}`));
+    }
+    getCandidateUsers(id) {
+        return this.httpClient.get(this.getApiUrl(`/v2/task/${id}/candidate-user`));
+    }
+    getCandidateTeams(id) {
+        return this.httpClient.get(this.getApiUrl(`/v1/task/${id}/candidate-team`), { params: { size: '1000' } });
+    }
+    assignTask(id, assigneeRequest) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/assign`), assigneeRequest);
+    }
+    unassignTask(id) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/unassign`), null);
+    }
+    completeTask(id, variables) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/complete`), {
+            variables,
+            filesToDelete: [],
+        });
+    }
+    getTaskProcessLink(taskId) {
+        return this.httpClient.get(this.getApiUrl(`/v2/process-link/task/${taskId}`), { headers: new HttpHeaders().set(InterceptorSkip, '404') });
+    }
+    getTaskListColumns(caseDefinitionKey) {
+        return this.httpClient.get(this.getApiUrl(`/v1/case/${caseDefinitionKey}/task-list-column`));
+    }
+    getConfigCustomTaskList() {
+        return this.configService.config.customTaskList;
+    }
+    getTaskListSearchFields(caseDefinitionKey) {
+        return this.httpClient.get(this.getApiUrl(`v1/search/field/TaskListSearchColumns/${caseDefinitionKey}`));
+    }
+    setTaskDueDate(taskId, setTaskDueDateRequest) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${taskId}/set-due-date`), setTaskDueDateRequest);
+    }
+    removeTaskDueDate(taskId) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${taskId}/set-due-date`), null);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskService, deps: [{ token: i1.HttpClient }, { token: i1$1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i1$1.ConfigService }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskListService {
+    constructor() {
+        this._ALL_CASES_ID = 'ALL_CASES';
+        this._caseDefinitionKey$ = new BehaviorSubject(null);
+        this._selectedTaskType$ = new BehaviorSubject(TaskListTab.MINE);
+        this._loadingStateForCaseDefinition$ = new BehaviorSubject(false);
+    }
+    get caseDefinitionKey$() {
+        return this._caseDefinitionKey$.asObservable();
+    }
+    get selectedTaskType$() {
+        return this._selectedTaskType$.asObservable();
+    }
+    get caseDefinitionKey() {
+        return this._caseDefinitionKey$.getValue();
+    }
+    get selectedTaskType() {
+        return this._selectedTaskType$.getValue();
+    }
+    get loadingStateForCaseDefinition$() {
+        return this._loadingStateForCaseDefinition$.asObservable();
+    }
+    get ALL_CASES_ID() {
+        return this._ALL_CASES_ID;
+    }
+    setSelectedTaskType(type) {
+        this._selectedTaskType$.next(type);
+    }
+    setCaseDefinitionKey(caseDefinitionKey) {
+        this._loadingStateForCaseDefinition$.next(true);
+        this._caseDefinitionKey$.next(caseDefinitionKey);
+    }
+    setLoadingStateForCaseDefinition(loading) {
+        this._loadingStateForCaseDefinition$.next(loading);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListService, decorators: [{
+            type: Injectable
+        }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskListSortService {
+    get sortStateForCurrentTaskType$() {
+        return this._sortStateForCurrentTaskType$;
+    }
+    get sortStringForCurrentTaskType$() {
+        return this.sortStateForCurrentTaskType$.pipe(map(sortState => (sortState ? this.getSortString(sortState) : null)));
+    }
+    get overrideSortState$() {
+        return this._overrideSortState$.asObservable();
+    }
+    get overrideSortStateString$() {
+        return this._overrideSortState$.pipe(map(state => (state ? this.getSortString(state) : null)));
+    }
+    get _defaultSortState() {
+        return this.taskService.getConfigCustomTaskList()?.defaultSortedColumn || null;
+    }
+    constructor(taskService, taskListService) {
+        this.taskService = taskService;
+        this.taskListService = taskListService;
+        this._overrideSortState$ = new BehaviorSubject(null);
+        this._sortState$ = new BehaviorSubject({
+            [TaskListTab.ALL]: this._defaultSortState,
+            [TaskListTab.MINE]: this._defaultSortState,
+            [TaskListTab.OPEN]: this._defaultSortState,
+            [TaskListTab.TEAM]: this._defaultSortState,
+        });
+        this._sortStateForCurrentTaskType$ = combineLatest([
+            this.taskListService.selectedTaskType$,
+            this._sortState$,
+        ]).pipe(map(([selectedTaskType, sortStates]) => sortStates[selectedTaskType]));
+    }
+    updateSortState(taskType, updatedSortState) {
+        this._sortState$.pipe(take(1)).subscribe(sortState => {
+            this._sortState$.next({
+                ...sortState,
+                [taskType]: { ...sortState[taskType], ...updatedSortState },
+            });
+        });
+    }
+    updateSortStates(updatedSortState) {
+        this._sortState$.pipe(take(1)).subscribe(sortStates => {
+            const sortStatesCopy = { ...sortStates };
+            Object.keys(sortStates).forEach(taskType => {
+                sortStatesCopy[taskType] = { ...sortStatesCopy[taskType], ...updatedSortState };
+            });
+            this._sortState$.next(sortStatesCopy);
+        });
+    }
+    clearSortStates() {
+        this._sortState$.pipe(take(1)).subscribe(sortStates => {
+            const sortStatesCopy = { ...sortStates };
+            Object.keys(sortStates).forEach(taskType => {
+                sortStatesCopy[taskType] = null;
+            });
+            this._sortState$.next(sortStatesCopy);
+        });
+    }
+    resetDefaultSortStates() {
+        this._sortState$.pipe(take(1)).subscribe(sortStates => {
+            const sortStatesCopy = { ...sortStates };
+            Object.keys(sortStates).forEach(taskType => {
+                sortStatesCopy[taskType] = this._defaultSortState;
+            });
+            this._sortState$.next(sortStatesCopy);
+        });
+    }
+    getSortStateFromSortString(sortString) {
+        const splitString = sortString && sortString.split(',');
+        if (splitString?.length > 1) {
+            return {
+                isSorting: true,
+                state: {
+                    name: splitString[0],
+                    direction: splitString[1],
+                },
+            };
+        }
+        return null;
+    }
+    setOverrideSortState(state) {
+        this._overrideSortState$.next(state);
+    }
+    resetOverrideSortState() {
+        this._overrideSortState$.next(null);
+    }
+    getSortString(sort) {
+        return `${sort.state.name},${sort.state.direction}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListSortService, deps: [{ token: TaskService }, { token: TaskListService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListSortService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListSortService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: TaskService }, { type: TaskListService }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskListColumnService {
+    get hasCustomConfigTaskList() {
+        return !!this.taskService.getConfigCustomTaskList();
+    }
+    get fields$() {
+        return this._fields$.asObservable();
+    }
+    get taskListColumnsForCase$() {
+        return this.taskListService.caseDefinitionKey$.pipe(tap(caseDefinitionName => {
+            if (caseDefinitionName === this.taskListService.ALL_CASES_ID) {
+                this.resetTaskListFields();
+            }
+        }), filter(caseDefinitionName => !!caseDefinitionName && caseDefinitionName !== this.taskListService.ALL_CASES_ID), switchMap(caseDefinitionName => this.taskService.getTaskListColumns(caseDefinitionName)), tap(taskListColumns => {
+            if (taskListColumns.length === 0) {
+                this.taskListSortService.updateSortStates({
+                    isSorting: true,
+                    state: {
+                        name: this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS[0].key,
+                        direction: 'DESC',
+                    },
+                });
+                this._fields$.next(this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS);
+            }
+            else {
+                this._fields$.next(this.mapTaskListColumnToColumnConfig(taskListColumns));
+            }
+        }), tap(() => this.taskListService.setLoadingStateForCaseDefinition(false)));
+    }
+    constructor(taskService, taskListService, taskListSortService) {
+        this.taskService = taskService;
+        this.taskListService = taskListService;
+        this.taskListSortService = taskListSortService;
+        this._DEFAULT_TASK_LIST_FIELDS = [
+            {
+                key: 'created',
+                label: `task-list.fieldLabels.created`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'name',
+                label: `task-list.fieldLabels.name`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'valtimoAssignee.fullName',
+                label: `task-list.fieldLabels.valtimoAssignee.fullName`,
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'due',
+                label: `task-list.fieldLabels.due`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'context',
+                label: `task-list.fieldLabels.context`,
+                viewType: ViewType.TEXT,
+            },
+        ];
+        this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS = [
+            {
+                key: 'createTime',
+                label: `task-list.fieldLabels.created`,
+                viewType: ViewType.DATE,
+                sortable: true,
+                format: 'DD MMM YYYY HH:mm',
+            },
+            {
+                key: 'name',
+                label: `task-list.fieldLabels.name`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'assignee',
+                label: `task-list.fieldLabels.valtimoAssignee.fullName`,
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'dueDate',
+                label: `task-list.fieldLabels.due`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+        ];
+        this._fields$ = new BehaviorSubject(this._DEFAULT_TASK_LIST_FIELDS);
+    }
+    resetTaskListFields() {
+        if (this.hasCustomConfigTaskList) {
+            this.setFieldsToCustomTaskListFields();
+        }
+        else {
+            this.setFieldsToDefaultTaskListFields();
+        }
+        this.taskListSortService.resetDefaultSortStates();
+        this.taskListService.setLoadingStateForCaseDefinition(false);
+    }
+    setFieldsToCustomTaskListFields() {
+        const customTaskListFields = this.taskService.getConfigCustomTaskList().fields;
+        if (customTaskListFields) {
+            this._fields$.next(customTaskListFields.map((column, index) => ({
+                key: column.propertyName,
+                label: `task-list.fieldLabels.${column.translationKey}`,
+                sortable: column.sortable,
+                ...(column.viewType && { viewType: column.viewType }),
+                ...(column.enum && { enum: column.enum }),
+            })));
+        }
+    }
+    setFieldsToDefaultTaskListFields() {
+        this._fields$.next(this._DEFAULT_TASK_LIST_FIELDS);
+    }
+    mapTaskListColumnToColumnConfig(taskListColumns) {
+        const hasDefaultSort = !!taskListColumns.find(column => column.defaultSort);
+        const firstSortableColumn = taskListColumns.find(column => column.sortable);
+        if (!hasDefaultSort && firstSortableColumn) {
+            this.taskListSortService.updateSortStates({
+                isSorting: true,
+                state: {
+                    name: firstSortableColumn.key,
+                    direction: 'DESC',
+                },
+            });
+        }
+        if (!hasDefaultSort && !firstSortableColumn) {
+            this.taskListSortService.clearSortStates();
+        }
+        return taskListColumns.map(column => {
+            if (column.defaultSort) {
+                this.taskListSortService.updateSortStates({
+                    isSorting: true,
+                    state: {
+                        name: column.key,
+                        direction: column.defaultSort,
+                    },
+                });
+            }
+            return {
+                viewType: this.getViewType(column.displayType.type),
+                key: column.key,
+                label: column.title || column.key,
+                sortable: column.sortable,
+                ...(column?.displayType?.displayTypeParameters?.enum && {
+                    enum: column?.displayType?.displayTypeParameters?.enum,
+                }),
+                ...(column?.displayType?.displayTypeParameters?.dateFormat && {
+                    format: column?.displayType?.displayTypeParameters?.dateFormat,
+                }),
+            };
+        });
+    }
+    getViewType(taskListColumnColumnDisplayType) {
+        switch (taskListColumnColumnDisplayType) {
+            case 'arrayCount':
+                return 'relatedFiles';
+            case 'underscoresToSpaces':
+                return 'stringReplaceUnderscore';
+            default:
+                return taskListColumnColumnDisplayType;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListColumnService, deps: [{ token: TaskService }, { token: TaskListService }, { token: TaskListSortService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListColumnService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListColumnService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: TaskService }, { type: TaskListService }, { type: TaskListSortService }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskListPaginationService {
+    get paginationForCurrentTaskType$() {
+        return this._paginationForCurrentTaskType$;
+    }
+    get paginationForCurrentTaskTypeForList$() {
+        return this._paginationForCurrentTaskType$.pipe(map(pagination => ({ ...pagination, page: pagination?.page + 1 || 1 })));
+    }
+    constructor(taskListService) {
+        this.taskListService = taskListService;
+        this._pagination$ = new BehaviorSubject({
+            [TaskListTab.ALL]: this.getDefaultPagination(),
+            [TaskListTab.MINE]: this.getDefaultPagination(),
+            [TaskListTab.OPEN]: this.getDefaultPagination(),
+            [TaskListTab.TEAM]: this.getDefaultPagination(),
+        });
+        this._paginationForCurrentTaskType$ = combineLatest([
+            this.taskListService.selectedTaskType$,
+            this._pagination$,
+        ]).pipe(map(([selectedTaskType, pagination]) => pagination[selectedTaskType]));
+    }
+    updateTaskPagination(taskType, updatedPagination) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            const currentPagination = pagination[taskType];
+            this._pagination$.next({
+                ...pagination,
+                [taskType]: { ...currentPagination, ...updatedPagination },
+            });
+        });
+    }
+    getLastAvailablePage(page, size, collectionSize) {
+        if (this.isNumber(page) && this.isNumber(size) && this.isNumber(collectionSize) && page !== 0) {
+            const amountOfPages = Math.ceil(collectionSize / size);
+            if (page + 1 > amountOfPages) {
+                return amountOfPages - 1;
+            }
+        }
+        return page;
+    }
+    isNumber(value) {
+        return typeof value === 'number';
+    }
+    getDefaultPagination() {
+        return {
+            page: 0,
+            size: 10,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListPaginationService, deps: [{ token: TaskListService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListPaginationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListPaginationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: TaskListService }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskListSearchService {
+    get loadingSearchFields$() {
+        return this._loadingSearchFields$.asObservable();
+    }
+    get otherFilters$() {
+        return this._otherFilters$.asObservable();
+    }
+    constructor(configService, taskListService, taskService) {
+        this.configService = configService;
+        this.taskListService = taskListService;
+        this.taskService = taskService;
+        this._loadingSearchFields$ = new BehaviorSubject(true);
+        this._otherFilters$ = new BehaviorSubject([]);
+        this.searchFields$ = this.taskListService.caseDefinitionKey$.pipe(tap(() => this._loadingSearchFields$.next(true)), switchMap(caseDefinitionName => caseDefinitionName
+            ? this.taskService.getTaskListSearchFields(caseDefinitionName)
+            : of([])), map$1(searchFields => searchFields.map(searchField => {
+            const fieldTypeLowerCase = searchField.fieldType?.toLowerCase();
+            return {
+                ...searchField,
+                dataType: searchField.dataType?.toLowerCase(),
+                fieldType: fieldTypeLowerCase === 'text_contains' ? 'single' : fieldTypeLowerCase,
+                matchType: searchField?.matchType?.toLowerCase(),
+            };
+        })), tap(() => this._loadingSearchFields$.next(false)));
+    }
+    setSearchFieldValues(searchFieldValues) {
+        this._otherFilters$.next(this.mapSearchValuesToFilters(searchFieldValues));
+    }
+    setOtherFilters(otherFilters) {
+        this._otherFilters$.next(otherFilters);
+    }
+    resetOtherFilters() {
+        this._otherFilters$.next([]);
+    }
+    mapOtherFilterToSearchValues(otherFilters) {
+        return otherFilters.reduce((acc, curr) => {
+            const filter = curr;
+            if (filter.rangeFrom) {
+                return {
+                    ...acc,
+                    [filter.key]: {
+                        start: filter.rangeFrom,
+                        end: filter.rangeTo,
+                    },
+                };
+            }
+            else if (filter.multiValue) {
+                return { ...acc, [filter.key]: filter.values };
+            }
+            else if (Array.isArray(filter.values) && filter.values.length > 0 && !filter.multiValue) {
+                return { ...acc, [filter.key]: filter.values[0] };
+            }
+            return acc;
+        }, {});
+    }
+    mapSearchValuesToFilters(values) {
+        const filters = [];
+        Object.keys(values).forEach(valueKey => {
+            const searchValue = values[valueKey];
+            if (searchValue.start) {
+                filters.push({ key: valueKey, rangeFrom: searchValue.start, rangeTo: searchValue.end });
+            }
+            else if (Array.isArray(searchValue)) {
+                filters.push({ key: valueKey, values: searchValue, multiValue: true });
+            }
+            else {
+                filters.push({ key: valueKey, values: [searchValue], multiValue: false });
+            }
+        });
+        return filters;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListSearchService, deps: [{ token: i1$1.ConfigService }, { token: TaskListService }, { token: TaskService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListSearchService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListSearchService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.ConfigService }, { type: TaskListService }, { type: TaskService }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskListQueryParamService {
+    setTaskListParams(params) {
+        const queryParams = omit(params, 'reload');
+        const encodedQueryParams = Object.keys(queryParams).reduce((acc, curr) => ({ ...acc, [curr]: this.objectToBase64(queryParams[curr]) }), {});
+        this.router.navigate([this.getUrlWithoutParams()], { queryParams: encodedQueryParams });
+    }
+    constructor(router, route) {
+        this.router = router;
+        this.route = route;
+    }
+    getTaskListQueryParams() {
+        const queryParams = this.route.snapshot.queryParams;
+        const decodedParams = Object.keys(queryParams).reduce((acc, curr) => ({ ...acc, [curr]: this.parseBase64(queryParams[curr]) }), {});
+        return decodedParams;
+    }
+    getUrlWithoutParams() {
+        const urlTree = this.router.parseUrl(this.router.url);
+        urlTree.queryParams = {};
+        urlTree.fragment = null;
+        return urlTree.toString();
+    }
+    objectToBase64(jsObject) {
+        return btoa(JSON.stringify(jsObject));
+    }
+    parseBase64(base64string) {
+        return JSON.parse(atob(base64string));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListQueryParamService, deps: [{ token: i1$2.Router }, { token: i1$2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListQueryParamService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListQueryParamService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$2.Router }, { type: i1$2.ActivatedRoute }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskIntermediateSaveService extends BaseApiService {
+    get submission$() {
+        return this._submission$.pipe(filter((value) => !!value));
+    }
+    get formIoFormData$() {
+        return this._formIoFormData$.pipe(filter((value) => !!value));
+    }
+    constructor(httpClient, configService) {
+        super(httpClient, configService);
+        this.httpClient = httpClient;
+        this.configService = configService;
+        this._submission$ = new BehaviorSubject({});
+        this._formIoFormData$ = new BehaviorSubject({});
+    }
+    getIntermediateSubmission(taskInstanceId) {
+        return this.httpClient
+            .get(this.getApiUrl('/v1/form/intermediate/submission'), {
+            params: {
+                taskInstanceId,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '404'),
+        })
+            .pipe(catchError(() => of(null)));
+    }
+    storeIntermediateSubmission(request) {
+        return this.httpClient.post(this.getApiUrl('/v1/form/intermediate/submission'), request, {
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    clearIntermediateSubmission(taskInstanceId) {
+        return this.httpClient.delete(this.getApiUrl('/v1/form/intermediate/submission'), {
+            params: {
+                taskInstanceId,
+            },
+        });
+    }
+    setSubmission(value) {
+        this._submission$.next(value);
+    }
+    setFormIoFormData(value) {
+        this._formIoFormData$.next(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskIntermediateSaveService, deps: [{ token: i1.HttpClient }, { token: i1$1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskIntermediateSaveService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskIntermediateSaveService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i1$1.ConfigService }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskDetailContentComponent {
+    set task(value) {
+        if (!value)
+            return;
+        if (this.taskInstanceId$.getValue() === value.id) {
+            this.task$.next(value);
+            return;
+        }
+        this.loadTaskDetails(value);
+    }
+    set taskAndProcessLink(value) {
+        if (!value)
+            return;
+        const task = enrichTaskFromProcessLink(value.task, value.processLinkActivityResult);
+        this.loadTaskDetails(task, value.processLinkActivityResult);
+    }
+    set modalClosed(closed) {
+        // save form flow data on modal closed
+        if (this.formFlow)
+            this.formFlow.saveData();
+        this.taskInstanceId$.next(null);
+        if (closed) {
+            this.closeModalEvent.emit();
+        }
+    }
+    get viewInitialized$() {
+        return this._viewInitialized$.pipe(filter(initialized => initialized));
+    }
+    constructor(configService, documentService, globalNotificationService, iconService, logger, modalService, permissionService, processLinkService, router, stateService, taskIntermediateSaveService, taskService, translateService, formViewModel, formCustomComponentConfig, urlResolverService) {
+        this.configService = configService;
+        this.documentService = documentService;
+        this.globalNotificationService = globalNotificationService;
+        this.iconService = iconService;
+        this.logger = logger;
+        this.modalService = modalService;
+        this.permissionService = permissionService;
+        this.processLinkService = processLinkService;
+        this.router = router;
+        this.stateService = stateService;
+        this.taskIntermediateSaveService = taskIntermediateSaveService;
+        this.taskService = taskService;
+        this.translateService = translateService;
+        this.formViewModel = formViewModel;
+        this.formCustomComponentConfig = formCustomComponentConfig;
+        this.urlResolverService = urlResolverService;
+        this.closeModalEvent = new EventEmitter();
+        this.formSubmit = new EventEmitter();
+        this.activeChange = new EventEmitter();
+        this.taskUpdated = new EventEmitter();
+        this.canAssignUserToTask$ = new BehaviorSubject(false);
+        this.errorMessage$ = new BehaviorSubject(null);
+        this.formDefinition$ = new BehaviorSubject(null);
+        this.formDefinitionId$ = new BehaviorSubject(null);
+        this.formFlowInstanceId$ = new BehaviorSubject(null);
+        this.formioOptions$ = new BehaviorSubject(null);
+        this.formIoFormData$ = new BehaviorSubject(null);
+        this.formName$ = new BehaviorSubject(null);
+        this.loading$ = new BehaviorSubject(true);
+        this.submission$ = new BehaviorSubject(null);
+        this.task$ = new BehaviorSubject(null);
+        this.taskInstanceId$ = new BehaviorSubject(null);
+        this.intermediateSaveEnabled = false;
+        this._taskProcessLinkType$ = new BehaviorSubject(null);
+        this.processLinkIsForm$ = this._taskProcessLinkType$.pipe(map$1((type) => type === 'form'));
+        this.processLinkIsFormViewModel$ = this._taskProcessLinkType$.pipe(map$1((type) => type === 'form-view-model'));
+        this.processLinkIsFormFlow$ = this._taskProcessLinkType$.pipe(map$1((type) => type === 'form-flow'));
+        this.processLinkIsUiComponent$ = this._taskProcessLinkType$.pipe(map$1((type) => type === 'ui-component'));
+        this.noFormNotification$ = combineLatest([
+            this.loading$,
+            this.formDefinition$,
+            this.formFlowInstanceId$,
+            this.errorMessage$,
+            this.processLinkIsUiComponent$,
+            this.processLinkIsFormViewModel$,
+        ]).pipe(map$1(([loading, formDefinition, formFlowInstanceId, errorMessage, isUiComponent, isFormViewModel,]) => {
+            if (!loading &&
+                !formDefinition &&
+                !formFlowInstanceId &&
+                !errorMessage &&
+                !isUiComponent &&
+                !isFormViewModel) {
+                return {
+                    type: 'warning',
+                    title: this.translateService.instant('interface.warning'),
+                    message: this.translateService.instant('formManagement.noFormDefinitionFoundUser'),
+                    showClose: false,
+                    lowContrast: true,
+                };
+            }
+            return null;
+        }));
+        this._processLinkId$ = new BehaviorSubject(null);
+        this._subscriptions = new Subscription();
+        this._formCustomComponentConfig$ = new BehaviorSubject({});
+        this._viewInitialized$ = new BehaviorSubject(false);
+        this.intermediateSaveEnabled = !!this.configService.featureToggles?.enableIntermediateSave;
+        this.iconService.registerAll([RecentlyViewed16]);
+        const options = new FormioOptionsImpl();
+        options.disableAlerts = true;
+        this.formioOptions$.next(options);
+        this._formCustomComponentConfig$.next(formCustomComponentConfig);
+    }
+    ngOnInit() {
+        this.openPermissionSubscription();
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+        this.submission$.next(null);
+        this._viewInitialized$.next(false);
+    }
+    ngAfterViewInit() {
+        this._viewInitialized$.next(true);
+    }
+    onSubmit(submission) {
+        if (submission.data) {
+            this.taskIntermediateSaveService.setFormIoFormData(submission.data);
+            this.formIoFormData$.next(submission.data);
+        }
+        combineLatest([this._processLinkId$, this._taskProcessLinkType$, this.task$])
+            .pipe(take$1(1))
+            .subscribe(([processLinkId, taskProcessLinkType, task]) => {
+            if (taskProcessLinkType === 'form') {
+                if (processLinkId) {
+                    this.processLinkService
+                        .submitForm(processLinkId, submission.data, task?.businessKey, task?.id)
+                        .subscribe({
+                        next: (_) => {
+                            this.completeTask(task);
+                        },
+                        error: errors => {
+                            this.form.showErrors(errors);
+                        },
+                    });
+                }
+            }
+            else if (taskProcessLinkType === 'form-view-model') {
+                this.completeTask(task);
+            }
+        });
+    }
+    completeTask(task) {
+        if (!task)
+            return;
+        this.globalNotificationService.showToast({
+            title: `${task.name} ${this.translateService.instant('taskDetail.taskCompleted')}`,
+            type: 'success',
+        });
+        this.task$.next(null);
+        this.formSubmit.emit();
+        this.closeModalEvent.emit();
+        this.activeChange.emit(false);
+        if (this.formFlow)
+            this.formFlow.saveData();
+    }
+    onChange(event) {
+        if (event.data) {
+            this.taskIntermediateSaveService.setFormIoFormData(event.data);
+            this.formIoFormData$.next(event.data);
+            this.activeChange.emit(true);
+        }
+    }
+    onFormFlowChangeEvent() {
+        this.activeChange.emit(true);
+    }
+    loadTaskDetails(task, processLink) {
+        this.resetTaskProcessLinkType();
+        this.resetFormDefinition();
+        this.taskInstanceId$.next(task.id);
+        if (!processLink) {
+            this.getTaskProcessLink(task.id);
+        }
+        else {
+            this.setTaskProcessLink(processLink);
+        }
+        this.setDocumentDefinitionNameInService(task);
+        const documentId = task.businessKey;
+        this.stateService.setDocumentId(documentId);
+        this.task$.next(task);
+        this.stateService.setProcessInstanceId(task.processInstanceId);
+    }
+    getCurrentProgress(formViewModelComponentRef) {
+        this.taskInstanceId$
+            .pipe(filter(value => !!value), take$1(1), switchMap((taskInstanceId) => this.taskIntermediateSaveService.getIntermediateSubmission(taskInstanceId ?? '')))
+            .subscribe({
+            next: (intermediateSubmission) => {
+                this.taskIntermediateSaveService.setSubmission({
+                    data: intermediateSubmission?.submission || {},
+                });
+                if (formViewModelComponentRef) {
+                    formViewModelComponentRef.instance.submission = {
+                        data: intermediateSubmission.submission,
+                    };
+                }
+            },
+        });
+    }
+    getTaskProcessLink(taskId) {
+        this.taskService.getTaskProcessLink(taskId).subscribe({
+            next: res => {
+                this.updateTaskFromProcessLink(res);
+                this.setTaskProcessLink(res);
+            },
+            error: _ => {
+                this.loading$.next(false);
+            },
+        });
+    }
+    updateTaskFromProcessLink(processLinkResult) {
+        const currentTask = this.task$.getValue();
+        if (!currentTask)
+            return;
+        const enrichedTask = enrichTaskFromProcessLink(currentTask, processLinkResult);
+        if (enrichedTask !== currentTask) {
+            this.task$.next(enrichedTask);
+            this.taskUpdated.emit(enrichedTask);
+        }
+    }
+    setTaskProcessLink(processLinkResult) {
+        if (processLinkResult !== null) {
+            switch (processLinkResult?.type) {
+                case 'form':
+                    this._taskProcessLinkType$.next('form');
+                    this._processLinkId$.next(processLinkResult.processLinkId);
+                    // initializeFormWithSubmission will set loading to false after form is ready
+                    this.initializeFormWithSubmission(processLinkResult.properties.prefilledForm);
+                    break;
+                case 'form-flow':
+                    this._taskProcessLinkType$.next('form-flow');
+                    this.formFlowInstanceId$.next(processLinkResult.properties.formFlowInstanceId ?? '');
+                    this.loading$.next(false);
+                    break;
+                case 'form-view-model':
+                    this._taskProcessLinkType$.next('form-view-model');
+                    this._processLinkId$.next(processLinkResult.processLinkId);
+                    this.formDefinition$.next(processLinkResult.properties.formDefinition);
+                    this.formName$.next(processLinkResult.properties.formName ?? '');
+                    this.setFormViewModelComponent();
+                    this.loading$.next(false);
+                    break;
+                case 'url':
+                    this._taskProcessLinkType$.next('url');
+                    this._processLinkId$.next(processLinkResult.processLinkId);
+                    combineLatest([this.processLinkService.getVariables(), this.task$])
+                        .pipe(take$1(1))
+                        .subscribe(([variables, task]) => {
+                        let url = this.urlResolverService.resolveUrlVariables(processLinkResult.properties.url, variables.variables);
+                        window.open(url, '_blank').focus();
+                        this.processLinkService
+                            .submitURLProcessLink(processLinkResult.processLinkId, task.businessKey, task.id)
+                            .subscribe(() => {
+                            this.completeTask(task);
+                        });
+                    });
+                    this.loading$.next(false);
+                    break;
+                case 'ui-component':
+                    this._taskProcessLinkType$.next('ui-component');
+                    this._processLinkId$.next(processLinkResult.processLinkId);
+                    this.formDefinition$.next(null);
+                    this.formName$.next('');
+                    this.setFormCustomComponent(processLinkResult.properties.componentKey);
+                    this.loading$.next(false);
+                    break;
+            }
+        }
+    }
+    openPermissionSubscription() {
+        this._subscriptions.add(this.task$.subscribe(task => {
+            if (task) {
+                this.logger.debug('Checking if user allowed to assign a user to Task with id:', task.id);
+                this.permissionService
+                    .requestPermission(CAN_ASSIGN_TASK_PERMISSION, {
+                    resource: TASK_DETAIL_PERMISSION_RESOURCE.task,
+                    identifier: task.id,
+                })
+                    .subscribe((allowed) => {
+                    this.canAssignUserToTask$.next(allowed);
+                });
+            }
+            else {
+                this.logger.debug('Reset is user allowed to assign a user to Task as task is null');
+                this.canAssignUserToTask$.next(false);
+            }
+        }));
+    }
+    setFormDefinition(formDefinition) {
+        this._taskProcessLinkType$.next('form');
+        this.formDefinition$.next(formDefinition);
+    }
+    initializeFormWithSubmission(formDefinition) {
+        if (this.intermediateSaveEnabled) {
+            // Wait for intermediate submission before rendering the form
+            this.taskInstanceId$
+                .pipe(filter(value => !!value), take$1(1), switchMap((taskInstanceId) => this.taskIntermediateSaveService.getIntermediateSubmission(taskInstanceId ?? '')))
+                .subscribe({
+                next: (intermediateSubmission) => {
+                    // Set submission first, then form definition, then mark as loaded
+                    this.submission$.next({
+                        data: intermediateSubmission?.submission || {},
+                    });
+                    this.setFormDefinition(formDefinition);
+                    this.loading$.next(false);
+                },
+                error: () => {
+                    // If fetching fails, still render form with empty submission
+                    this.submission$.next({ data: {} });
+                    this.setFormDefinition(formDefinition);
+                    this.loading$.next(false);
+                },
+            });
+        }
+        else {
+            // No intermediate save, render form immediately with empty submission
+            this.submission$.next({ data: {} });
+            this.setFormDefinition(formDefinition);
+            this.loading$.next(false);
+        }
+    }
+    setFormViewModelComponent() {
+        combineLatest([this._viewInitialized$, this.processLinkIsFormViewModel$]).subscribe(([viewInitialized, isFvm]) => {
+            if (viewInitialized && isFvm) {
+                this.formViewModelDynamicContainer.clear();
+                if (!this.formViewModel) {
+                    return;
+                }
+                const formViewModelComponent = this.formViewModelDynamicContainer.createComponent(this.formViewModel.component);
+                formViewModelComponent.instance.form = this.formDefinition$.getValue();
+                formViewModelComponent.instance.formName = this.formName$.getValue();
+                formViewModelComponent.instance.taskInstanceId = this.taskInstanceId$.getValue();
+                formViewModelComponent.instance.isStartForm = false;
+                formViewModelComponent.instance.formSubmit
+                    .pipe(switchMap(() => this.task$), take$1(1))
+                    .subscribe((task) => {
+                    this.completeTask(task);
+                });
+                if (this.intermediateSaveEnabled) {
+                    this._subscriptions.add(formViewModelComponent.instance.submission$.subscribe(submission => {
+                        this.taskIntermediateSaveService.setSubmission(submission);
+                    }));
+                    this._subscriptions.add(this.submission$.pipe(distinctUntilChanged()).subscribe((submission) => {
+                        if (submission?.data && Object.keys(submission.data).length === 0) {
+                            formViewModelComponent.instance.submission = { data: {} };
+                        }
+                    }));
+                    this.getCurrentProgress(formViewModelComponent);
+                }
+                this._subscriptions.add(this.closeModalEvent.subscribe(() => {
+                    formViewModelComponent.destroy();
+                }));
+            }
+        });
+    }
+    setFormCustomComponent(formCustomComponentKey) {
+        combineLatest([this._viewInitialized$, this.processLinkIsUiComponent$]).subscribe(([viewInitialized, isUiComponent]) => {
+            if (viewInitialized && isUiComponent) {
+                this.formCustomComponentDynamicContainer.clear();
+                if (!this.formCustomComponentConfig) {
+                    return;
+                }
+                let renderedComponent;
+                this._subscriptions.add(this._formCustomComponentConfig$.subscribe((formCustomComponentConfig) => {
+                    const customComponent = formCustomComponentConfig[formCustomComponentKey];
+                    renderedComponent = this.formCustomComponentDynamicContainer.createComponent(customComponent);
+                    renderedComponent.instance.taskInstanceId = this.taskInstanceId$.value;
+                    renderedComponent.instance.submittedEvent.subscribe(() => {
+                        this.closeModalEvent.emit();
+                    });
+                }));
+                this._subscriptions.add(this.closeModalEvent.subscribe(() => {
+                    renderedComponent.destroy();
+                }));
+            }
+        });
+    }
+    resetFormDefinition() {
+        this.formDefinition$.next(null);
+        this.submission$.next(null);
+        this.loading$.next(true);
+    }
+    resetTaskProcessLinkType() {
+        this._taskProcessLinkType$.next(null);
+        this._processLinkId$.next(null);
+    }
+    setDocumentDefinitionNameInService(task) {
+        this.documentService
+            .getProcessDefinitionCaseDefinitionFromProcessInstanceId(task.processInstanceId)
+            .subscribe(ProcessDefinitionCaseDefinition => {
+            const caseDefinitionKey = ProcessDefinitionCaseDefinition.id.caseDefinitionId.key;
+            this.modalService.setCaseDefinitionKey(caseDefinitionKey);
+            this.stateService.setCaseDefinitionKey(caseDefinitionKey);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskDetailContentComponent, deps: [{ token: i1$1.ConfigService }, { token: i2.DocumentService }, { token: i1$1.GlobalNotificationService }, { token: i2$1.IconService }, { token: i4.NGXLogger }, { token: i9.ValtimoModalService }, { token: i3.PermissionService }, { token: i7.ProcessLinkService }, { token: i1$2.Router }, { token: i9.FormIoStateService }, { token: TaskIntermediateSaveService }, { token: TaskService }, { token: i4$1.TranslateService }, { token: FORM_VIEW_MODEL_TOKEN, optional: true }, { token: FORM_CUSTOM_COMPONENT_TOKEN, optional: true }, { token: i7.UrlResolverService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.20", type: TaskDetailContentComponent, isStandalone: true, selector: "valtimo-task-detail-content", inputs: { task: "task", taskAndProcessLink: "taskAndProcessLink", modalClosed: "modalClosed" }, outputs: { closeModalEvent: "closeModalEvent", formSubmit: "formSubmit", activeChange: "activeChange", taskUpdated: "taskUpdated" }, viewQueries: [{ propertyName: "form", first: true, predicate: ["form"], descendants: true }, { propertyName: "formViewModelDynamicContainer", first: true, predicate: ["formViewModelComponent"], descendants: true, read: ViewContainerRef }, { propertyName: "formFlow", first: true, predicate: ["formFlow"], descendants: true }, { propertyName: "formCustomComponentDynamicContainer", first: true, predicate: ["formCustomComponent"], descendants: true, read: ViewContainerRef }], ngImport: i0, template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<ng-container\n  *ngIf=\"{\n    loading: loading$ | async,\n    task: task$ | async,\n    taskId: taskInstanceId$ | async,\n    formDefinition: formDefinition$ | async,\n    formDefinitionId: formDefinitionId$ | async,\n    formName: formName$ | async,\n    formIoFormData: formIoFormData$ | async,\n    submission: submission$ | async,\n    processLinkIsForm: processLinkIsForm$ | async,\n    processLinkIsFormViewModel: processLinkIsFormViewModel$ | async,\n    processLinkIsUiComponent: processLinkIsUiComponent$ | async,\n    formioOptions: formioOptions$ | async,\n    processLinkIsFormFlow: processLinkIsFormFlow$ | async,\n    formFlowInstanceId: formFlowInstanceId$ | async,\n    errorMessage: errorMessage$ | async,\n    canAssignUserToTask: canAssignUserToTask$ | async,\n    noFormNotification: noFormNotification$ | async,\n  } as obs\"\n>\n  @if (obs.loading) {\n    <div style=\"width: 100%; display: flex; justify-content: center; padding: 1rem\">\n      <cds-loading size=\"sm\"></cds-loading>\n    </div>\n  } @else {\n    <valtimo-form-io\n      #form\n      *ngIf=\"\n        obs.formDefinition &&\n        obs.submission &&\n        obs.processLinkIsForm &&\n        !obs.processLinkIsUiComponent &&\n        !obs.processLinkIsFormViewModel\n      \"\n      [form]=\"obs.formDefinition\"\n      [submission]=\"obs.submission\"\n      (submit)=\"onSubmit($event)\"\n      (change)=\"onChange($event)\"\n      [options]=\"obs.formioOptions\"\n    ></valtimo-form-io>\n\n    <valtimo-form-flow\n      #formFlow\n      *ngIf=\"obs.processLinkIsFormFlow\"\n      [formIoFormData]=\"formIoFormData$\"\n      [formFlowInstanceId]=\"obs.formFlowInstanceId\"\n      (formFlowComplete)=\"completeTask(obs.task)\"\n      (formFlowChange)=\"onFormFlowChangeEvent()\"\n    ></valtimo-form-flow>\n\n    @if (obs.noFormNotification) {\n      <cds-inline-notification [notificationObj]=\"obs.noFormNotification\"></cds-inline-notification>\n    }\n\n    @if (obs.errorMessage) {\n      <cds-inline-notification\n        [notificationObj]=\"{\n          type: 'error',\n          title: ('interface.error' | translate),\n          message: obs.errorMessage,\n          showClose: false,\n          lowContrast: true\n        }\"\n      ></cds-inline-notification>\n    }\n  }\n\n  <div class=\"m-2\">\n    <ng-template #formViewModelComponent></ng-template>\n    <ng-template #formCustomComponent></ng-template>\n  </div>\n</ng-container>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }, { kind: "ngmodule", type: FormIoModule }, { kind: "component", type: i9.FormioComponent, selector: "valtimo-form-io", inputs: ["options", "submission", "form", "readOnly", "formRefresh$"], outputs: ["submit", "change", "event"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i4$1.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: ProcessLinkModule }, { kind: "component", type: i7.FormFlowComponent, selector: "valtimo-form-flow", inputs: ["formIoFormData", "formFlowInstanceId"], outputs: ["formFlowComplete", "formFlowChange"] }, { kind: "ngmodule", type: LoadingModule }, { kind: "component", type: i2$1.Loading, selector: "cds-loading, ibm-loading", inputs: ["title", "isActive", "size", "overlay"] }, { kind: "ngmodule", type: NotificationModule }, { kind: "component", type: i2$1.Notification, selector: "cds-notification, cds-inline-notification, ibm-notification, ibm-inline-notification", inputs: ["notificationObj"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskDetailContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-task-detail-content', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                        CommonModule,
+                        FormIoModule,
+                        TranslateModule,
+                        ProcessLinkModule,
+                        LoadingModule,
+                        NotificationModule,
+                    ], template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<ng-container\n  *ngIf=\"{\n    loading: loading$ | async,\n    task: task$ | async,\n    taskId: taskInstanceId$ | async,\n    formDefinition: formDefinition$ | async,\n    formDefinitionId: formDefinitionId$ | async,\n    formName: formName$ | async,\n    formIoFormData: formIoFormData$ | async,\n    submission: submission$ | async,\n    processLinkIsForm: processLinkIsForm$ | async,\n    processLinkIsFormViewModel: processLinkIsFormViewModel$ | async,\n    processLinkIsUiComponent: processLinkIsUiComponent$ | async,\n    formioOptions: formioOptions$ | async,\n    processLinkIsFormFlow: processLinkIsFormFlow$ | async,\n    formFlowInstanceId: formFlowInstanceId$ | async,\n    errorMessage: errorMessage$ | async,\n    canAssignUserToTask: canAssignUserToTask$ | async,\n    noFormNotification: noFormNotification$ | async,\n  } as obs\"\n>\n  @if (obs.loading) {\n    <div style=\"width: 100%; display: flex; justify-content: center; padding: 1rem\">\n      <cds-loading size=\"sm\"></cds-loading>\n    </div>\n  } @else {\n    <valtimo-form-io\n      #form\n      *ngIf=\"\n        obs.formDefinition &&\n        obs.submission &&\n        obs.processLinkIsForm &&\n        !obs.processLinkIsUiComponent &&\n        !obs.processLinkIsFormViewModel\n      \"\n      [form]=\"obs.formDefinition\"\n      [submission]=\"obs.submission\"\n      (submit)=\"onSubmit($event)\"\n      (change)=\"onChange($event)\"\n      [options]=\"obs.formioOptions\"\n    ></valtimo-form-io>\n\n    <valtimo-form-flow\n      #formFlow\n      *ngIf=\"obs.processLinkIsFormFlow\"\n      [formIoFormData]=\"formIoFormData$\"\n      [formFlowInstanceId]=\"obs.formFlowInstanceId\"\n      (formFlowComplete)=\"completeTask(obs.task)\"\n      (formFlowChange)=\"onFormFlowChangeEvent()\"\n    ></valtimo-form-flow>\n\n    @if (obs.noFormNotification) {\n      <cds-inline-notification [notificationObj]=\"obs.noFormNotification\"></cds-inline-notification>\n    }\n\n    @if (obs.errorMessage) {\n      <cds-inline-notification\n        [notificationObj]=\"{\n          type: 'error',\n          title: ('interface.error' | translate),\n          message: obs.errorMessage,\n          showClose: false,\n          lowContrast: true\n        }\"\n      ></cds-inline-notification>\n    }\n  }\n\n  <div class=\"m-2\">\n    <ng-template #formViewModelComponent></ng-template>\n    <ng-template #formCustomComponent></ng-template>\n  </div>\n</ng-container>\n" }]
+        }], ctorParameters: () => [{ type: i1$1.ConfigService }, { type: i2.DocumentService }, { type: i1$1.GlobalNotificationService }, { type: i2$1.IconService }, { type: i4.NGXLogger }, { type: i9.ValtimoModalService }, { type: i3.PermissionService }, { type: i7.ProcessLinkService }, { type: i1$2.Router }, { type: i9.FormIoStateService }, { type: TaskIntermediateSaveService }, { type: TaskService }, { type: i4$1.TranslateService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FORM_VIEW_MODEL_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FORM_CUSTOM_COMPONENT_TOKEN]
+                }] }, { type: i7.UrlResolverService }], propDecorators: { form: [{
+                type: ViewChild,
+                args: ['form']
+            }], formViewModelDynamicContainer: [{
+                type: ViewChild,
+                args: ['formViewModelComponent', { static: false, read: ViewContainerRef }]
+            }], formFlow: [{
+                type: ViewChild,
+                args: ['formFlow']
+            }], formCustomComponentDynamicContainer: [{
+                type: ViewChild,
+                args: ['formCustomComponent', { static: false, read: ViewContainerRef }]
+            }], task: [{
+                type: Input
+            }], taskAndProcessLink: [{
+                type: Input
+            }], modalClosed: [{
+                type: Input
+            }], closeModalEvent: [{
+                type: Output
+            }], formSubmit: [{
+                type: Output
+            }], activeChange: [{
+                type: Output
+            }], taskUpdated: [{
+                type: Output
+            }] } });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskDetailIntermediateSaveComponent {
+    set task(value) {
+        if (!value)
+            return;
+        this.taskService
+            .getTaskProcessLink(value.id)
+            .pipe(take$1(1))
+            .subscribe(res => {
+            this.setFormFlow(res);
+        });
+        this.taskValue.set(value);
+        this.page.set({
+            title: value.name,
+            subtitle: `${this.translateService.instant('taskDetail.taskCreated')} ${value.created}`,
+        });
+        this.getCurrentProgress(value);
+    }
+    set taskAndProcessLink(value) {
+        if (!value)
+            return;
+        this.setFormFlow(value.processLinkActivityResult);
+        this.taskValue.set(value.task);
+        this.page.set({
+            title: value?.task.name,
+            subtitle: `${this.translateService.instant('taskDetail.taskCreated')} ${value?.task.created}`,
+        });
+        this.getCurrentProgress(value.task);
+    }
+    constructor(configService, globalNotificationService, iconService, taskIntermediateSaveService, taskService, translateService) {
+        this.configService = configService;
+        this.globalNotificationService = globalNotificationService;
+        this.iconService = iconService;
+        this.taskIntermediateSaveService = taskIntermediateSaveService;
+        this.taskService = taskService;
+        this.translateService = translateService;
+        this.currentIntermediateSaveEvent = new EventEmitter();
+        this.showModalEvent = new EventEmitter();
+        this.formFlowInstanceId$ = new BehaviorSubject(undefined);
+        this.showConfirmationModal$ = new BehaviorSubject(false);
+        this.taskValue = signal(null);
+        this.page = signal(null);
+        this.canAssignUserToTask = signal(false);
+        this.submission$ = this.taskIntermediateSaveService.submission$;
+        this.formIoFormData$ = this.taskIntermediateSaveService.formIoFormData$;
+        this.intermediateSaveEnabled = false;
+        this.currentIntermediateSave = null;
+        this.intermediateSaveEnabled = !!this.configService.featureToggles?.enableIntermediateSave;
+        this.iconService.registerAll([RecentlyViewed16]);
+    }
+    saveCurrentProgress() {
+        combineLatest([this.submission$, this.formIoFormData$])
+            .pipe(take$1(1), switchMap(([submission, formIoFormData]) => {
+            const dataToSave = submission?.data ? submission.data : formIoFormData;
+            const intermediateSaveRequest = {
+                submission: dataToSave,
+                taskInstanceId: this.taskValue()?.id ?? '',
+            };
+            return this.taskIntermediateSaveService
+                .storeIntermediateSubmission(intermediateSaveRequest)
+                .pipe(tap(() => {
+                // Update in-memory submission so form retains data on re-render
+                this.taskIntermediateSaveService.setSubmission({ data: dataToSave });
+            }));
+        }))
+            .subscribe({
+            next: intermediateSubmission => {
+                this.globalNotificationService.showToast({
+                    title: this.translateService.instant('formManagement.intermediateSave.success'),
+                    type: 'success',
+                });
+                this.currentIntermediateSave = this.formatIntermediateSubmission(intermediateSubmission);
+                this.currentIntermediateSaveEvent.emit(this.currentIntermediateSave);
+            },
+            error: () => {
+                this.globalNotificationService.showToast({
+                    title: this.translateService.instant('formManagement.intermediateSave.error'),
+                    type: 'error',
+                });
+            },
+        });
+    }
+    revertSaveClick() {
+        if (this.showModalEvent.observed) {
+            this.showModalEvent.emit();
+            return;
+        }
+        this.showConfirmationModal$.next(true);
+    }
+    clearCurrentProgress() {
+        this.taskIntermediateSaveService
+            .clearIntermediateSubmission(this.taskValue()?.id ?? '')
+            .pipe(take$1(1))
+            .subscribe(() => {
+            this.taskIntermediateSaveService.setSubmission({});
+            this.currentIntermediateSave = null;
+            this.currentIntermediateSaveEvent.emit(this.currentIntermediateSave);
+        });
+    }
+    setFormFlow(processLink) {
+        if (processLink !== null && processLink.type === 'form-flow') {
+            this.formFlowInstanceId$.next(processLink.properties.formFlowInstanceId);
+        }
+    }
+    formatIntermediateSubmission(intermediateSubmission) {
+        intermediateSubmission.createdOn = moment(intermediateSubmission.createdOn).format('DD MMM YYYY HH:mm');
+        if (intermediateSubmission.editedOn) {
+            intermediateSubmission.editedOn = moment(new Date(intermediateSubmission.editedOn)).format('DD MMM YYYY HH:mm');
+        }
+        return intermediateSubmission;
+    }
+    getCurrentProgress(task) {
+        this.taskIntermediateSaveService
+            .getIntermediateSubmission(task.id ?? '')
+            .pipe(take$1(1))
+            .subscribe(intermediateSave => {
+            if (intermediateSave !== null) {
+                this.currentIntermediateSave = this.formatIntermediateSubmission(intermediateSave);
+                // Update in-memory submission with data from API
+                this.taskIntermediateSaveService.setSubmission({ data: intermediateSave.submission });
+            }
+            else {
+                this.currentIntermediateSave = null;
+                this.taskIntermediateSaveService.setSubmission({});
+            }
+            this.currentIntermediateSaveEvent.emit(this.currentIntermediateSave);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskDetailIntermediateSaveComponent, deps: [{ token: i1$1.ConfigService }, { token: i1$1.GlobalNotificationService }, { token: i2$1.IconService }, { token: TaskIntermediateSaveService }, { token: TaskService }, { token: i4$1.TranslateService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.20", type: TaskDetailIntermediateSaveComponent, isStandalone: true, selector: "valtimo-task-detail-intermediate-save", inputs: { task: "task", taskAndProcessLink: "taskAndProcessLink" }, outputs: { currentIntermediateSaveEvent: "currentIntermediateSaveEvent", showModalEvent: "showModalEvent" }, ngImport: i0, template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n@if (intermediateSaveEnabled && (formFlowInstanceId$ | async) === undefined) {\n  <button\n    cdsButton=\"ghost\"\n    iconOnly=\"true\"\n    cdsIcon=\"save\"\n    [vTooltip]=\"'formManagement.intermediateSave.save' | translate\"\n    (click)=\"saveCurrentProgress()\"\n  ></button>\n\n  <button\n    cdsButton=\"ghost\"\n    iconOnly=\"true\"\n    cdsIcon=\"recently-viewed\"\n    [disabled]=\"!currentIntermediateSave\"\n    [vTooltip]=\"'formManagement.intermediateSave.clear' | translate\"\n    (click)=\"revertSaveClick()\"\n  ></button>\n}\n\n<valtimo-confirmation-modal\n  [showModalSubject$]=\"showConfirmationModal$\"\n  (confirmEvent)=\"clearCurrentProgress()\"\n  (cancelEvent)=\"showConfirmationModal$.next(false)\"\n  cancelButtonType=\"ghost\"\n  confirmButtonTextTranslationKey=\"interface.confirm\"\n  titleTranslationKey=\"formManagement.intermediateSave.clear\"\n  contentTranslationKey=\"formManagement.intermediateSave.clearConfirm\"\n></valtimo-confirmation-modal>\n", styles: [":host{flex-shrink:0}\n/*!\n * Copyright 2015-2025 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i4$1.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i2$1.Button, selector: "[cdsButton], [ibmButton]", inputs: ["ibmButton", "cdsButton", "size", "skeleton", "iconOnly", "isExpressive"] }, { kind: "ngmodule", type: ConfirmationModalModule }, { kind: "component", type: i9.ConfirmationModalComponent, selector: "valtimo-confirmation-modal", inputs: ["titleTranslationKey", "title", "content", "contentTranslationKey", "confirmButtonText", "confirmButtonTextTranslationKey", "confirmButtonType", "showOptionalButton", "optionalButtonText", "optionalButtonTextTranslationKey", "optionalButtonType", "cancelButtonText", "cancelButtonTextTranslationKey", "cancelButtonType", "showModalSubject$", "outputOnConfirm", "outputOnOptional", "spacerAfterCancelButton"], outputs: ["confirmEvent", "optionalEvent", "cancelEvent"] }, { kind: "ngmodule", type: IconModule }, { kind: "directive", type: i2$1.IconDirective, selector: "[cdsIcon], [ibmIcon]", inputs: ["ibmIcon", "cdsIcon", "size", "title", "ariaLabel", "ariaLabelledBy", "ariaHidden", "isFocusable"] }, { kind: "ngmodule", type: ModalModule }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i9.TooltipDirective, selector: "[vTooltip]", inputs: ["vTooltip", "onBottom", "tooltipDisabled"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskDetailIntermediateSaveComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-task-detail-intermediate-save', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        CommonModule,
+                        TranslateModule,
+                        ButtonModule,
+                        ConfirmationModalModule,
+                        IconModule,
+                        ModalModule,
+                        TooltipModule,
+                    ], template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n@if (intermediateSaveEnabled && (formFlowInstanceId$ | async) === undefined) {\n  <button\n    cdsButton=\"ghost\"\n    iconOnly=\"true\"\n    cdsIcon=\"save\"\n    [vTooltip]=\"'formManagement.intermediateSave.save' | translate\"\n    (click)=\"saveCurrentProgress()\"\n  ></button>\n\n  <button\n    cdsButton=\"ghost\"\n    iconOnly=\"true\"\n    cdsIcon=\"recently-viewed\"\n    [disabled]=\"!currentIntermediateSave\"\n    [vTooltip]=\"'formManagement.intermediateSave.clear' | translate\"\n    (click)=\"revertSaveClick()\"\n  ></button>\n}\n\n<valtimo-confirmation-modal\n  [showModalSubject$]=\"showConfirmationModal$\"\n  (confirmEvent)=\"clearCurrentProgress()\"\n  (cancelEvent)=\"showConfirmationModal$.next(false)\"\n  cancelButtonType=\"ghost\"\n  confirmButtonTextTranslationKey=\"interface.confirm\"\n  titleTranslationKey=\"formManagement.intermediateSave.clear\"\n  contentTranslationKey=\"formManagement.intermediateSave.clearConfirm\"\n></valtimo-confirmation-modal>\n", styles: [":host{flex-shrink:0}\n/*!\n * Copyright 2015-2025 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"] }]
+        }], ctorParameters: () => [{ type: i1$1.ConfigService }, { type: i1$1.GlobalNotificationService }, { type: i2$1.IconService }, { type: TaskIntermediateSaveService }, { type: TaskService }, { type: i4$1.TranslateService }], propDecorators: { task: [{
+                type: Input
+            }], taskAndProcessLink: [{
+                type: Input
+            }], currentIntermediateSaveEvent: [{
+                type: Output
+            }], showModalEvent: [{
+                type: Output
+            }] } });
+
+/*
+ * Copyright 2015-2026 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class SetTaskDueDateComponent {
+    set canModifyTask(value) {
+        this.canModifyTaskSet$.next(true);
+        this.canModifyTask$.next(value);
+    }
+    get _task() {
+        return this._task$.getValue();
+    }
+    get _selectedDateString() {
+        return this.selectedDateString$.getValue();
+    }
+    set task(value) {
+        if (!value) {
+            this.hasDueDate$.next(false);
+            this._task$.next(null);
+            this.selectedDateString$.next('');
+            return;
+        }
+        this.hasDueDate$.next(!!value.due);
+        this._task$.next(value);
+    }
+    constructor(cdsThemeService, iconService, taskService, translateService, globalNotificationService) {
+        this.cdsThemeService = cdsThemeService;
+        this.iconService = iconService;
+        this.taskService = taskService;
+        this.translateService = translateService;
+        this.globalNotificationService = globalNotificationService;
+        this.dueDateChanged = new EventEmitter();
+        this.canModifyTaskSet$ = new BehaviorSubject(false);
+        this.canModifyTask$ = new BehaviorSubject(false);
+        this._task$ = new BehaviorSubject(null);
+        this.hasDueDate$ = new BehaviorSubject(false);
+        this.selectedDateString$ = new BehaviorSubject('');
+        this.taskDueDate$ = this._task$.pipe(filter$1(task => !!task), map(task => new Date(task.due)));
+        this.showDatePicker$ = new BehaviorSubject(true);
+        this.disabled$ = new BehaviorSubject(false);
+        this.open$ = new Subject();
+        this.editToggletipOpen$ = new BehaviorSubject(false);
+        this.mouseIsOverDueDate$ = new BehaviorSubject(false);
+        this.toggletipTheme$ = this.cdsThemeService.toggletipTheme$;
+        this.toggletipDropdownTheme$ = this.cdsThemeService.toggletipDropdownTheme$;
+        this.language$ = this.translateService.onLangChange.pipe(map(event => event.lang), startWith(this.translateService.currentLang), distinctUntilChanged$1());
+        this.iconService.registerAll([CalendarAdd16, Edit16]);
+    }
+    clear() {
+        this.selectedDateString$.next('');
+        this.resetDatePicker();
+    }
+    initEditWithCurrentDate() {
+        this.editToggletipOpen$.next(true);
+        const task = this._task;
+        if (task?.due) {
+            this.selectedDateString$.next(new Date(task.due).toISOString());
+        }
+        else {
+            this.selectedDateString$.next('');
+        }
+        this.resetDatePicker();
+    }
+    onCloseEditToggletip() {
+        this.editToggletipOpen$.next(false);
+    }
+    onMouseEnterDueDate() {
+        this.mouseIsOverDueDate$.next(true);
+    }
+    onMouseLeaveDueDate() {
+        this.mouseIsOverDueDate$.next(false);
+    }
+    onDateValueChange(value) {
+        const date = Array.isArray(value) && value[0];
+        if (!date) {
+            this.selectedDateString$.next('');
+            return;
+        }
+        this.selectedDateString$.next(date.toISOString());
+    }
+    onSubmitButtonClick() {
+        this.disabled$.next(true);
+        const dateString = this._selectedDateString;
+        this.taskService.setTaskDueDate(this._task.id, { dueDate: dateString }).subscribe({
+            next: () => {
+                this.disabled$.next(false);
+                this.hasDueDate$.next(true);
+                this._task$.next({ ...this._task, due: dateString });
+                this.selectedDateString$.next('');
+                this.closeToggletip();
+                this.dueDateChanged.emit();
+                this.showDueDateSetNotification(dateString);
+            },
+            error: () => {
+                this.disabled$.next(false);
+            },
+        });
+    }
+    onRemoveButtonClick() {
+        this.disabled$.next(true);
+        this.taskService.removeTaskDueDate(this._task.id).subscribe({
+            next: () => {
+                this.disabled$.next(false);
+                this.hasDueDate$.next(false);
+                this._task$.next({ ...this._task, due: null });
+                this.closeToggletip();
+                this.dueDateChanged.emit();
+                this.showDueDateRemovedNotification();
+            },
+            error: () => {
+                this.disabled$.next(false);
+            },
+        });
+    }
+    resetDatePicker() {
+        this.showDatePicker$.next(false);
+        setTimeout(() => this.showDatePicker$.next(true));
+    }
+    closeToggletip() {
+        this.editToggletipOpen$.next(false);
+        this.open$.next(true);
+        setTimeout(() => this.open$.next(false));
+    }
+    showDueDateSetNotification(dateString) {
+        const formattedDate = new Date(dateString).toLocaleDateString(this.translateService.currentLang);
+        this.globalNotificationService.showToast({
+            title: this.translateService.instant('taskDetail.dueDateSetNotificationTitle'),
+            subtitle: this.translateService.instant('taskDetail.dueDateSetNotificationContent', {
+                date: formattedDate,
+                task: this._task?.name,
+            }),
+            type: 'info',
+        });
+    }
+    showDueDateRemovedNotification() {
+        this.globalNotificationService.showToast({
+            title: this.translateService.instant('taskDetail.dueDateRemovedNotificationTitle'),
+            subtitle: this.translateService.instant('taskDetail.dueDateRemovedNotificationContent', {
+                task: this._task?.name,
+            }),
+            type: 'info',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: SetTaskDueDateComponent, deps: [{ token: i9.CdsThemeService }, { token: i2$1.IconService }, { token: TaskService }, { token: i4$1.TranslateService }, { token: i1$1.GlobalNotificationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: SetTaskDueDateComponent, isStandalone: true, selector: "valtimo-set-task-due-date", inputs: { canModifyTask: "canModifyTask", task: "task" }, outputs: { dueDateChanged: "dueDateChanged" }, ngImport: i0, template: "<!--\n  ~ Copyright 2015-2026 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n<ng-container\n  *ngIf=\"\n    (canModifyTaskSet$ | async) && {\n      hasDueDate: hasDueDate$ | async,\n      taskDueDate: taskDueDate$ | async,\n      selectedDateString: selectedDateString$ | async,\n      disabled: disabled$ | async,\n      mouseIsOverDueDate: mouseIsOverDueDate$ | async,\n      canModifyTask: canModifyTask$ | async,\n      language: language$ | async,\n      showDatePicker: showDatePicker$ | async,\n      editToggletipOpen: editToggletipOpen$ | async,\n    } as obs\n  \"\n>\n  <div\n    *ngIf=\"obs.canModifyTask || (!obs.canModifyTask && obs.hasDueDate)\"\n    class=\"due-date-container\"\n    (mouseenter)=\"onMouseEnterDueDate()\"\n    (mouseleave)=\"onMouseLeaveDueDate()\"\n  >\n    <div\n      class=\"due-date-text element\"\n      [ngClass]=\"{\n        active: obs.canModifyTask\n          ? obs.hasDueDate && !obs.mouseIsOverDueDate && !obs.editToggletipOpen\n          : obs.hasDueDate,\n      }\"\n    >\n      <span class=\"bold\">{{ 'setTaskDueDate.dueDateText' | translate }}</span>\n      &nbsp;\n      {{ obs.taskDueDate | date: 'dd-MM-yyyy' }}\n    </div>\n\n    <cds-toggletip\n      *ngIf=\"obs.canModifyTask\"\n      align=\"bottom\"\n      class=\"element\"\n      [autoAlign]=\"true\"\n      [isOpen]=\"open$ | async\"\n      [ngClass]=\"{active: obs.hasDueDate && (obs.mouseIsOverDueDate || obs.editToggletipOpen)}\"\n      (onOpen)=\"initEditWithCurrentDate()\"\n      (onClose)=\"onCloseEditToggletip()\"\n    >\n      <button\n        cdsToggletipButton\n        [removeClassnames]=\"['cds--toggletip-button']\"\n        cdsButton=\"ghost\"\n        size=\"sm\"\n        class=\"click-to-edit-button\"\n      >\n        {{ 'setTaskDueDate.clickToEdit' | translate }}\n      </button>\n\n      <div cdsToggletipContent class=\"assign-due-date-popover-content\">\n        <cds-date-picker\n          *ngIf=\"obs.showDatePicker\"\n          [attr.data-carbon-theme]=\"toggletipDropdownTheme$ | async\"\n          [cdsLayer]=\"1\"\n          [label]=\"'setTaskDueDate.label' | translate\"\n          [language]=\"obs.language\"\n          [placeholder]=\"'dd-mm-jjjj'\"\n          dateFormat=\"d/m/Y\"\n          [value]=\"obs.taskDueDate ? [obs.taskDueDate] : []\"\n          [disabled]=\"obs.disabled\"\n          (valueChange)=\"onDateValueChange($event)\"\n        ></cds-date-picker>\n\n        <button\n          cdsButton\n          [attr.data-carbon-theme]=\"toggletipTheme$ | async\"\n          class=\"submit-due-date-button\"\n          [disabled]=\"!obs.selectedDateString || obs.disabled\"\n          (click)=\"onSubmitButtonClick()\"\n        >\n          {{ 'setTaskDueDate.submitButtonText' | translate }}\n\n          <svg class=\"cds--btn__icon\" cdsIcon=\"calendar--add\" size=\"16\"></svg>\n        </button>\n\n        <button\n          cdsButton=\"danger--tertiary\"\n          [cdsLayer]=\"1\"\n          [attr.data-carbon-theme]=\"toggletipTheme$ | async\"\n          [disabled]=\"obs.disabled\"\n          (click)=\"onRemoveButtonClick()\"\n        >\n          {{ 'setTaskDueDate.removeButtonText' | translate }}\n        </button>\n      </div>\n    </cds-toggletip>\n\n    <cds-toggletip\n      align=\"bottom\"\n      class=\"element main\"\n      [autoAlign]=\"true\"\n      [isOpen]=\"open$ | async\"\n      [ngClass]=\"{active: !obs.hasDueDate}\"\n      (onOpen)=\"clear()\"\n    >\n      <button\n        cdsToggletipButton\n        [removeClassnames]=\"['cds--toggletip-button']\"\n        cdsButton=\"tertiary\"\n        size=\"sm\"\n        class=\"set-task-due-date-button\"\n      >\n        {{ 'setTaskDueDate.buttonText' | translate }}\n\n        <svg class=\"cds--btn__icon\" cdsIcon=\"calendar--add\" size=\"16\"></svg>\n      </button>\n\n      <div cdsToggletipContent class=\"assign-due-date-popover-content\">\n        <cds-date-picker\n          *ngIf=\"!obs.hasDueDate && obs.showDatePicker\"\n          [attr.data-carbon-theme]=\"toggletipDropdownTheme$ | async\"\n          [cdsLayer]=\"1\"\n          [label]=\"'setTaskDueDate.label' | translate\"\n          [language]=\"obs.language\"\n          [placeholder]=\"'dd-mm-jjjj'\"\n          dateFormat=\"d/m/Y\"\n          [disabled]=\"obs.disabled\"\n          (valueChange)=\"onDateValueChange($event)\"\n        ></cds-date-picker>\n\n        <button\n          cdsButton\n          [attr.data-carbon-theme]=\"toggletipTheme$ | async\"\n          class=\"submit-due-date-button\"\n          [disabled]=\"!obs.selectedDateString || obs.disabled\"\n          (click)=\"onSubmitButtonClick()\"\n        >\n          {{ 'setTaskDueDate.submitButtonText' | translate }}\n\n          <svg class=\"cds--btn__icon\" cdsIcon=\"calendar--add\" size=\"16\"></svg>\n        </button>\n      </div>\n    </cds-toggletip>\n  </div>\n</ng-container>\n", styles: [":host ::ng-deep .cds--popover-content{max-inline-size:unset}.due-date-container{display:flex;align-items:center;justify-content:center;position:relative;font-weight:400;font-size:14px;line-height:18px;letter-spacing:.16px;color:var(--cds-link-01)}.due-date-container .bold{font-weight:700}.due-date-text{display:flex;justify-content:flex-start;align-items:center;width:100%}.element{opacity:0;visibility:hidden;position:absolute;width:100%;transition:opacity .3s ease-in-out}.element.active{opacity:1;visibility:visible}.element.main{position:relative;width:auto}.assign-due-date-popover-content{width:400px;max-inline-size:400px;display:flex;flex-direction:column;gap:16px}.assign-due-date-popover-content .cds--btn{width:100%;max-width:unset}.assign-due-date-popover-content ::ng-deep .cds--date-picker-input__wrapper,.assign-due-date-popover-content ::ng-deep .cds--date-picker-input__wrapper>span,.assign-due-date-popover-content ::ng-deep .cds--date-picker-container,.assign-due-date-popover-content ::ng-deep .cds--date-picker,.assign-due-date-popover-content ::ng-deep .cds--date-picker__input{width:100%}.set-task-due-date-button{width:250px}.click-to-edit-button{width:100%}\n/*!\n * Copyright 2015-2026 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.DatePipe, name: "date" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i4$1.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i2$1.Button, selector: "[cdsButton], [ibmButton]", inputs: ["ibmButton", "cdsButton", "size", "skeleton", "iconOnly", "isExpressive"] }, { kind: "ngmodule", type: IconModule }, { kind: "directive", type: i2$1.IconDirective, selector: "[cdsIcon], [ibmIcon]", inputs: ["ibmIcon", "cdsIcon", "size", "title", "ariaLabel", "ariaLabelledBy", "ariaHidden", "isFocusable"] }, { kind: "ngmodule", type: ToggletipModule }, { kind: "component", type: i2$1.Toggletip, selector: "cds-toggletip, ibm-toggletip", inputs: ["id", "isOpen"] }, { kind: "directive", type: i2$1.ToggletipButton, selector: "[cdsToggletipButton], [ibmToggletipButton]", inputs: ["ariaLabel"] }, { kind: "directive", type: i2$1.ToggletipContent, selector: "[cdsToggletipContent], [ibmToggletipContent]" }, { kind: "ngmodule", type: DatePickerModule }, { kind: "component", type: i2$1.DatePicker, selector: "cds-date-picker, ibm-date-picker", inputs: ["range", "dateFormat", "language", "label", "helperText", "rangeHelperText", "rangeLabel", "placeholder", "ariaLabel", "inputPattern", "id", "value", "theme", "disabled", "readonly", "invalid", "invalidText", "warn", "warnText", "size", "rangeInvalid", "rangeInvalidText", "rangeWarn", "rangeWarnText", "skeleton", "plugins", "flatpickrOptions"], outputs: ["valueChange", "onClose"] }, { kind: "ngmodule", type: LayerModule }, { kind: "directive", type: i2$1.LayerDirective, selector: "[cdsLayer], [ibmLayer]", inputs: ["ibmLayer", "cdsLayer"], exportAs: ["layer"] }, { kind: "directive", type: RemoveClassnamesDirective, selector: "[removeClassnames]", inputs: ["removeClassnames"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: SetTaskDueDateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-set-task-due-date', standalone: true, imports: [
+                        CommonModule,
+                        TranslateModule,
+                        ButtonModule,
+                        IconModule,
+                        ToggletipModule,
+                        DatePickerModule,
+                        LayerModule,
+                        RemoveClassnamesDirective,
+                    ], template: "<!--\n  ~ Copyright 2015-2026 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n<ng-container\n  *ngIf=\"\n    (canModifyTaskSet$ | async) && {\n      hasDueDate: hasDueDate$ | async,\n      taskDueDate: taskDueDate$ | async,\n      selectedDateString: selectedDateString$ | async,\n      disabled: disabled$ | async,\n      mouseIsOverDueDate: mouseIsOverDueDate$ | async,\n      canModifyTask: canModifyTask$ | async,\n      language: language$ | async,\n      showDatePicker: showDatePicker$ | async,\n      editToggletipOpen: editToggletipOpen$ | async,\n    } as obs\n  \"\n>\n  <div\n    *ngIf=\"obs.canModifyTask || (!obs.canModifyTask && obs.hasDueDate)\"\n    class=\"due-date-container\"\n    (mouseenter)=\"onMouseEnterDueDate()\"\n    (mouseleave)=\"onMouseLeaveDueDate()\"\n  >\n    <div\n      class=\"due-date-text element\"\n      [ngClass]=\"{\n        active: obs.canModifyTask\n          ? obs.hasDueDate && !obs.mouseIsOverDueDate && !obs.editToggletipOpen\n          : obs.hasDueDate,\n      }\"\n    >\n      <span class=\"bold\">{{ 'setTaskDueDate.dueDateText' | translate }}</span>\n      &nbsp;\n      {{ obs.taskDueDate | date: 'dd-MM-yyyy' }}\n    </div>\n\n    <cds-toggletip\n      *ngIf=\"obs.canModifyTask\"\n      align=\"bottom\"\n      class=\"element\"\n      [autoAlign]=\"true\"\n      [isOpen]=\"open$ | async\"\n      [ngClass]=\"{active: obs.hasDueDate && (obs.mouseIsOverDueDate || obs.editToggletipOpen)}\"\n      (onOpen)=\"initEditWithCurrentDate()\"\n      (onClose)=\"onCloseEditToggletip()\"\n    >\n      <button\n        cdsToggletipButton\n        [removeClassnames]=\"['cds--toggletip-button']\"\n        cdsButton=\"ghost\"\n        size=\"sm\"\n        class=\"click-to-edit-button\"\n      >\n        {{ 'setTaskDueDate.clickToEdit' | translate }}\n      </button>\n\n      <div cdsToggletipContent class=\"assign-due-date-popover-content\">\n        <cds-date-picker\n          *ngIf=\"obs.showDatePicker\"\n          [attr.data-carbon-theme]=\"toggletipDropdownTheme$ | async\"\n          [cdsLayer]=\"1\"\n          [label]=\"'setTaskDueDate.label' | translate\"\n          [language]=\"obs.language\"\n          [placeholder]=\"'dd-mm-jjjj'\"\n          dateFormat=\"d/m/Y\"\n          [value]=\"obs.taskDueDate ? [obs.taskDueDate] : []\"\n          [disabled]=\"obs.disabled\"\n          (valueChange)=\"onDateValueChange($event)\"\n        ></cds-date-picker>\n\n        <button\n          cdsButton\n          [attr.data-carbon-theme]=\"toggletipTheme$ | async\"\n          class=\"submit-due-date-button\"\n          [disabled]=\"!obs.selectedDateString || obs.disabled\"\n          (click)=\"onSubmitButtonClick()\"\n        >\n          {{ 'setTaskDueDate.submitButtonText' | translate }}\n\n          <svg class=\"cds--btn__icon\" cdsIcon=\"calendar--add\" size=\"16\"></svg>\n        </button>\n\n        <button\n          cdsButton=\"danger--tertiary\"\n          [cdsLayer]=\"1\"\n          [attr.data-carbon-theme]=\"toggletipTheme$ | async\"\n          [disabled]=\"obs.disabled\"\n          (click)=\"onRemoveButtonClick()\"\n        >\n          {{ 'setTaskDueDate.removeButtonText' | translate }}\n        </button>\n      </div>\n    </cds-toggletip>\n\n    <cds-toggletip\n      align=\"bottom\"\n      class=\"element main\"\n      [autoAlign]=\"true\"\n      [isOpen]=\"open$ | async\"\n      [ngClass]=\"{active: !obs.hasDueDate}\"\n      (onOpen)=\"clear()\"\n    >\n      <button\n        cdsToggletipButton\n        [removeClassnames]=\"['cds--toggletip-button']\"\n        cdsButton=\"tertiary\"\n        size=\"sm\"\n        class=\"set-task-due-date-button\"\n      >\n        {{ 'setTaskDueDate.buttonText' | translate }}\n\n        <svg class=\"cds--btn__icon\" cdsIcon=\"calendar--add\" size=\"16\"></svg>\n      </button>\n\n      <div cdsToggletipContent class=\"assign-due-date-popover-content\">\n        <cds-date-picker\n          *ngIf=\"!obs.hasDueDate && obs.showDatePicker\"\n          [attr.data-carbon-theme]=\"toggletipDropdownTheme$ | async\"\n          [cdsLayer]=\"1\"\n          [label]=\"'setTaskDueDate.label' | translate\"\n          [language]=\"obs.language\"\n          [placeholder]=\"'dd-mm-jjjj'\"\n          dateFormat=\"d/m/Y\"\n          [disabled]=\"obs.disabled\"\n          (valueChange)=\"onDateValueChange($event)\"\n        ></cds-date-picker>\n\n        <button\n          cdsButton\n          [attr.data-carbon-theme]=\"toggletipTheme$ | async\"\n          class=\"submit-due-date-button\"\n          [disabled]=\"!obs.selectedDateString || obs.disabled\"\n          (click)=\"onSubmitButtonClick()\"\n        >\n          {{ 'setTaskDueDate.submitButtonText' | translate }}\n\n          <svg class=\"cds--btn__icon\" cdsIcon=\"calendar--add\" size=\"16\"></svg>\n        </button>\n      </div>\n    </cds-toggletip>\n  </div>\n</ng-container>\n", styles: [":host ::ng-deep .cds--popover-content{max-inline-size:unset}.due-date-container{display:flex;align-items:center;justify-content:center;position:relative;font-weight:400;font-size:14px;line-height:18px;letter-spacing:.16px;color:var(--cds-link-01)}.due-date-container .bold{font-weight:700}.due-date-text{display:flex;justify-content:flex-start;align-items:center;width:100%}.element{opacity:0;visibility:hidden;position:absolute;width:100%;transition:opacity .3s ease-in-out}.element.active{opacity:1;visibility:visible}.element.main{position:relative;width:auto}.assign-due-date-popover-content{width:400px;max-inline-size:400px;display:flex;flex-direction:column;gap:16px}.assign-due-date-popover-content .cds--btn{width:100%;max-width:unset}.assign-due-date-popover-content ::ng-deep .cds--date-picker-input__wrapper,.assign-due-date-popover-content ::ng-deep .cds--date-picker-input__wrapper>span,.assign-due-date-popover-content ::ng-deep .cds--date-picker-container,.assign-due-date-popover-content ::ng-deep .cds--date-picker,.assign-due-date-popover-content ::ng-deep .cds--date-picker__input{width:100%}.set-task-due-date-button{width:250px}.click-to-edit-button{width:100%}\n/*!\n * Copyright 2015-2026 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"] }]
+        }], ctorParameters: () => [{ type: i9.CdsThemeService }, { type: i2$1.IconService }, { type: TaskService }, { type: i4$1.TranslateService }, { type: i1$1.GlobalNotificationService }], propDecorators: { dueDateChanged: [{
+                type: Output
+            }], canModifyTask: [{
+                type: Input
+            }], task: [{
+                type: Input
+            }] } });
+
+/*
+ * Copyright 2015-2026 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+moment.locale(localStorage.getItem('langKey') || '');
+class TaskDetailModalComponent {
+    set modalSize(value) {
+        if (value)
+            this.size$.next(formSizeToCarbonModalSizeMap[value]);
+    }
+    set openFromCaseManagement(value) {
+        if (value)
+            this.openFromCaseManagement$.next(value);
+    }
+    constructor(router, translateService, permissionService, logger, taskIntermediateSaveService, sseService, cdr, iconService, documentService, taskService, globalNotificationService) {
+        this.router = router;
+        this.translateService = translateService;
+        this.permissionService = permissionService;
+        this.logger = logger;
+        this.taskIntermediateSaveService = taskIntermediateSaveService;
+        this.sseService = sseService;
+        this.cdr = cdr;
+        this.iconService = iconService;
+        this.documentService = documentService;
+        this.taskService = taskService;
+        this.globalNotificationService = globalNotificationService;
+        this.formSubmit = new EventEmitter();
+        this.assignmentOfTaskChanged = new EventEmitter();
+        this.dueDateChanged = new EventEmitter();
+        this.modalClosed = new EventEmitter();
+        this.currentIntermediateSave$ = new BehaviorSubject(null);
+        this.processLinkPreloaded$ = new BehaviorSubject(false);
+        this.task$ = new BehaviorSubject(null);
+        this.taskAndProcessLink$ = new BehaviorSubject(null);
+        this.submission$ = new BehaviorSubject({});
+        this.page$ = new BehaviorSubject(null);
+        this.showConfirmationModal$ = new BehaviorSubject(false);
+        this.businessKey$ = new BehaviorSubject('');
+        this.caseDocumentId$ = new BehaviorSubject('');
+        this.size$ = new BehaviorSubject('md');
+        this.openFromCaseManagement$ = new BehaviorSubject(false);
+        this.canAssignUserToTask$ = new BehaviorSubject(false);
+        this.canModifyTask$ = new BehaviorSubject(false);
+        this.modalCloseEvent$ = new BehaviorSubject(false);
+        this.modalOpen$ = new BehaviorSubject(false);
+        this.candidateUsers$ = combineLatest([
+            this.task$.pipe(filter$1(task => !!task)),
+            this.canAssignUserToTask$,
+        ]).pipe(switchMap$1(([task, canAssign]) => canAssign ? this.taskService.getCandidateUsers(task.id) : of([])), shareReplay(1));
+        this.candidateTeams$ = combineLatest([
+            this.task$.pipe(filter$1(task => !!task)),
+            this.canAssignUserToTask$,
+        ]).pipe(switchMap$1(([task, canAssign]) => canAssign ? this.taskService.getCandidateTeams(task.id).pipe(map(page => page.content)) : of([])), shareReplay(1));
+        this._subscriptions = new Subscription();
+        this.iconService.registerAll([FolderDetailsReference16]);
+    }
+    ngOnInit() {
+        this.openTaskSubscription();
+        this.openTaskUpdateSseEventSubscription();
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
+    openRelatedCase() {
+        const caseDocId = this.caseDocumentId$.getValue() || this.businessKey$.getValue();
+        this.documentService
+            .getDocument(caseDocId)
+            .pipe(take(1))
+            .subscribe(document => {
+            window.open(`/cases/${document.definitionId?.name}/document/${caseDocId}`, '_blank');
+        });
+    }
+    openTaskSubscription() {
+        this._subscriptions.add(this.task$.subscribe(task => {
+            if (task) {
+                this.logger.debug('Checking if user allowed to assign a user to Task with id:', task.id);
+                this.businessKey$.next(task.businessKey);
+                this.caseDocumentId$.next(task.caseDocumentId || task.businessKey);
+                this.permissionService
+                    .requestPermission(CAN_ASSIGN_TASK_PERMISSION, {
+                    resource: TASK_DETAIL_PERMISSION_RESOURCE.task,
+                    identifier: task.id,
+                })
+                    .subscribe((allowed) => {
+                    this.canAssignUserToTask$.next(allowed);
+                });
+                this.permissionService
+                    .requestPermission(CAN_MODIFY_TASK_PERMISSION, {
+                    resource: TASK_DETAIL_PERMISSION_RESOURCE.task,
+                    identifier: task.id,
+                })
+                    .subscribe((allowed) => {
+                    this.canModifyTask$.next(allowed);
+                });
+            }
+            else {
+                this.logger.debug('Reset is user allowed to assign a user to Task as task is null');
+                this.canAssignUserToTask$.next(false);
+            }
+        }));
+    }
+    openTaskUpdateSseEventSubscription() {
+        this._subscriptions.add(this.sseService
+            .getSseEventObservable('TASK_UPDATE')
+            .pipe(filter$1(event => this.task$.getValue()?.id === event.taskId), switchMap$1(event => this.taskService.getTask(event.taskId).pipe(catchError$1(err => {
+            if (err.status === 404) {
+                return of(null);
+            }
+            this.logger.error('Failed to fetch task on SSE update', err);
+            return EMPTY;
+        }))))
+            .subscribe(response => {
+            if (!response) {
+                this.closeModal();
+            }
+            else {
+                const currentTask = this.task$.getValue();
+                const fetchedTask = response.task;
+                if (!currentTask || !fetchedTask)
+                    return;
+                // Merge fetched task data onto the existing task, only overwriting with
+                // defined values to preserve fields not returned by the GET /v1/task/{id}
+                // endpoint (e.g. valtimoAssignee, businessKey, caseDocumentId)
+                const mergedTask = { ...currentTask };
+                for (const [key, value] of Object.entries(fetchedTask)) {
+                    if (value !== undefined) {
+                        mergedTask[key] = value;
+                    }
+                }
+                if (currentTask.assignee !== mergedTask.assignee) {
+                    this.showAssigneeNotification(mergedTask);
+                }
+                this.task$.next(mergedTask);
+            }
+        }));
+    }
+    refreshTask(response) {
+        const currentTask = this.task$.getValue();
+        const fetchedTask = response.task;
+        if (!currentTask || !fetchedTask)
+            return;
+        const mergedTask = { ...currentTask };
+        for (const [key, value] of Object.entries(fetchedTask)) {
+            if (value !== undefined) {
+                mergedTask[key] = value;
+            }
+        }
+        this.task$.next(mergedTask);
+    }
+    showAssigneeNotification(task) {
+        if (task.assignee) {
+            this.globalNotificationService.showToast({
+                title: this.translateService.instant('taskDetail.assignedNotificationTitle'),
+                type: 'info',
+            });
+        }
+        else {
+            this.globalNotificationService.showToast({
+                title: this.translateService.instant('taskDetail.unassignedNotificationTitle'),
+                type: 'info',
+            });
+        }
+    }
+    clearCurrentProgress() {
+        this._intermediateSaveComponent.clearCurrentProgress();
+    }
+    openTaskDetails(task) {
+        if (task) {
+            this.task$.next({ ...task });
+        }
+        this.setPageFromTask(task);
+        this.openModal();
+    }
+    openTaskAndProcessLinkDetails(taskWithProcessLink) {
+        this.processLinkPreloaded$.next(true);
+        if (taskWithProcessLink) {
+            this.taskAndProcessLink$.next(taskWithProcessLink);
+            const task = enrichTaskFromProcessLink({ ...taskWithProcessLink.task }, taskWithProcessLink.processLinkActivityResult);
+            this.task$.next(task);
+        }
+        this.setPageFromTask(taskWithProcessLink?.task);
+        this.openModal();
+    }
+    setPageFromTask(task) {
+        this.page$.next({
+            title: task?.name,
+            subtitle: `${this.translateService.instant('taskDetail.taskCreated')} ${task?.created}`,
+        });
+    }
+    gotoProcessLinkScreen() {
+        this.closeModal();
+        this.router.navigate(['process-links']);
+    }
+    onCurrentIntermediateSaveEvent(value) {
+        this.currentIntermediateSave$.next(value);
+    }
+    onTaskUpdated(task) {
+        this.task$.next(task);
+    }
+    onAssignmentChanged(event) {
+        const task = this.task$.getValue();
+        if (!task)
+            return;
+        const assignRequest = {};
+        if (event.userId !== undefined)
+            assignRequest.assignee = event.userId ?? '';
+        if (event.teamKey !== undefined)
+            assignRequest.assignedTeamKey = event.teamKey ?? '';
+        this.taskService
+            .assignTask(task.id, assignRequest)
+            .pipe(switchMap$1(() => this.taskService.getTask(task.id)), take(1))
+            .subscribe(response => {
+            this.refreshTask(response);
+            this.assignmentOfTaskChanged.emit();
+        });
+    }
+    onUnassigned() {
+        const task = this.task$.getValue();
+        if (!task)
+            return;
+        this.taskService
+            .unassignTask(task.id)
+            .pipe(switchMap$1(() => this.taskService.getTask(task.id)), take(1))
+            .subscribe(response => {
+            this.refreshTask(response);
+            this.assignmentOfTaskChanged.emit();
+        });
+    }
+    onFormSubmit() {
+        this.formSubmit.emit();
+    }
+    onShowModalEvent() {
+        this.showConfirmationModal$.next(true);
+    }
+    closeModal() {
+        this.modalOpen$.next(false);
+        this.modalCloseEvent$.next(!this.modalCloseEvent$.getValue());
+        this.modalClosed.emit();
+        // Delay clearing task data and submission until after modal close animation completes
+        runAfterCarbonModalClosed(() => {
+            this.processLinkPreloaded$.next(false);
+            this.task$.next(null);
+            this.taskAndProcessLink$.next(null);
+            this.taskIntermediateSaveService.setSubmission({});
+        });
+    }
+    openModal() {
+        this.modalOpen$.next(false);
+        setTimeout(() => {
+            this.modalOpen$.next(true);
+            this.cdr.detectChanges();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskDetailModalComponent, deps: [{ token: i1$2.Router }, { token: i4$1.TranslateService }, { token: i3.PermissionService }, { token: i4.NGXLogger }, { token: TaskIntermediateSaveService }, { token: i6$1.SseService }, { token: i0.ChangeDetectorRef }, { token: i2$1.IconService }, { token: i2.DocumentService }, { token: TaskService }, { token: i1$1.GlobalNotificationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.20", type: TaskDetailModalComponent, isStandalone: false, selector: "valtimo-task-detail-modal", inputs: { modalSize: "modalSize", openFromCaseManagement: "openFromCaseManagement" }, outputs: { formSubmit: "formSubmit", assignmentOfTaskChanged: "assignmentOfTaskChanged", dueDateChanged: "dueDateChanged", modalClosed: "modalClosed" }, viewQueries: [{ propertyName: "_intermediateSaveComponent", first: true, predicate: TaskDetailIntermediateSaveComponent, descendants: true }], ngImport: i0, template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<cds-modal\n  id=\"taskDetailModal\"\n  [size]=\"size$ | async\"\n  [open]=\"modalOpen$ | async\"\n  (close)=\"closeModal()\"\n  valtimoCdsModal\n  [minContentHeight]=\"480\"\n>\n  <cds-modal-header (closeSelect)=\"closeModal()\">\n    <div class=\"title-container\">\n      <p class=\"cds--modal-header__heading cds--type-beta\">{{ (page$ | async)?.title }}</p>\n\n      <p class=\"cds--modal-header__label cds--type-delta\">{{ (page$ | async)?.subtitle }}</p>\n\n      <p\n        class=\"cds--modal-header__label cds--type-delta\"\n        *ngIf=\"currentIntermediateSave$ | async as currentIntermediateSave\"\n      >\n        {{ 'formManagement.intermediateSave.lastSavedBy' | translate }}:\n\n        {{\n          currentIntermediateSave?.editedBy\n            ? currentIntermediateSave?.editedBy\n            : currentIntermediateSave.createdBy\n        }}\n\n        {{ 'formManagement.intermediateSave.on' | translate }}:\n\n        {{\n          currentIntermediateSave?.editedOn\n            ? currentIntermediateSave?.editedOn\n            : currentIntermediateSave.createdOn\n        }}\n      </p>\n\n      <ng-container *ngTemplateOutlet=\"assignUserToTask\"></ng-container>\n    </div>\n\n    <div class=\"save-buttons-margin\">\n      <button\n        *ngIf=\"!(openFromCaseManagement$ | async)\"\n        cdsButton=\"ghost\"\n        iconOnly=\"true\"\n        cdsIcon=\"folder--details--reference\"\n        [vTooltip]=\"'formManagement.navigateToRelatedCase' | translate\"\n        (click)=\"openRelatedCase()\"\n      ></button>\n\n      @if (processLinkPreloaded$ | async) {\n        <valtimo-task-detail-intermediate-save\n          [taskAndProcessLink]=\"taskAndProcessLink$ | async\"\n          (currentIntermediateSaveEvent)=\"onCurrentIntermediateSaveEvent($event)\"\n          (showModalEvent)=\"onShowModalEvent()\"\n        ></valtimo-task-detail-intermediate-save>\n      } @else {\n        <valtimo-task-detail-intermediate-save\n          [task]=\"task$ | async\"\n          (currentIntermediateSaveEvent)=\"onCurrentIntermediateSaveEvent($event)\"\n          (showModalEvent)=\"onShowModalEvent()\"\n        ></valtimo-task-detail-intermediate-save>\n      }\n    </div>\n  </cds-modal-header>\n\n  <div body class=\"cds--modal-content pb-1\">\n    @if (processLinkPreloaded$ | async) {\n      <valtimo-task-detail-content\n        [taskAndProcessLink]=\"taskAndProcessLink$ | async\"\n        [modalClosed]=\"modalCloseEvent$ | async\"\n        (formSubmit)=\"onFormSubmit()\"\n        (closeModalEvent)=\"closeModal()\"\n        (taskUpdated)=\"onTaskUpdated($event)\"\n      ></valtimo-task-detail-content>\n    } @else {\n      <valtimo-task-detail-content\n        [task]=\"task$ | async\"\n        [modalClosed]=\"modalCloseEvent$ | async\"\n        (formSubmit)=\"onFormSubmit()\"\n        (closeModalEvent)=\"closeModal()\"\n        (taskUpdated)=\"onTaskUpdated($event)\"\n      ></valtimo-task-detail-content>\n    }\n  </div>\n</cds-modal>\n\n<valtimo-confirmation-modal\n  [showModalSubject$]=\"showConfirmationModal$\"\n  (confirmEvent)=\"clearCurrentProgress()\"\n  (cancelEvent)=\"showConfirmationModal$.next(false)\"\n  cancelButtonType=\"ghost\"\n  confirmButtonTextTranslationKey=\"interface.confirm\"\n  titleTranslationKey=\"formManagement.intermediateSave.clear\"\n  contentTranslationKey=\"formManagement.intermediateSave.clearConfirm\"\n></valtimo-confirmation-modal>\n\n<ng-template #assignUserToTask>\n  <div\n    *ngIf=\"{\n      task: task$ | async,\n      canAssignUserToTask: canAssignUserToTask$ | async,\n      canModifyTask: canModifyTask$ | async,\n    } as obs\"\n    class=\"task-actions\"\n  >\n    <valtimo-assignment\n      *ngIf=\"obs.task && assignmentOfTaskChanged\"\n      mode=\"task\"\n      [assigneeId]=\"obs.task.assignee\"\n      [assigneeFullName]=\"obs.task.valtimoAssignee?.fullName\"\n      [assignedTeamKey]=\"obs.task.assignedTeam?.key\"\n      [assignedTeamTitle]=\"obs.task.assignedTeam?.title\"\n      [hasPermission]=\"obs.canAssignUserToTask\"\n      [candidateUsers$]=\"candidateUsers$\"\n      [candidateTeams$]=\"candidateTeams$\"\n      (assignmentChangedEvent)=\"onAssignmentChanged($event)\"\n      (unassignedEvent)=\"onUnassigned()\"\n    ></valtimo-assignment>\n\n    <valtimo-set-task-due-date\n      [task]=\"obs.task\"\n      [canModifyTask]=\"obs.canModifyTask\"\n      (dueDateChanged)=\"dueDateChanged.emit()\"\n    ></valtimo-set-task-due-date>\n  </div>\n</ng-template>\n", styles: ["#taskDetailModal .formio-component-submit{text-align:right}#taskDetailModal .cds--modal:not(.is-visible){pointer-events:none}cds-modal-header .cds--modal-header{display:flex;justify-content:space-between}.save-buttons-margin{margin-top:-15px}.task-actions{display:flex;flex-wrap:wrap;width:100%;padding-top:8px;gap:8px}\n/*!\n * Copyright 2015-2025 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"], dependencies: [{ kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i2$1.Modal, selector: "cds-modal, ibm-modal", inputs: ["size", "theme", "ariaLabel", "open", "trigger", "hasScrollingContent"], outputs: ["overlaySelected", "close"] }, { kind: "component", type: i2$1.ModalHeader, selector: "cds-modal-header, ibm-modal-header", inputs: ["theme", "closeLabel", "showCloseButton"], outputs: ["closeSelect"] }, { kind: "directive", type: i2$1.Button, selector: "[cdsButton], [ibmButton]", inputs: ["ibmButton", "cdsButton", "size", "skeleton", "iconOnly", "isExpressive"] }, { kind: "directive", type: i2$1.IconDirective, selector: "[cdsIcon], [ibmIcon]", inputs: ["ibmIcon", "cdsIcon", "size", "title", "ariaLabel", "ariaLabelledBy", "ariaHidden", "isFocusable"] }, { kind: "directive", type: i9.TooltipDirective, selector: "[vTooltip]", inputs: ["vTooltip", "onBottom", "tooltipDisabled"] }, { kind: "component", type: i9.ConfirmationModalComponent, selector: "valtimo-confirmation-modal", inputs: ["titleTranslationKey", "title", "content", "contentTranslationKey", "confirmButtonText", "confirmButtonTextTranslationKey", "confirmButtonType", "showOptionalButton", "optionalButtonText", "optionalButtonTextTranslationKey", "optionalButtonType", "cancelButtonText", "cancelButtonTextTranslationKey", "cancelButtonType", "showModalSubject$", "outputOnConfirm", "outputOnOptional", "spacerAfterCancelButton"], outputs: ["confirmEvent", "optionalEvent", "cancelEvent"] }, { kind: "component", type: i9.AssignmentComponent, selector: "valtimo-assignment", inputs: ["mode", "hasPermission", "assigneeId", "assigneeFullName", "assignedTeamKey", "assignedTeamTitle", "candidateUsers$", "candidateTeams$"], outputs: ["assignmentChangedEvent", "unassignedEvent"] }, { kind: "component", type: TaskDetailContentComponent, selector: "valtimo-task-detail-content", inputs: ["task", "taskAndProcessLink", "modalClosed"], outputs: ["closeModalEvent", "formSubmit", "activeChange", "taskUpdated"] }, { kind: "component", type: TaskDetailIntermediateSaveComponent, selector: "valtimo-task-detail-intermediate-save", inputs: ["task", "taskAndProcessLink"], outputs: ["currentIntermediateSaveEvent", "showModalEvent"] }, { kind: "component", type: SetTaskDueDateComponent, selector: "valtimo-set-task-due-date", inputs: ["canModifyTask", "task"], outputs: ["dueDateChanged"] }, { kind: "directive", type: i9.ValtimoCdsModalDirective, selector: "[valtimoCdsModal]", inputs: ["minContentHeight"] }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }, { kind: "pipe", type: i4$1.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskDetailModalComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'valtimo-task-detail-modal', encapsulation: ViewEncapsulation.None, template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<cds-modal\n  id=\"taskDetailModal\"\n  [size]=\"size$ | async\"\n  [open]=\"modalOpen$ | async\"\n  (close)=\"closeModal()\"\n  valtimoCdsModal\n  [minContentHeight]=\"480\"\n>\n  <cds-modal-header (closeSelect)=\"closeModal()\">\n    <div class=\"title-container\">\n      <p class=\"cds--modal-header__heading cds--type-beta\">{{ (page$ | async)?.title }}</p>\n\n      <p class=\"cds--modal-header__label cds--type-delta\">{{ (page$ | async)?.subtitle }}</p>\n\n      <p\n        class=\"cds--modal-header__label cds--type-delta\"\n        *ngIf=\"currentIntermediateSave$ | async as currentIntermediateSave\"\n      >\n        {{ 'formManagement.intermediateSave.lastSavedBy' | translate }}:\n\n        {{\n          currentIntermediateSave?.editedBy\n            ? currentIntermediateSave?.editedBy\n            : currentIntermediateSave.createdBy\n        }}\n\n        {{ 'formManagement.intermediateSave.on' | translate }}:\n\n        {{\n          currentIntermediateSave?.editedOn\n            ? currentIntermediateSave?.editedOn\n            : currentIntermediateSave.createdOn\n        }}\n      </p>\n\n      <ng-container *ngTemplateOutlet=\"assignUserToTask\"></ng-container>\n    </div>\n\n    <div class=\"save-buttons-margin\">\n      <button\n        *ngIf=\"!(openFromCaseManagement$ | async)\"\n        cdsButton=\"ghost\"\n        iconOnly=\"true\"\n        cdsIcon=\"folder--details--reference\"\n        [vTooltip]=\"'formManagement.navigateToRelatedCase' | translate\"\n        (click)=\"openRelatedCase()\"\n      ></button>\n\n      @if (processLinkPreloaded$ | async) {\n        <valtimo-task-detail-intermediate-save\n          [taskAndProcessLink]=\"taskAndProcessLink$ | async\"\n          (currentIntermediateSaveEvent)=\"onCurrentIntermediateSaveEvent($event)\"\n          (showModalEvent)=\"onShowModalEvent()\"\n        ></valtimo-task-detail-intermediate-save>\n      } @else {\n        <valtimo-task-detail-intermediate-save\n          [task]=\"task$ | async\"\n          (currentIntermediateSaveEvent)=\"onCurrentIntermediateSaveEvent($event)\"\n          (showModalEvent)=\"onShowModalEvent()\"\n        ></valtimo-task-detail-intermediate-save>\n      }\n    </div>\n  </cds-modal-header>\n\n  <div body class=\"cds--modal-content pb-1\">\n    @if (processLinkPreloaded$ | async) {\n      <valtimo-task-detail-content\n        [taskAndProcessLink]=\"taskAndProcessLink$ | async\"\n        [modalClosed]=\"modalCloseEvent$ | async\"\n        (formSubmit)=\"onFormSubmit()\"\n        (closeModalEvent)=\"closeModal()\"\n        (taskUpdated)=\"onTaskUpdated($event)\"\n      ></valtimo-task-detail-content>\n    } @else {\n      <valtimo-task-detail-content\n        [task]=\"task$ | async\"\n        [modalClosed]=\"modalCloseEvent$ | async\"\n        (formSubmit)=\"onFormSubmit()\"\n        (closeModalEvent)=\"closeModal()\"\n        (taskUpdated)=\"onTaskUpdated($event)\"\n      ></valtimo-task-detail-content>\n    }\n  </div>\n</cds-modal>\n\n<valtimo-confirmation-modal\n  [showModalSubject$]=\"showConfirmationModal$\"\n  (confirmEvent)=\"clearCurrentProgress()\"\n  (cancelEvent)=\"showConfirmationModal$.next(false)\"\n  cancelButtonType=\"ghost\"\n  confirmButtonTextTranslationKey=\"interface.confirm\"\n  titleTranslationKey=\"formManagement.intermediateSave.clear\"\n  contentTranslationKey=\"formManagement.intermediateSave.clearConfirm\"\n></valtimo-confirmation-modal>\n\n<ng-template #assignUserToTask>\n  <div\n    *ngIf=\"{\n      task: task$ | async,\n      canAssignUserToTask: canAssignUserToTask$ | async,\n      canModifyTask: canModifyTask$ | async,\n    } as obs\"\n    class=\"task-actions\"\n  >\n    <valtimo-assignment\n      *ngIf=\"obs.task && assignmentOfTaskChanged\"\n      mode=\"task\"\n      [assigneeId]=\"obs.task.assignee\"\n      [assigneeFullName]=\"obs.task.valtimoAssignee?.fullName\"\n      [assignedTeamKey]=\"obs.task.assignedTeam?.key\"\n      [assignedTeamTitle]=\"obs.task.assignedTeam?.title\"\n      [hasPermission]=\"obs.canAssignUserToTask\"\n      [candidateUsers$]=\"candidateUsers$\"\n      [candidateTeams$]=\"candidateTeams$\"\n      (assignmentChangedEvent)=\"onAssignmentChanged($event)\"\n      (unassignedEvent)=\"onUnassigned()\"\n    ></valtimo-assignment>\n\n    <valtimo-set-task-due-date\n      [task]=\"obs.task\"\n      [canModifyTask]=\"obs.canModifyTask\"\n      (dueDateChanged)=\"dueDateChanged.emit()\"\n    ></valtimo-set-task-due-date>\n  </div>\n</ng-template>\n", styles: ["#taskDetailModal .formio-component-submit{text-align:right}#taskDetailModal .cds--modal:not(.is-visible){pointer-events:none}cds-modal-header .cds--modal-header{display:flex;justify-content:space-between}.save-buttons-margin{margin-top:-15px}.task-actions{display:flex;flex-wrap:wrap;width:100%;padding-top:8px;gap:8px}\n/*!\n * Copyright 2015-2025 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"] }]
+        }], ctorParameters: () => [{ type: i1$2.Router }, { type: i4$1.TranslateService }, { type: i3.PermissionService }, { type: i4.NGXLogger }, { type: TaskIntermediateSaveService }, { type: i6$1.SseService }, { type: i0.ChangeDetectorRef }, { type: i2$1.IconService }, { type: i2.DocumentService }, { type: TaskService }, { type: i1$1.GlobalNotificationService }], propDecorators: { _intermediateSaveComponent: [{
+                type: ViewChild,
+                args: [TaskDetailIntermediateSaveComponent]
+            }], formSubmit: [{
+                type: Output
+            }], assignmentOfTaskChanged: [{
+                type: Output
+            }], dueDateChanged: [{
+                type: Output
+            }], modalClosed: [{
+                type: Output
+            }], modalSize: [{
+                type: Input
+            }], openFromCaseManagement: [{
+                type: Input
+            }] } });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const TASK_LIST_NO_SEARCH_RESULTS_MESSAGE = {
+    description: 'task-list.noSearchResultsDescription',
+    isSearchResult: true,
+    title: 'task-list.noSearchResultsTitle',
+};
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+moment.locale(localStorage.getItem('langKey') || '');
+class TaskListComponent {
+    onPopState() {
+        setTimeout(() => {
+            this.setParamsFromQueryParams();
+        });
+    }
+    constructor(configService, documentService, permissionService, router, taskService, taskListService, translateService, taskListColumnService, taskListPaginationService, taskListSortService, taskListSearchService, taskListQueryParamService, pageTitleService, sseService, teamsApiService) {
+        this.configService = configService;
+        this.documentService = documentService;
+        this.permissionService = permissionService;
+        this.router = router;
+        this.taskService = taskService;
+        this.taskListService = taskListService;
+        this.translateService = translateService;
+        this.taskListColumnService = taskListColumnService;
+        this.taskListPaginationService = taskListPaginationService;
+        this.taskListSortService = taskListSortService;
+        this.taskListSearchService = taskListSearchService;
+        this.taskListQueryParamService = taskListQueryParamService;
+        this.pageTitleService = pageTitleService;
+        this.sseService = sseService;
+        this.teamsApiService = teamsApiService;
+        this.ALL_CASES_ID = this.taskListService.ALL_CASES_ID;
+        this.selectedTaskType$ = this.taskListService.selectedTaskType$;
+        this._overrideNoResultsMessage$ = new BehaviorSubject(null);
+        this.noResultsMessage$ = combineLatest([
+            this.selectedTaskType$,
+            this._overrideNoResultsMessage$,
+        ]).pipe(map(([selectedTaskType, overrideNoResultsMessage]) => overrideNoResultsMessage || {
+            title: 'task-list.' + selectedTaskType + '.noResultsTitle',
+            description: 'task-list.' + selectedTaskType + '.noResultsDescription',
+            isSearchResult: false,
+        }));
+        this.fields$ = this.taskListColumnService.fields$.pipe(map((fields) => [
+            {
+                key: 'isOpened',
+                label: '',
+                viewType: ViewType.TEMPLATE,
+                template: this._unreadIndicator,
+                className: 'valtimo-task-list__unread-column',
+            },
+            ...fields,
+        ]));
+        this.loadingTasks$ = new BehaviorSubject(true);
+        this.visibleTabs$ = new BehaviorSubject(null);
+        this._enableLoadingAnimation$ = new BehaviorSubject(true);
+        this.cachedTasks$ = new BehaviorSubject(null);
+        this.paginationForCurrentTaskTypeForList$ = this.taskListPaginationService.paginationForCurrentTaskTypeForList$;
+        this.sortStateForCurrentTaskType$ = this.taskListSortService.sortStateForCurrentTaskType$;
+        this.overrideSortState$ = this.taskListSortService.overrideSortState$;
+        this._reload$ = new BehaviorSubject(true);
+        this.caseDefinitionKey$ = this.taskListService.caseDefinitionKey$;
+        this.tasks$ = combineLatest([
+            this.taskListService.loadingStateForCaseDefinition$,
+            this.selectedTaskType$,
+            this.taskListPaginationService.paginationForCurrentTaskType$,
+            this.taskListSortService.sortStringForCurrentTaskType$,
+            this.caseDefinitionKey$,
+            this._enableLoadingAnimation$,
+            this._reload$,
+            this.taskListSearchService.otherFilters$,
+            this.taskListSortService.overrideSortStateString$,
+        ]).pipe(filter$1(([loadingStateForCaseDefinition]) => loadingStateForCaseDefinition === false), map(([_, selectedTaskType, paginationForSelectedTaskType, sortStringForSelectedTaskType, caseDefinitionKey, enableLoadingAnimation, reload, otherFilters, overrideSortStateString,]) => this.getTaskListParams(paginationForSelectedTaskType, overrideSortStateString || sortStringForSelectedTaskType, selectedTaskType, caseDefinitionKey, enableLoadingAnimation, reload, otherFilters)), distinctUntilChanged$1((previous, current) => isEqual(previous.params, current.params)), tap(params => {
+            if (params.enableLoadingAnimation)
+                this.loadingTasks$.next(true);
+            this.taskListQueryParamService.setTaskListParams(params.params);
+        }), switchMap(({ params }) => combineLatest([
+            this.taskService.queryTasksPageV3(params.selectedTaskType, params.params, params.caseDefinitionKey, params.otherFilters),
+            of(!!params.caseDefinitionKey),
+        ])), switchMap(([tasksResult, isSpecified]) => this.getTaskListPermissionsRequest(tasksResult, isSpecified)), map(([isSpecified, taskResult, canViewTaskPermissions, canViewCasePermissions]) => {
+            this.updateTaskListPaginationAfterResponse(Number(taskResult.totalElements));
+            return this.mapTasksForList(isSpecified, taskResult, canViewTaskPermissions, canViewCasePermissions);
+        }), tap(tasks => {
+            this.cachedTasks$.next(tasks);
+            this.loadingTasks$.next(false);
+            this.disableLoadingAnimation();
+            this.taskListSearchService.otherFilters$.pipe(take(1)).subscribe(otherFilters => {
+                this._overrideNoResultsMessage$.next(otherFilters?.length > 0 ? TASK_LIST_NO_SEARCH_RESULTS_MESSAGE : null);
+            });
+        }));
+        this.loadingCaseListItems$ = new BehaviorSubject(true);
+        this._selectedCaseDefinitionId$ = new BehaviorSubject(this.ALL_CASES_ID);
+        this.caseListItems$ = combineLatest([
+            this.documentService.getAllDefinitions(),
+            this._selectedCaseDefinitionId$,
+            this.translateService.stream('key'),
+        ]).pipe(map(([documentDefinitionRes, selectedCaseDefinitionId]) => [
+            {
+                content: this.translateService.instant('task-list.allCases'),
+                id: this.ALL_CASES_ID,
+                selected: selectedCaseDefinitionId === this.ALL_CASES_ID,
+            },
+            ...documentDefinitionRes.content.map(documentDefinition => ({
+                id: documentDefinition.id.name,
+                content: documentDefinition?.schema?.title,
+                selected: documentDefinition.id.name === selectedCaseDefinitionId,
+            })),
+        ]), tap(() => this.loadingCaseListItems$.next(false)));
+        this.taskListColumnsForCase$ = this.taskListColumnService.taskListColumnsForCase$;
+        this.loadingSearchFields$ = this.taskListSearchService.loadingSearchFields$;
+        this.searchFields$ = this.taskListSearchService.searchFields$;
+        this._DEFAULT_TASK_LIST_TABS = [
+            TaskListTab.MINE,
+            TaskListTab.TEAM,
+            TaskListTab.OPEN,
+            TaskListTab.ALL,
+        ];
+        this.setSearchFieldValuesSubject$ = new BehaviorSubject({});
+        this.clearSearchFieldValuesSubject$ = new Subject();
+        this._subscriptions = new Subscription();
+    }
+    ngOnInit() {
+        this.taskListColumnService.resetTaskListFields();
+        this.setVisibleTabs();
+        this.pageTitleService.disableReset();
+        this.setParamsFromQueryParams();
+        this.openTaskUpdateSseEventSubscription();
+    }
+    openTaskUpdateSseEventSubscription() {
+        this._subscriptions.add(combineLatest([
+            this.sseService.getSseEventObservable('TASK_UPDATE'),
+            this.caseDefinitionKey$,
+        ])
+            .pipe(filter$1(([event, caseDefinitionKey]) => caseDefinitionKey === null || event.caseDefinitionKey === caseDefinitionKey))
+            .subscribe(() => this.reload()));
+    }
+    ngOnDestroy() {
+        this.pageTitleService.enableReset();
+        this._subscriptions.unsubscribe();
+    }
+    paginationClicked(page, type) {
+        this.taskListPaginationService.updateTaskPagination(type, { page: page - 1 });
+    }
+    paginationSet(newSize) {
+        combineLatest([
+            this.taskListPaginationService.paginationForCurrentTaskType$,
+            this.taskListService.selectedTaskType$,
+        ])
+            .pipe(take(1))
+            .subscribe(([pagination, selectedTaskType]) => {
+            this.taskListPaginationService.updateTaskPagination(selectedTaskType, {
+                size: Number(newSize),
+                page: this.taskListPaginationService.getLastAvailablePage(pagination.page, Number(newSize), pagination.collectionSize),
+            });
+        });
+    }
+    tabChange(tab) {
+        this.taskListService.selectedTaskType$.pipe(take(1)).subscribe(selectedTaskType => {
+            if (selectedTaskType !== tab) {
+                this.enableLoadingAnimation();
+                this.taskListService.setSelectedTaskType(tab);
+                this.taskListPaginationService.updateTaskPagination(tab, { page: 0 });
+            }
+        });
+    }
+    openRelatedCase(event, index) {
+        event.stopPropagation();
+        this.cachedTasks$.pipe(take(1)).subscribe(cachedTasks => {
+            const currentTask = cachedTasks && cachedTasks[index];
+            if (currentTask && !currentTask.caseLocked) {
+                const caseDocId = currentTask.caseDocumentId || currentTask.businessKey;
+                this.documentService
+                    .getDocument(caseDocId)
+                    .pipe(take(1))
+                    .subscribe(document => {
+                    this.router.navigate([`/cases/${document.definitionId?.name}/document/${caseDocId}`]);
+                });
+            }
+        });
+    }
+    rowOpenTaskClick(task) {
+        return !task.endTime && !task.locked ? this._taskDetail.openTaskDetails(task) : false;
+    }
+    sortChanged(sortState) {
+        this.taskListSortService.setOverrideSortState(sortState);
+        this.taskListSortService.updateSortState(this.taskListService.selectedTaskType, sortState);
+    }
+    setCaseDefinition(definition) {
+        if (definition.item.id && definition.item.id !== this.taskListService.caseDefinitionKey) {
+            this.taskListSortService.resetOverrideSortState();
+            this.loadingTasks$.next(true);
+            this.taskListService.setCaseDefinitionKey(definition.item.id);
+        }
+    }
+    reload() {
+        this.enableLoadingAnimation();
+        this._reload$.next(!this._reload$.getValue());
+    }
+    search(searchFieldValues) {
+        if (!searchFieldValues)
+            return;
+        this.taskListSearchService.setSearchFieldValues(searchFieldValues);
+    }
+    updateTaskListPaginationAfterResponse(newCollectionSize) {
+        this.taskListPaginationService.paginationForCurrentTaskType$
+            .pipe(take(1))
+            .subscribe(currentPagination => {
+            this.taskListPaginationService.updateTaskPagination(this.taskListService.selectedTaskType, {
+                collectionSize: Number(newCollectionSize),
+                page: this.taskListPaginationService.getLastAvailablePage(currentPagination.page, currentPagination.size, newCollectionSize),
+            });
+        });
+    }
+    setVisibleTabs() {
+        const configuredTabs = this.configService.config?.visibleTaskListTabs || this._DEFAULT_TASK_LIST_TABS;
+        this.teamsApiService.getCurrentUserTeams().subscribe(teams => {
+            const tabs = teams.length > 0
+                ? configuredTabs
+                : configuredTabs.filter(tab => tab !== TaskListTab.TEAM);
+            this.visibleTabs$.next(tabs);
+            this.taskListService.setSelectedTaskType(tabs[0]);
+        });
+    }
+    disableLoadingAnimation() {
+        this._enableLoadingAnimation$.next(false);
+    }
+    enableLoadingAnimation() {
+        this._enableLoadingAnimation$.next(true);
+    }
+    getTaskListParams(paginationForSelectedTaskType, sortStringForSelectedTaskType, selectedTaskType, caseDefinitionKey, enableLoadingAnimation, reload, otherFilters) {
+        const params = {
+            ...paginationForSelectedTaskType,
+            ...(sortStringForSelectedTaskType && { sort: sortStringForSelectedTaskType }),
+        };
+        delete params.collectionSize;
+        return {
+            params: {
+                reload,
+                selectedTaskType,
+                params,
+                ...(caseDefinitionKey &&
+                    caseDefinitionKey !== this.ALL_CASES_ID && { caseDefinitionKey: caseDefinitionKey }),
+                ...(otherFilters && { otherFilters }),
+            },
+            enableLoadingAnimation,
+        };
+    }
+    getTaskListPermissionsRequest(tasksResult, isSpecified) {
+        const taskResults = tasksResult.content;
+        const hasTaskResults = Array.isArray(taskResults) && taskResults.length > 0;
+        return combineLatest([
+            of(isSpecified),
+            of(tasksResult),
+            hasTaskResults
+                ? combineLatest(taskResults.map(task => this.permissionService.requestPermission(CAN_VIEW_TASK_PERMISSION, {
+                    resource: TASK_DETAIL_PERMISSION_RESOURCE.task,
+                    identifier: !isSpecified ? task.id : task.id,
+                })))
+                : of(null),
+            hasTaskResults
+                ? combineLatest(taskResults.map(task => this.permissionService.requestPermission(CAN_VIEW_CASE_PERMISSION, {
+                    resource: TASK_DETAIL_PERMISSION_RESOURCE.jsonSchemaDocument,
+                    identifier: task.caseDocumentId || task.businessKey,
+                })))
+                : of(null),
+        ]);
+    }
+    mapTasksForList(isSpecified, tasks, canViewTaskPermissions, canViewCasePermissions) {
+        const MOMENT_FORMAT = 'DD MMM YYYY HH:mm';
+        if (isSpecified) {
+            return tasks.content.map((specifiedTask, specifiedTaskIndex) => specifiedTask.items.reduce((acc, curr) => ({
+                id: specifiedTask.id,
+                businessKey: specifiedTask.businessKey,
+                caseDocumentId: specifiedTask.caseDocumentId,
+                processInstanceId: specifiedTask.processInstanceId,
+                name: specifiedTask.name,
+                isOpened: specifiedTask.isOpened,
+                ...(moment(specifiedTask.created).isValid() && {
+                    created: moment(specifiedTask.created).format(MOMENT_FORMAT),
+                }),
+                ...(canViewTaskPermissions && { locked: !canViewTaskPermissions[specifiedTaskIndex] }),
+                ...(canViewCasePermissions && {
+                    caseLocked: !canViewCasePermissions[specifiedTaskIndex],
+                }),
+                ...acc,
+                [curr.key]: curr.value,
+            }), {}));
+        }
+        return tasks?.content?.map((task, taskIndex) => {
+            const createdDate = moment(task.created);
+            const dueDate = moment(task.due);
+            const taskCopy = { ...task };
+            if (task.due && dueDate.isValid())
+                taskCopy.due = dueDate.format(MOMENT_FORMAT);
+            if (createdDate.isValid())
+                taskCopy.created = createdDate.format(MOMENT_FORMAT);
+            if (canViewTaskPermissions)
+                taskCopy.locked = !canViewTaskPermissions[taskIndex];
+            if (canViewCasePermissions)
+                taskCopy.caseLocked = !canViewCasePermissions[taskIndex];
+            return taskCopy;
+        });
+    }
+    setParamsFromQueryParams() {
+        const decodedParams = this.taskListQueryParamService.getTaskListQueryParams();
+        if (decodedParams.caseDefinitionKey) {
+            this.taskListService.setCaseDefinitionKey(decodedParams.caseDefinitionKey);
+            this._selectedCaseDefinitionId$.next(decodedParams.caseDefinitionKey);
+        }
+        if (decodedParams.otherFilters?.length > 0) {
+            const searchFieldValues = this.taskListSearchService.mapOtherFilterToSearchValues(decodedParams.otherFilters);
+            this.setSearchFieldValuesSubject$.next(searchFieldValues);
+        }
+        else {
+            this.clearSearchFieldValuesSubject$.next(null);
+        }
+        if (decodedParams.selectedTaskType)
+            this.taskListService.setSelectedTaskType(decodedParams.selectedTaskType);
+        if (decodedParams.params?.sort) {
+            const stateFromSortString = this.taskListSortService.getSortStateFromSortString(decodedParams.params.sort);
+            if (stateFromSortString)
+                this.taskListSortService.setOverrideSortState(stateFromSortString);
+        }
+        if (decodedParams.params)
+            this.taskListPaginationService.updateTaskPagination(this.taskListService.selectedTaskType, decodedParams.params);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListComponent, deps: [{ token: i1$1.ConfigService }, { token: i2.DocumentService }, { token: i3.PermissionService }, { token: i1$2.Router }, { token: TaskService }, { token: TaskListService }, { token: i4$1.TranslateService }, { token: TaskListColumnService }, { token: TaskListPaginationService }, { token: TaskListSortService }, { token: TaskListSearchService }, { token: TaskListQueryParamService }, { token: i9.PageTitleService }, { token: i6$1.SseService }, { token: i11.TeamsApiService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.20", type: TaskListComponent, isStandalone: false, selector: "valtimo-task-list", host: { listeners: { "window:popstate": "onPopState($event)" } }, providers: [
+            TaskListService,
+            TaskListColumnService,
+            TaskListPaginationService,
+            TaskListSortService,
+            TaskListSearchService,
+            TaskListQueryParamService,
+        ], viewQueries: [{ propertyName: "_taskDetail", first: true, predicate: ["taskDetail"], descendants: true }, { propertyName: "_unreadIndicator", first: true, predicate: ["unreadIndicator"], descendants: true, static: true }], ngImport: i0, template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  *ngIf=\"{\n    loading: loadingTasks$ | async,\n    selectedTaskType: selectedTaskType$ | async,\n    tasks: tasks$ | async,\n    fields: fields$ | async,\n    visibleTabs: visibleTabs$ | async,\n    pagination: paginationForCurrentTaskTypeForList$ | async,\n    taskListColumnsForCase: taskListColumnsForCase$ | async,\n    sortState: sortStateForCurrentTaskType$ | async,\n    overrideSortState: overrideSortState$ | async,\n    searchFields: searchFields$ | async,\n    loadingSearchFields: loadingSearchFields$ | async,\n    caseDefinitionKey: caseDefinitionKey$ | async,\n    noResultsMessage: noResultsMessage$ | async,\n  } as obs\"\n  class=\"main-content\"\n>\n  <div class=\"container-fluid\">\n    @if (obs.caseDefinitionKey && obs.caseDefinitionKey !== ALL_CASES_ID) {\n      <ng-container\n        *ngTemplateOutlet=\"\n          searchFields;\n          context: {\n            obs: obs,\n          }\n        \"\n      ></ng-container>\n    }\n\n    <ng-container\n      *ngTemplateOutlet=\"\n        tasksList;\n        context: {\n          obs: obs,\n        }\n      \"\n    ></ng-container>\n\n    <ng-container\n      *ngTemplateOutlet=\"\n        tasksListLoading;\n        context: {\n          obs: obs,\n        }\n      \"\n    ></ng-container>\n\n    <valtimo-task-detail-modal\n      #taskDetail\n      (formSubmit)=\"reload()\"\n      (assignmentOfTaskChanged)=\"reload()\"\n      (dueDateChanged)=\"reload()\"\n      (modalClosed)=\"reload()\"\n    ></valtimo-task-detail-modal>\n  </div>\n</div>\n\n<ng-template #configuredTabs let-selectedTaskType=\"selectedTaskType\" let-visibleTabs=\"visibleTabs\">\n  <cds-tabs *ngIf=\"visibleTabs\" type=\"contained\" class=\"valtimo-carbon-list__tabs\">\n    <cds-tab\n      *ngFor=\"let tab of visibleTabs\"\n      [attr.data-testid]=\"'task-list-tab-' + tab\"\n      [heading]=\"'task-list.' + tab + '.title' | translate\"\n      [active]=\"selectedTaskType === tab\"\n      (selected)=\"tabChange(tab)\"\n    ></cds-tab>\n  </cds-tabs>\n</ng-template>\n\n<ng-template #unreadIndicator let-data=\"data\">\n  <span *ngIf=\"!data.item?.isOpened\" class=\"valtimo-task-list__unread-dot\"></span>\n</ng-template>\n\n<ng-template #caseLink let-data=\"data\">\n  <ng-container *ngIf=\"cachedTasks$ | async as cachedTasks\">\n    <div *ngIf=\"cachedTasks[data.index].caseLocked\">\n      <a\n        class=\"float-left cds--link--disabled\"\n        cdsLink\n        href=\"javascript:void(0)\"\n        ngbTooltip=\"{{ 'task-list.caseLocked' | translate }}\"\n        (click)=\"$event.stopPropagation()\"\n      >\n        {{ 'task-list.goToCase' | translate }}\n      </a>\n    </div>\n    <div *ngIf=\"!cachedTasks[data.index].caseLocked\">\n      <a\n        class=\"float-left cds--link\"\n        cdsLink\n        href=\"javascript:void(0)\"\n        (click)=\"openRelatedCase($event, data.index)\"\n      >\n        {{ 'task-list.goToCase' | translate }}\n      </a>\n    </div>\n  </ng-container>\n</ng-template>\n\n<ng-template #tasksList let-obs=\"obs\">\n  <valtimo-carbon-list\n    *ngIf=\"!obs.loading\"\n    [fields]=\"obs.fields\"\n    [header]=\"false\"\n    [items]=\"obs.tasks\"\n    [lastColumnTemplate]=\"caseLink\"\n    [pagination]=\"obs.pagination\"\n    paginationIdentifier=\"taskList\"\n    lockedTooltipTranslationKey=\"task-list.rowLocked\"\n    [sortState]=\"obs.overrideSortState || obs.sortState\"\n    (paginationClicked)=\"paginationClicked($event, obs.selectedTaskType)\"\n    (paginationSet)=\"paginationSet($event)\"\n    (rowClicked)=\"rowOpenTaskClick($event)\"\n    (sortChanged)=\"sortChanged($event)\"\n  >\n    <div tabs>\n      <ng-container *ngIf=\"obs.visibleTabs\">\n        <ng-container\n          *ngTemplateOutlet=\"\n            configuredTabs;\n            context: {selectedTaskType: obs.selectedTaskType, visibleTabs: obs.visibleTabs}\n          \"\n        ></ng-container>\n      </ng-container>\n    </div>\n\n    <valtimo-no-results\n      [description]=\"obs.noResultsMessage.description | translate\"\n      [title]=\"obs.noResultsMessage.title | translate\"\n    >\n    </valtimo-no-results>\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #tasksListLoading let-obs=\"obs\">\n  <valtimo-carbon-list *ngIf=\"obs.loading\" [loading]=\"true\">\n    <div tabs>\n      <cds-tabs *ngIf=\"!obs.visibleTabs\" type=\"contained\" class=\"valtimo-carbon-list__tabs\">\n        <cds-tab\n          [heading]=\"'task-list.mine.title' | translate\"\n          [active]=\"obs.selectedTaskType === 'mine'\"\n        >\n        </cds-tab>\n\n        <cds-tab\n          [heading]=\"'task-list.open.title' | translate\"\n          [active]=\"obs.selectedTaskType === 'open'\"\n        >\n        </cds-tab>\n\n        <cds-tab\n          [heading]=\"'task-list.all.title' | translate\"\n          [active]=\"obs.selectedTaskType === 'all'\"\n        >\n        </cds-tab>\n      </cds-tabs>\n\n      <cds-tabs *ngIf=\"obs.visibleTabs\" type=\"contained\" class=\"valtimo-carbon-list__tabs\">\n        <cds-tab\n          *ngFor=\"let tab of obs.visibleTabs\"\n          [heading]=\"'task-list.' + tab + '.title' | translate\"\n          [active]=\"obs.selectedTaskType === tab\"\n        ></cds-tab>\n      </cds-tabs>\n    </div>\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #searchFields let-obs=\"obs\">\n  <div class=\"mb-3\">\n    <valtimo-search-fields\n      [searchFields]=\"obs.searchFields\"\n      [inputDisabled]=\"obs.loadingSearchFields\"\n      [caseDefinitionKey]=\"obs.caseDefinitionKey\"\n      [setValuesSubject$]=\"setSearchFieldValuesSubject$\"\n      [clearValuesSubject$]=\"clearSearchFieldValuesSubject$\"\n      (doSearch)=\"search($event)\"\n    >\n    </valtimo-search-fields>\n  </div>\n</ng-template>\n\n<ng-container renderInPageHeader [fullWidth]=\"true\">\n  <ng-template>\n    <cds-dropdown\n      class=\"case-definition-selection\"\n      *ngIf=\"{\n        loadingCaseListItems: loadingCaseListItems$ | async,\n        caseListItems: caseListItems$ | async,\n      } as obs\"\n      [attr.data-testid]=\"'task-list-case-dropdown'\"\n      [disabled]=\"obs.loadingCaseListItems || (obs.caseListItems || []).length === 1\"\n      [skeleton]=\"obs.loadingCaseListItems\"\n      (selected)=\"setCaseDefinition($event)\"\n    >\n      <cds-dropdown-list [items]=\"obs.caseListItems || []\"></cds-dropdown-list>\n    </cds-dropdown>\n  </ng-template>\n</ng-container>\n", styles: [".cds--link--disabled{cursor:not-allowed;pointer-events:auto!important;outline:0!important}.case-definition-selection{display:flex;width:250px}.valtimo-task-list__unread-dot{display:inline-block;width:8px;height:8px;border-radius:50%;background-color:var(--cds-link-primary)}::ng-deep .valtimo-task-list__unread-column{width:2rem;padding-right:0!important}\n/*!\n * Copyright 2015-2025 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"], dependencies: [{ kind: "directive", type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i9.CarbonListComponent, selector: "valtimo-carbon-list", inputs: ["items", "fields", "tableTranslations", "paginatorConfig", "pagination", "loading", "skeletonRowCount", "actions", "actionItems", "showActionItems", "header", "hideColumnHeader", "initialSortState", "sortState", "isSearchable", "enableSingleSelection", "lastColumnTemplate", "paginationIdentifier", "showSelectionColumn", "striped", "hideToolbar", "lockedTooltipTranslationKey", "movingRowsEnabled", "dragAndDrop", "dragAndDropDisabled"], outputs: ["rowClicked", "paginationClicked", "paginationSet", "search", "sortChanged", "moveRow", "itemsReordered"] }, { kind: "component", type: i9.CarbonNoResultsComponent, selector: "valtimo-no-results", inputs: ["action", "description", "illustration", "title", "smallPadding", "collapseVertically", "alwaysRenderVertically"] }, { kind: "directive", type: i13.NgbTooltip, selector: "[ngbTooltip]", inputs: ["animation", "autoClose", "placement", "triggers", "container", "disableTooltip", "tooltipClass", "openDelay", "closeDelay", "ngbTooltip"], outputs: ["shown", "hidden"], exportAs: ["ngbTooltip"] }, { kind: "directive", type: i2$1.Link, selector: "[cdsLink], [ibmLink]", inputs: ["inline", "disabled"] }, { kind: "component", type: i2$1.Tabs, selector: "cds-tabs, ibm-tabs", inputs: ["position", "cacheActive", "followFocus", "isNavigation", "ariaLabel", "ariaLabelledby", "type", "theme", "skeleton"] }, { kind: "component", type: i2$1.Tab, selector: "cds-tab, ibm-tab", inputs: ["heading", "title", "context", "active", "disabled", "tabIndex", "id", "cacheActive", "tabContent", "templateContext"], outputs: ["selected"] }, { kind: "directive", type: i9.RenderInPageHeaderDirective, selector: "[renderInPageHeader]", inputs: ["fullWidth"] }, { kind: "component", type: i2$1.Dropdown, selector: "cds-dropdown, ibm-dropdown", inputs: ["id", "label", "hideLabel", "helperText", "placeholder", "displayValue", "clearText", "size", "type", "theme", "disabled", "readonly", "skeleton", "inline", "disableArrowKeys", "invalid", "invalidText", "warn", "warnText", "appendInline", "scrollableContainer", "itemValueKey", "selectionFeedback", "menuButtonLabel", "selectedLabel", "dropUp", "fluid"], outputs: ["selected", "onClose", "close"] }, { kind: "component", type: i2$1.DropdownList, selector: "cds-dropdown-list, ibm-dropdown-list", inputs: ["ariaLabel", "items", "listTpl", "type", "showTitles"], outputs: ["select", "scroll", "blurIntent"] }, { kind: "component", type: i9.SearchFieldsComponent, selector: "valtimo-search-fields", inputs: ["loading", "searchFields", "caseDefinitionKey", "setValuesSubject$", "clearValuesSubject$", "defaultValues", "disableSaveSearch", "inputDisabled", "externalSearchField", "canSaveSearch"], outputs: ["doSearch", "saveSearchEvent", "clearEvent"] }, { kind: "component", type: TaskDetailModalComponent, selector: "valtimo-task-detail-modal", inputs: ["modalSize", "openFromCaseManagement"], outputs: ["formSubmit", "assignmentOfTaskChanged", "dueDateChanged", "modalClosed"] }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }, { kind: "pipe", type: i4$1.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskListComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'valtimo-task-list', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        TaskListService,
+                        TaskListColumnService,
+                        TaskListPaginationService,
+                        TaskListSortService,
+                        TaskListSearchService,
+                        TaskListQueryParamService,
+                    ], template: "<!--\n  ~ Copyright 2015-2025 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  *ngIf=\"{\n    loading: loadingTasks$ | async,\n    selectedTaskType: selectedTaskType$ | async,\n    tasks: tasks$ | async,\n    fields: fields$ | async,\n    visibleTabs: visibleTabs$ | async,\n    pagination: paginationForCurrentTaskTypeForList$ | async,\n    taskListColumnsForCase: taskListColumnsForCase$ | async,\n    sortState: sortStateForCurrentTaskType$ | async,\n    overrideSortState: overrideSortState$ | async,\n    searchFields: searchFields$ | async,\n    loadingSearchFields: loadingSearchFields$ | async,\n    caseDefinitionKey: caseDefinitionKey$ | async,\n    noResultsMessage: noResultsMessage$ | async,\n  } as obs\"\n  class=\"main-content\"\n>\n  <div class=\"container-fluid\">\n    @if (obs.caseDefinitionKey && obs.caseDefinitionKey !== ALL_CASES_ID) {\n      <ng-container\n        *ngTemplateOutlet=\"\n          searchFields;\n          context: {\n            obs: obs,\n          }\n        \"\n      ></ng-container>\n    }\n\n    <ng-container\n      *ngTemplateOutlet=\"\n        tasksList;\n        context: {\n          obs: obs,\n        }\n      \"\n    ></ng-container>\n\n    <ng-container\n      *ngTemplateOutlet=\"\n        tasksListLoading;\n        context: {\n          obs: obs,\n        }\n      \"\n    ></ng-container>\n\n    <valtimo-task-detail-modal\n      #taskDetail\n      (formSubmit)=\"reload()\"\n      (assignmentOfTaskChanged)=\"reload()\"\n      (dueDateChanged)=\"reload()\"\n      (modalClosed)=\"reload()\"\n    ></valtimo-task-detail-modal>\n  </div>\n</div>\n\n<ng-template #configuredTabs let-selectedTaskType=\"selectedTaskType\" let-visibleTabs=\"visibleTabs\">\n  <cds-tabs *ngIf=\"visibleTabs\" type=\"contained\" class=\"valtimo-carbon-list__tabs\">\n    <cds-tab\n      *ngFor=\"let tab of visibleTabs\"\n      [attr.data-testid]=\"'task-list-tab-' + tab\"\n      [heading]=\"'task-list.' + tab + '.title' | translate\"\n      [active]=\"selectedTaskType === tab\"\n      (selected)=\"tabChange(tab)\"\n    ></cds-tab>\n  </cds-tabs>\n</ng-template>\n\n<ng-template #unreadIndicator let-data=\"data\">\n  <span *ngIf=\"!data.item?.isOpened\" class=\"valtimo-task-list__unread-dot\"></span>\n</ng-template>\n\n<ng-template #caseLink let-data=\"data\">\n  <ng-container *ngIf=\"cachedTasks$ | async as cachedTasks\">\n    <div *ngIf=\"cachedTasks[data.index].caseLocked\">\n      <a\n        class=\"float-left cds--link--disabled\"\n        cdsLink\n        href=\"javascript:void(0)\"\n        ngbTooltip=\"{{ 'task-list.caseLocked' | translate }}\"\n        (click)=\"$event.stopPropagation()\"\n      >\n        {{ 'task-list.goToCase' | translate }}\n      </a>\n    </div>\n    <div *ngIf=\"!cachedTasks[data.index].caseLocked\">\n      <a\n        class=\"float-left cds--link\"\n        cdsLink\n        href=\"javascript:void(0)\"\n        (click)=\"openRelatedCase($event, data.index)\"\n      >\n        {{ 'task-list.goToCase' | translate }}\n      </a>\n    </div>\n  </ng-container>\n</ng-template>\n\n<ng-template #tasksList let-obs=\"obs\">\n  <valtimo-carbon-list\n    *ngIf=\"!obs.loading\"\n    [fields]=\"obs.fields\"\n    [header]=\"false\"\n    [items]=\"obs.tasks\"\n    [lastColumnTemplate]=\"caseLink\"\n    [pagination]=\"obs.pagination\"\n    paginationIdentifier=\"taskList\"\n    lockedTooltipTranslationKey=\"task-list.rowLocked\"\n    [sortState]=\"obs.overrideSortState || obs.sortState\"\n    (paginationClicked)=\"paginationClicked($event, obs.selectedTaskType)\"\n    (paginationSet)=\"paginationSet($event)\"\n    (rowClicked)=\"rowOpenTaskClick($event)\"\n    (sortChanged)=\"sortChanged($event)\"\n  >\n    <div tabs>\n      <ng-container *ngIf=\"obs.visibleTabs\">\n        <ng-container\n          *ngTemplateOutlet=\"\n            configuredTabs;\n            context: {selectedTaskType: obs.selectedTaskType, visibleTabs: obs.visibleTabs}\n          \"\n        ></ng-container>\n      </ng-container>\n    </div>\n\n    <valtimo-no-results\n      [description]=\"obs.noResultsMessage.description | translate\"\n      [title]=\"obs.noResultsMessage.title | translate\"\n    >\n    </valtimo-no-results>\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #tasksListLoading let-obs=\"obs\">\n  <valtimo-carbon-list *ngIf=\"obs.loading\" [loading]=\"true\">\n    <div tabs>\n      <cds-tabs *ngIf=\"!obs.visibleTabs\" type=\"contained\" class=\"valtimo-carbon-list__tabs\">\n        <cds-tab\n          [heading]=\"'task-list.mine.title' | translate\"\n          [active]=\"obs.selectedTaskType === 'mine'\"\n        >\n        </cds-tab>\n\n        <cds-tab\n          [heading]=\"'task-list.open.title' | translate\"\n          [active]=\"obs.selectedTaskType === 'open'\"\n        >\n        </cds-tab>\n\n        <cds-tab\n          [heading]=\"'task-list.all.title' | translate\"\n          [active]=\"obs.selectedTaskType === 'all'\"\n        >\n        </cds-tab>\n      </cds-tabs>\n\n      <cds-tabs *ngIf=\"obs.visibleTabs\" type=\"contained\" class=\"valtimo-carbon-list__tabs\">\n        <cds-tab\n          *ngFor=\"let tab of obs.visibleTabs\"\n          [heading]=\"'task-list.' + tab + '.title' | translate\"\n          [active]=\"obs.selectedTaskType === tab\"\n        ></cds-tab>\n      </cds-tabs>\n    </div>\n  </valtimo-carbon-list>\n</ng-template>\n\n<ng-template #searchFields let-obs=\"obs\">\n  <div class=\"mb-3\">\n    <valtimo-search-fields\n      [searchFields]=\"obs.searchFields\"\n      [inputDisabled]=\"obs.loadingSearchFields\"\n      [caseDefinitionKey]=\"obs.caseDefinitionKey\"\n      [setValuesSubject$]=\"setSearchFieldValuesSubject$\"\n      [clearValuesSubject$]=\"clearSearchFieldValuesSubject$\"\n      (doSearch)=\"search($event)\"\n    >\n    </valtimo-search-fields>\n  </div>\n</ng-template>\n\n<ng-container renderInPageHeader [fullWidth]=\"true\">\n  <ng-template>\n    <cds-dropdown\n      class=\"case-definition-selection\"\n      *ngIf=\"{\n        loadingCaseListItems: loadingCaseListItems$ | async,\n        caseListItems: caseListItems$ | async,\n      } as obs\"\n      [attr.data-testid]=\"'task-list-case-dropdown'\"\n      [disabled]=\"obs.loadingCaseListItems || (obs.caseListItems || []).length === 1\"\n      [skeleton]=\"obs.loadingCaseListItems\"\n      (selected)=\"setCaseDefinition($event)\"\n    >\n      <cds-dropdown-list [items]=\"obs.caseListItems || []\"></cds-dropdown-list>\n    </cds-dropdown>\n  </ng-template>\n</ng-container>\n", styles: [".cds--link--disabled{cursor:not-allowed;pointer-events:auto!important;outline:0!important}.case-definition-selection{display:flex;width:250px}.valtimo-task-list__unread-dot{display:inline-block;width:8px;height:8px;border-radius:50%;background-color:var(--cds-link-primary)}::ng-deep .valtimo-task-list__unread-column{width:2rem;padding-right:0!important}\n/*!\n * Copyright 2015-2025 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"] }]
+        }], ctorParameters: () => [{ type: i1$1.ConfigService }, { type: i2.DocumentService }, { type: i3.PermissionService }, { type: i1$2.Router }, { type: TaskService }, { type: TaskListService }, { type: i4$1.TranslateService }, { type: TaskListColumnService }, { type: TaskListPaginationService }, { type: TaskListSortService }, { type: TaskListSearchService }, { type: TaskListQueryParamService }, { type: i9.PageTitleService }, { type: i6$1.SseService }, { type: i11.TeamsApiService }], propDecorators: { _taskDetail: [{
+                type: ViewChild,
+                args: ['taskDetail']
+            }], _unreadIndicator: [{
+                type: ViewChild,
+                args: ['unreadIndicator', { static: true }]
+            }], onPopState: [{
+                type: HostListener,
+                args: ['window:popstate', ['$event']]
+            }] } });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var TaskListColumnDefaultSort;
+(function (TaskListColumnDefaultSort) {
+    TaskListColumnDefaultSort["ASC"] = "ASC";
+    TaskListColumnDefaultSort["DESC"] = "DESC";
+})(TaskListColumnDefaultSort || (TaskListColumnDefaultSort = {}));
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var TaskListSearchFieldDataType;
+(function (TaskListSearchFieldDataType) {
+    TaskListSearchFieldDataType["TEXT"] = "text";
+    TaskListSearchFieldDataType["NUMBER"] = "number";
+    TaskListSearchFieldDataType["DATE"] = "date";
+    TaskListSearchFieldDataType["DATETIME"] = "datetime";
+    TaskListSearchFieldDataType["TIME"] = "time";
+    TaskListSearchFieldDataType["BOOLEAN"] = "boolean";
+})(TaskListSearchFieldDataType || (TaskListSearchFieldDataType = {}));
+var TaskListSearchFieldFieldType;
+(function (TaskListSearchFieldFieldType) {
+    TaskListSearchFieldFieldType["SINGLE"] = "single";
+    TaskListSearchFieldFieldType["RANGE"] = "range";
+    TaskListSearchFieldFieldType["SINGLE_SELECT_DROPDOWN"] = "single_select_dropdown";
+    TaskListSearchFieldFieldType["MULTI_SELECT_DROPDOWN"] = "multi_select_dropdown";
+})(TaskListSearchFieldFieldType || (TaskListSearchFieldFieldType = {}));
+var TaskListSearchFieldMatchType;
+(function (TaskListSearchFieldMatchType) {
+    TaskListSearchFieldMatchType["LIKE"] = "like";
+    TaskListSearchFieldMatchType["EXACT"] = "exact";
+})(TaskListSearchFieldMatchType || (TaskListSearchFieldMatchType = {}));
+var TaskListSearchDropdownDataProvider;
+(function (TaskListSearchDropdownDataProvider) {
+    TaskListSearchDropdownDataProvider["DATABASE"] = "dropdownDatabaseDataProvider";
+    TaskListSearchDropdownDataProvider["JSON"] = "dropdownJsonFileDataProvider";
+})(TaskListSearchDropdownDataProvider || (TaskListSearchDropdownDataProvider = {}));
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const routes = [
+    {
+        path: 'tasks',
+        component: TaskListComponent,
+        canActivate: [AuthGuardService],
+        data: { title: 'Tasks', roles: [ROLE_USER] },
+    },
+];
+class TaskRoutingModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.20", ngImport: i0, type: TaskRoutingModule, imports: [CommonModule, i1$2.RouterModule], exports: [RouterModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskRoutingModule, imports: [CommonModule, RouterModule.forChild(routes), RouterModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule, RouterModule.forChild(routes)],
+                    exports: [RouterModule],
+                }]
+        }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TaskModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.20", ngImport: i0, type: TaskModule, declarations: [TaskListComponent, TaskDetailModalComponent], imports: [CommonModule,
+            TaskRoutingModule,
+            CarbonListModule,
+            PageHeaderModule,
+            WidgetModule,
+            SpinnerModule,
+            CamundaFormModule,
+            BrowserAnimationsModule,
+            FormsModule, i4$1.TranslateModule, NgbModule,
+            FormIoModule,
+            ModalModule,
+            LinkModule,
+            ProcessLinkModule,
+            TabsModule,
+            ContentSwitcherModule,
+            RenderInPageHeaderDirective,
+            DropdownModule,
+            ButtonModule,
+            IconModule,
+            TooltipModule$1,
+            TooltipModule,
+            ConfirmationModalModule,
+            SearchFieldsModule,
+            AssignmentComponent,
+            TaskDetailContentComponent,
+            TaskDetailIntermediateSaveComponent,
+            SetTaskDueDateComponent,
+            ValtimoCdsModalDirective], exports: [TaskListComponent, TaskDetailModalComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskModule, imports: [CommonModule,
+            TaskRoutingModule,
+            CarbonListModule,
+            PageHeaderModule,
+            WidgetModule,
+            SpinnerModule,
+            CamundaFormModule,
+            BrowserAnimationsModule,
+            FormsModule,
+            TranslateModule.forRoot({
+                loader: {
+                    provide: TranslateLoader,
+                    useFactory: HttpLoaderFactory,
+                    deps: [HttpClient],
+                },
+            }),
+            NgbModule,
+            FormIoModule,
+            ModalModule,
+            LinkModule,
+            ProcessLinkModule,
+            TabsModule,
+            ContentSwitcherModule,
+            DropdownModule,
+            ButtonModule,
+            IconModule,
+            TooltipModule$1,
+            TooltipModule,
+            ConfirmationModalModule,
+            SearchFieldsModule,
+            AssignmentComponent,
+            TaskDetailContentComponent,
+            TaskDetailIntermediateSaveComponent,
+            SetTaskDueDateComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: TaskModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [TaskListComponent, TaskDetailModalComponent],
+                    imports: [
+                        CommonModule,
+                        TaskRoutingModule,
+                        CarbonListModule,
+                        PageHeaderModule,
+                        WidgetModule,
+                        SpinnerModule,
+                        CamundaFormModule,
+                        BrowserAnimationsModule,
+                        FormsModule,
+                        TranslateModule.forRoot({
+                            loader: {
+                                provide: TranslateLoader,
+                                useFactory: HttpLoaderFactory,
+                                deps: [HttpClient],
+                            },
+                        }),
+                        NgbModule,
+                        FormIoModule,
+                        ModalModule,
+                        LinkModule,
+                        ProcessLinkModule,
+                        TabsModule,
+                        ContentSwitcherModule,
+                        RenderInPageHeaderDirective,
+                        DropdownModule,
+                        ButtonModule,
+                        IconModule,
+                        TooltipModule$1,
+                        TooltipModule,
+                        ConfirmationModalModule,
+                        SearchFieldsModule,
+                        AssignmentComponent,
+                        TaskDetailContentComponent,
+                        TaskDetailIntermediateSaveComponent,
+                        SetTaskDueDateComponent,
+                        ValtimoCdsModalDirective,
+                    ],
+                    exports: [TaskListComponent, TaskDetailModalComponent],
+                }]
+        }] });
+
+/*
+ * Copyright 2015-2025 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Public API Surface of task
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CAN_ASSIGN_TASK_PERMISSION, CAN_MODIFY_TASK_PERMISSION, CAN_VIEW_CASE_PERMISSION, CAN_VIEW_TASK_PERMISSION, SetTaskDueDateComponent, TASK_DETAIL_PERMISSION_RESOURCE, TASK_LIST_NO_SEARCH_RESULTS_MESSAGE, TaskDetailContentComponent, TaskDetailIntermediateSaveComponent, TaskDetailModalComponent, TaskIntermediateSaveService, TaskListColumnDefaultSort, TaskListColumnService, TaskListComponent, TaskListPaginationService, TaskListQueryParamService, TaskListSearchDropdownDataProvider, TaskListSearchFieldDataType, TaskListSearchFieldFieldType, TaskListSearchFieldMatchType, TaskListSearchService, TaskListService, TaskModule, TaskService };
+//# sourceMappingURL=valtimo-task.mjs.map