@acorex-platform/module-workflow-management-client 0.0.21

package/types/acorex-platform-module-workflow-management-client.d.ts

@@ -0,0 +1,1026 @@
+import { AXPMenuProvider, AXPMenuProviderContext } from '@acorex-platform/framework-client/common';
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, Injector } from '@angular/core';
+import * as i1 from '@acorex-platform/module-calendar-management-client';
+import * as i2 from '@acorex-platform/framework-client/domain';
+import * as i4 from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPActivityCategory, AXPWidgetNode, AXPActionMenuItem, AXPActivityDefinition, AXPMultiLanguageString, AXPExecuteCommand } from '@acorex-platform/framework-shared/core';
+import { AXPActivityCategoryProvider, AXPActivityProvider, AXPWorkflowContinuationStepContext, AXPWorkflowTask, AXPWorkflowContinuationHook, AXPWorkflowContinuationOfferResult, WorkflowResumeResult } from '@acorex-platform/framework-client/workflow';
+import { AXPCommand, AXPCommandExecuteResultPromise } from '@acorex-platform/framework-shared/runtime';
+import { AXStyleColorType } from '@acorex/cdk/common';
+import { AXPopupSizeType } from '@acorex/components/popup';
+import { AXPWorkflowTaskProvider, AXPTaskFilter, AXPTask, AXPTaskActionMenuItem, AXPExtraField, AXPTaskStatus, AXPTaskPopoverMetadata, AXPTaskPopoverComponent, AXPWorkflowTaskProviderResolveOptions } from '@acorex-platform/module-task-management-client';
+import { AXPSessionService } from '@acorex-platform/framework-client/auth';
+import { AXMWorkflowManagementWorkflowInstanceEntityModel } from '@acorex-platform/module-workflow-management-client/contracts';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+
+declare class AXMMenuProvider implements AXPMenuProvider {
+    private entityService;
+    private sessionService;
+    provide(context: AXPMenuProviderContext): Promise<void>;
+}
+
+/**
+ * Registers workflow-management entity plugins:
+ * - workflow-run: workflow-capable entities and workflow-run list actions
+ * - workflow-selector: workflow definition + template input configurator
+ * - automation: related WorkflowManagement.Automation entity
+ */
+declare class AXMWorkflowPluginsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMWorkflowPluginsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMWorkflowPluginsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXMWorkflowPluginsModule>;
+}
+
+declare class AXMWorkflowManagementModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMWorkflowManagementModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMWorkflowManagementModule, never, [typeof i1.AXMCalendarManagementModule, typeof i2.AXPDomainModule, typeof AXMWorkflowPluginsModule, typeof i4.AXPWidgetCoreModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXMWorkflowManagementModule>;
+}
+
+/**
+ * Provider for activity categories.
+ * Reads categories from entity service (mock data).
+ */
+declare class AXCCategoryProvider implements AXPActivityCategoryProvider {
+    private readonly entityService;
+    /** Category entity is provided by category plugin (ActivityDefinition → ActivityDefinitionCategory). */
+    private categoryService;
+    getList(parentId?: string): Promise<AXPActivityCategory[]>;
+    getById(id: string): Promise<AXPActivityCategory | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCCategoryProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXCCategoryProvider>;
+}
+
+/**
+ * Input for ShowConfirmPopup activity.
+ */
+interface ShowConfirmPopupInput {
+    /**
+     * Title of the confirmation dialog
+     */
+    title: string;
+    /**
+     * Message/content of the confirmation dialog
+     */
+    message: string;
+    /**
+     * Dialog type/color (e.g., 'warning', 'danger', 'info', 'success')
+     */
+    type?: AXStyleColorType;
+    /**
+     * Button layout direction ('horizontal' or 'vertical')
+     */
+    direction?: 'horizontal' | 'vertical';
+    /**
+     * Whether dialog is closable
+     */
+    closable?: boolean;
+    /**
+     * Default action button ('confirm' or 'cancel')
+     */
+    defaultAction?: 'confirm' | 'cancel';
+}
+/**
+ * Output for ShowConfirmPopup activity.
+ * Outcome is determined by the outcomes object (ok or cancel).
+ */
+interface ShowConfirmPopupOutput {
+}
+/**
+ * ShowConfirmPopup Activity (Frontend)
+ *
+ * Shows a confirmation popup dialog with OK and Cancel buttons.
+ * This activity runs on the frontend and requires user interaction.
+ *
+ * Execution Mode: frontend
+ * Activity Type: workflow-activity:show-confirm-popup
+ *
+ * Outcomes:
+ * - ok: User clicked OK button
+ * - cancel: User clicked Cancel button or closed the dialog
+ */
+declare class ShowConfirmPopupActivity implements AXPCommand<ShowConfirmPopupInput, ShowConfirmPopupOutput> {
+    private readonly dialogService;
+    private readonly translationService;
+    execute(input: ShowConfirmPopupInput): AXPCommandExecuteResultPromise<ShowConfirmPopupOutput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowConfirmPopupActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowConfirmPopupActivity>;
+}
+
+/**
+ * Input for ShowLayoutPopup activity.
+ */
+interface ShowLayoutPopupInput {
+    /**
+     * Layout definition as JSON string or AXPWidgetNode object
+     */
+    layout: string | AXPWidgetNode;
+    /**
+     * Dialog title
+     */
+    title?: string;
+    /**
+     * Dialog size
+     */
+    size?: AXPopupSizeType;
+    /**
+     * Whether to show close button
+     */
+    closeButton?: boolean;
+    /**
+     * Initial context data for the form
+     */
+    context?: Record<string, any>;
+    /**
+     * Dialog actions (buttons) to display in footer
+     * Each action will create a corresponding outcome
+     */
+    actions?: {
+        prefix?: AXPActionMenuItem[];
+        suffix?: AXPActionMenuItem[];
+    };
+}
+/**
+ * ShowLayoutPopup Activity (Frontend)
+ *
+ * Shows a popup dialog with a custom layout built using layout builder.
+ * The layout can be provided as JSON string or AXPWidgetNode object.
+ *
+ * Execution Mode: frontend
+ * Activity Type: workflow-activity:show-layout-popup
+ *
+ * Outcomes:
+ * Outcomes are dynamically generated based on the actions provided in the input.
+ * Each action creates a corresponding outcome with the action name (from command.name or action.name).
+ * If no actions are provided, default actions (cancel, submit) are used.
+ *
+ * Examples:
+ * - If action has command.name = 'save', outcome will be { save: true }
+ * - If action has name = 'delete', outcome will be { delete: true }
+ * - Default outcomes: { cancel: true } or { submit: true }
+ */
+declare class ShowLayoutPopupActivity implements AXPCommand<ShowLayoutPopupInput, Record<string, any>> {
+    private readonly popupService;
+    execute(input: ShowLayoutPopupInput): AXPCommandExecuteResultPromise<Record<string, any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowLayoutPopupActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowLayoutPopupActivity>;
+}
+
+/**
+ * Input for Human Task activity.
+ */
+interface HumanTaskInput {
+    /**
+     * Task title
+     */
+    title?: string;
+    /**
+     * Task description
+     */
+    description?: string;
+    /**
+     * Assigned user IDs (direct assignment)
+     */
+    assignedUserIds?: string[];
+    /**
+     * Candidate user IDs (users who can claim the task)
+     */
+    candidateUserIds?: string[];
+    /**
+     * Candidate role IDs (roles whose members can claim the task)
+     */
+    candidateRoleIds?: string[];
+    /**
+     * Task priority
+     */
+    priority?: 'Low' | 'Normal' | 'High' | 'Urgent';
+    /**
+     * Task due date (ISO date string or Date)
+     */
+    dueDate?: string | Date;
+    /**
+     * Initial context data for the form
+     */
+    context?: Record<string, any>;
+    /**
+     * Actions (buttons) for this task. Format: { prefix?: Array<Action>, suffix?: Array<Action> } (or JSON string).
+     * Each action name becomes an outcome when the task is completed.
+     */
+    actions?: {
+        prefix?: Array<{
+            name?: string;
+            command?: {
+                name?: string;
+            };
+        }>;
+        suffix?: Array<{
+            name?: string;
+            command?: {
+                name?: string;
+            };
+        }>;
+    } | string;
+}
+/**
+ * Output for Human Task activity.
+ */
+interface HumanTaskOutput {
+    /**
+     * Result data from task completion (form values)
+     */
+    result: Record<string, any>;
+    /**
+     * Action that was clicked (e.g., 'approve', 'reject', 'cancel')
+     */
+    action: string;
+}
+/**
+ * Human Task Activity (Frontend)
+ *
+ * Generic human task activity that suspends workflow and waits for user interaction.
+ * Supports assignment and actions (displayed inline). For dialog-style flow, use a follow-up activity.
+ *
+ * Execution Mode: frontend
+ * Task Type: human-task
+ * Activity Type: workflow-activity:human-task
+ *
+ * Outcomes:
+ * Outcomes are dynamically generated based on the actions provided in the input.
+ * Each action creates a corresponding outcome with the action name (from command.name or action.name).
+ * If no actions are provided, default actions (cancel, submit) are used.
+ *
+ * Examples:
+ * - If action has command.name = 'approve', outcome will be { approve: true }
+ * - If action has name = 'reject', outcome will be { reject: true }
+ * - Default outcomes: { cancel: true } or { submit: true }
+ *
+ * Assignment:
+ * - assignedUserIds: Direct assignment to specific users
+ * - candidateUserIds: Users who can claim the task
+ * - candidateRoleIds: Roles whose members can claim the task
+ *
+ * Display Modes:
+ * - 'dialog': Traditional modal dialog (default)
+ * - 'inline': Actions displayed directly on page before resume
+ */
+declare class HumanTaskActivity implements AXPCommand<HumanTaskInput, HumanTaskOutput> {
+    /**
+     * Execute human task activity.
+     *
+     * This method doesn't actually show UI - it just validates input and returns success.
+     * The workflow engine will suspend at this activity and create a bookmark.
+     * The Generic Task Provider will handle displaying the task UI inline.
+     */
+    execute(input: HumanTaskInput): AXPCommandExecuteResultPromise<HumanTaskOutput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HumanTaskActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HumanTaskActivity>;
+}
+
+/**
+ * Input for Cartable (pooled) task activity.
+ * Does not use direct assignment: only candidates may claim the task on the task board.
+ */
+interface CartableTaskInput {
+    title?: string;
+    description?: string;
+    candidateUserIds?: string[];
+    candidateRoleIds?: string[];
+    priority?: 'Low' | 'Normal' | 'High' | 'Urgent';
+    dueDate?: string | Date;
+    context?: Record<string, any>;
+    actions?: {
+        prefix?: Array<{
+            name?: string;
+            command?: {
+                name?: string;
+            };
+        }>;
+        suffix?: Array<{
+            name?: string;
+            command?: {
+                name?: string;
+            };
+        }>;
+    } | string;
+}
+interface CartableTaskOutput {
+    result: Record<string, any>;
+    action: string;
+}
+/**
+ * Cartable task activity (frontend): suspends workflow with candidate users only.
+ * Assignee is set when a candidate claims the task on the task board (bookmark update).
+ *
+ * Activity Type: workflow-activity:cartable
+ */
+declare class CartableTaskActivity implements AXPCommand<CartableTaskInput, CartableTaskOutput> {
+    execute(input: CartableTaskInput): AXPCommandExecuteResultPromise<CartableTaskOutput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CartableTaskActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CartableTaskActivity>;
+}
+
+/**
+ * Input for ShowToast activity.
+ */
+interface ShowToastInput {
+    /**
+     * Message/content of the toast
+     */
+    message: string;
+    /**
+     * Toast type/color (e.g., 'success', 'danger', 'info', 'warning')
+     */
+    type?: AXStyleColorType;
+    /**
+     * Toast title (optional)
+     */
+    title?: string;
+    /**
+     * Whether to show close button
+     */
+    closeButton?: boolean;
+    /**
+     * Timeout in milliseconds (0 = no timeout)
+     */
+    timeOut?: number;
+    /**
+     * Whether to show timeout progress
+     */
+    timeOutProgress?: boolean;
+}
+/**
+ * Wrapper used when {@link ShowToastActivity} is invoked from entity/command dispatchers
+ * (`options` mirrors toolbar `command.options`).
+ */
+interface ShowToastEntityCommandEnvelope {
+    options?: ShowToastInput;
+}
+/** Plain toast fields or entity-toolbar envelope — both are supported. */
+type ShowToastCommandInput = ShowToastInput | ShowToastEntityCommandEnvelope;
+/**
+ * Output for ShowToast activity.
+ */
+interface ShowToastOutput {
+}
+/**
+ * ShowToast Activity (Frontend)
+ *
+ * Shows a toast notification message to the user.
+ * This activity runs on the frontend and displays a temporary notification.
+ *
+ * Execution Mode: frontend
+ * Activity Type: workflow-activity:show-toast
+ *
+ * Outcomes:
+ * - done: Toast was displayed successfully
+ */
+declare class ShowToastActivity implements AXPCommand<ShowToastCommandInput, ShowToastOutput> {
+    private readonly toastService;
+    private readonly translationService;
+    execute(input: ShowToastCommandInput): AXPCommandExecuteResultPromise<ShowToastOutput>;
+    /**
+     * Resolves {@link ShowToastInput} from a direct workflow payload or entity command envelope.
+     */
+    private static resolvePayload;
+    private static tryDirectPayload;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowToastActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowToastActivity>;
+}
+
+/** Input for the sign-off activity (approval with digital signature). */
+interface SignOffActivityInput {
+    /** Optional dialog message; translated when it is an i18n key. */
+    message?: string;
+    /** Optional entity record id for workflow context. */
+    refId?: string;
+    /** Optional entity type key (`Module.Entity`). */
+    refType?: string;
+}
+/** Output when the user completes or cancels sign-off. */
+interface SignOffActivityOutput {
+    signature: string;
+    note?: string;
+    signedAt: string;
+}
+/**
+ * Sign-off activity (frontend).
+ *
+ * Collects a required digital signature and optional note from the current user.
+ * Use after review/approval paths in workflows that require an auditable sign-off.
+ *
+ * Activity type: `workflow-activity:sign-off`
+ * Outcomes: `Signed` | `Cancelled`
+ */
+declare class SignOffActivity implements AXPCommand<SignOffActivityInput, SignOffActivityOutput> {
+    private readonly layoutBuilder;
+    private readonly translationService;
+    execute(input: SignOffActivityInput): AXPCommandExecuteResultPromise<SignOffActivityOutput>;
+    private showSignOffDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignOffActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignOffActivity>;
+}
+
+/** Input for the rejection-reason activity. */
+interface RejectionReasonActivityInput {
+    /** Optional dialog message; translated when it is an i18n key. */
+    message?: string;
+    /** When true, reason must be non-empty before submit (default: true). */
+    requireReason?: boolean;
+}
+/** Output when the user submits or cancels the rejection dialog. */
+interface RejectionReasonActivityOutput {
+    reason: string;
+    rejectedAt: string;
+}
+/**
+ * Rejection-reason activity (frontend).
+ *
+ * Shows a dialog to capture a rejection reason.
+ * Use on workflow reject branches instead of ad-hoc show-layout-popup layouts.
+ *
+ * Activity type: `workflow-activity:rejection-reason`
+ * Outcomes: `Submitted` | `Cancelled`
+ */
+declare class RejectionReasonActivity implements AXPCommand<RejectionReasonActivityInput, RejectionReasonActivityOutput> {
+    private readonly layoutBuilder;
+    private readonly translationService;
+    execute(input: RejectionReasonActivityInput): AXPCommandExecuteResultPromise<RejectionReasonActivityOutput>;
+    private showRejectionDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RejectionReasonActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RejectionReasonActivity>;
+}
+
+/**
+ * Input for Create Entity Form activity.
+ */
+interface CreateEntityFormInput {
+    /**
+     * Module name (e.g. HumanCapitalManagement)
+     */
+    module: string;
+    /**
+     * Entity name (e.g. LeaveRequest)
+     */
+    entity: string;
+    /**
+     * If true, form only collects data and the next workflow step (e.g. entity-create) persists.
+     * If false, entity create is executed on frontend and outcome is 'Done'.
+     */
+    persistInWorkflow?: boolean;
+    /**
+     * Property names to show. Only these properties are displayed. If both includes and excludes are set, only includes is applied.
+     */
+    includes?: string[];
+    /**
+     * Property names to hide. Ignored when includes is also set.
+     */
+    excludes?: string[];
+    /**
+     * Property names that should be displayed as readonly.
+     */
+    readonlys?: string[];
+    /**
+     * Default values for form properties. Keys are property names; filled values are applied as initial context.
+     */
+    data?: Record<string, any>;
+}
+/**
+ * Output for Create Entity Form activity.
+ */
+interface CreateEntityFormOutput {
+    /**
+     * Form data for the next workflow step (when persistInWorkflow is true).
+     */
+    result?: Record<string, any>;
+    /**
+     * Created entity ID (when persistInWorkflow is false and entity create succeeds).
+     */
+    id?: string;
+}
+/**
+ * Create Entity Form Activity (Frontend)
+ *
+ * Shows a create-entity form as an interactive dialog. When persistInWorkflow is true,
+ * returns form data and outcome 'Submitted'/'Cancelled' so the workflow handles persistence.
+ * When false, executes entity create on frontend and returns outcome 'Done'.
+ *
+ * Execution Mode: frontend
+ * Task Type: human-task
+ * Activity Type: workflow-activity:create-entity-form
+ *
+ * Outcomes:
+ * - Submitted: User submitted form (persistInWorkflow true → next step persists)
+ * - Cancelled: User cancelled the form
+ * - Done: Entity was created on frontend (persistInWorkflow false)
+ */
+declare class CreateEntityFormActivity implements AXPCommand<CreateEntityFormInput, CreateEntityFormOutput> {
+    private readonly entityForm;
+    private readonly entityService;
+    private readonly translationService;
+    execute(input: CreateEntityFormInput): AXPCommandExecuteResultPromise<CreateEntityFormOutput>;
+    /**
+     * Maps dialog.show() result to a command result with a stable workflow outcome in metadata.
+     * Some dialog hosts return only the data payload without the metadata wrapper.
+     */
+    private normalizeDialogShowResult;
+    private normalizePersistInWorkflow;
+    /**
+     * Normalizes property list input (array, JSON string, or expression result).
+     */
+    private normalizePropertyList;
+    /**
+     * Normalizes data input (object or JSON string).
+     */
+    private normalizeData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateEntityFormActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateEntityFormActivity>;
+}
+
+/**
+ * Workflow Activities Definition Provider
+ *
+ * Provides activity definitions (metadata only).
+ * Activity definitions contain metadata for UI and tooling.
+ * The `name` property is used as the command key for execution.
+ * Reads from entity service (mock data).
+ */
+declare class AXMWorkflowActivitiesDefinitionProvider implements AXPActivityProvider {
+    private readonly entityService;
+    private activityDefinitionService;
+    getList(categoryId: string): Promise<AXPActivityDefinition[]>;
+    getById(name: string): Promise<AXPActivityDefinition | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMWorkflowActivitiesDefinitionProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXMWorkflowActivitiesDefinitionProvider>;
+}
+
+interface CreateEnityInput {
+    module: string;
+    entity: string;
+}
+interface CreateEnityOutput {
+    id: string;
+}
+declare class AXPCreateEntityActivity implements AXPCommand<CreateEnityInput, CreateEnityOutput> {
+    private entityForm;
+    private entityService;
+    private translationService;
+    execute(input: CreateEnityInput): AXPCommandExecuteResultPromise<CreateEnityOutput>;
+    private normalizeDialogShowResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCreateEntityActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCreateEntityActivity>;
+}
+
+/**
+ * Configuration for a workflow-specific task provider.
+ * One provider per workflow definition – pass definitionId to scope tasks to that definition only.
+ */
+interface AXPGenericWorkflowTaskProviderConfig {
+    /** Unique provider name (e.g. 'leave-request-workflow-tasks', 'document-review-workflow-tasks'). */
+    name: string;
+    /**
+     * Original translatable title source (i18n key or MLS).
+     * When set, {@link AXPGenericWorkflowTaskProvider.getTitle} resolves from this on each read.
+     */
+    titleSource?: AXPMultiLanguageString;
+    /** Display title in task board type selector (i18n key, MLS, or plain string). */
+    title: AXPMultiLanguageString;
+    /** Optional icon (default: 'fa-light fa-diagram-project'). */
+    icon?: string;
+    /**
+     * When set, only workflow instances for this definition are shown.
+     * One provider = one definition. Omit to show all suspended workflow tasks (single generic provider).
+     */
+    definitionId?: string;
+}
+/**
+ * Injection token for provider config. Use when registering via DI (provide token + useFactory with deps).
+ * Prefer {@link provideGenericWorkflowTaskProvider} (dynamic import) instead of a static class import in NgModule providers.
+ */
+declare const AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG: InjectionToken<AXPGenericWorkflowTaskProviderConfig>;
+/**
+ * Generic Workflow Task Provider
+ *
+ * Provides tasks from Workflow Instances directly (no Work Items).
+ * Queries suspended workflow instances and extracts tasks from bookmarks.
+ *
+ * Create one provider per workflow definition by passing a config (name, title, definitionId).
+ * E.g. leave request: { name: 'leave-request-workflow-tasks', title: 'Leave Request', definitionId: 'LeaveRequestWorkflow' }
+ *
+ * Architecture:
+ * - Queries Workflow Instances with subStatus = 'Suspended'
+ * - Filters by config.definitionId when set (one provider = one definition)
+ * - Extracts active bookmarks for each instance
+ * - Parses bookmark payload for assignment/actions
+ * - Maps to task board format
+ */
+declare class AXPGenericWorkflowTaskProvider extends AXPWorkflowTaskProvider<Record<string, any>> {
+    private readonly config;
+    private readonly entityService;
+    private readonly workflowInstanceQuery;
+    private readonly userEntityData;
+    private readonly translationService;
+    private readonly formatService;
+    private readonly settingsService;
+    private readonly entityRegistry;
+    private readonly statusDefinitionService;
+    private readonly workflowDefinitionService;
+    private readonly workflowManager;
+    private readonly humanTaskService;
+    private readonly sessionService;
+    private readonly toastService;
+    private readonly commandService;
+    private readonly dueStatusProviderService;
+    private readonly expressionScopeService;
+    private readonly expressionEvaluator;
+    /** Primary entity type (with status plugin) inferred from the workflow definition. */
+    private primaryEntityTypeWithStatus;
+    /** Per-provider caches (one instance per workflow definition). */
+    private readonly entityDefinitionCache;
+    private readonly statusDefinitionKeyByEntityType;
+    private readonly statusProviderByDefinitionKey;
+    private readonly userReferenceCache;
+    private readonly entityStatusIdCache;
+    constructor(config: AXPGenericWorkflowTaskProviderConfig);
+    get name(): string;
+    getTitle(): Promise<string>;
+    getIcon(): Promise<string>;
+    /** Bookmark types shown on the workflow task board. */
+    private isTaskBoardBookmarkPayload;
+    /** Pooled task: must be claimed before submit/cancel (cartable, or human-task with candidates only). */
+    private isPooledClaimablePayload;
+    /** Normalizes bookmark assignee/candidate ids (array or single string from expressions). */
+    private normalizeUserIdList;
+    /** Human-task assigned to another user; current user may take over when permitted. */
+    private isReassignableHumanTaskPayload;
+    private canTakeOverTask;
+    private isWorkflowRunCommand;
+    /**
+     * Secondary popover menu: workflow run utilities (history, take over).
+     */
+    private appendWorkflowMoreMenuActions;
+    /**
+     * Get tasks from suspended workflow instances.
+     *
+     * Queries workflow instances filtered by:
+     * - subStatus = 'Suspended'
+     * - entityRefType (if provided in filter)
+     * - definitionId (if provided in filter)
+     * - assignee/claimant (if filter provided)
+     *
+     * Then extracts active bookmarks and maps to task board format.
+     */
+    getTasks(options: AXPTaskFilter): Promise<{
+        items: AXPTask<Record<string, any>>[];
+        total: number;
+    }>;
+    /**
+     * Get active (non-consumed) bookmarks from workflow instance entity.
+     * Reads from instance.workflowInstance?.bookmarks — no direct DB access.
+     */
+    private getActiveBookmarksFromInstance;
+    /**
+     * Task-board "started by": workflow instance creator (initiator), never the current viewer.
+     * Uses audit creator when present; otherwise resolves `initiatorUserId` from workflow variables.
+     */
+    private buildStartedByFromInstance;
+    private getWorkflowStateFromInstance;
+    /**
+     * Formats dates for task popover metadata using regional short-date settings.
+     */
+    private formatDateForTaskDisplay;
+    private parseIsoDateString;
+    private parseBookmarkDueDate;
+    /** Resolve platform user id to a display label for the task board grid. */
+    private resolveAssigneeReference;
+    private loadUserReference;
+    /** Task copy evaluation with legacy workflow input title rehydration. */
+    private buildTaskTranslationDeps;
+    /** Map bookmark to task board task format. */
+    private mapBookmarkToTask;
+    /** @deprecated Use normalizeTaskPriority from task-management instead. */
+    private mapPriorityToTaskPriority;
+    /**
+     * Update tasks (not applicable for workflow instances - they are read-only from task provider perspective).
+     */
+    updateTasks(tasksToUpdate: AXPTask<Record<string, any>>[]): Promise<AXPTask<Record<string, any>>[]>;
+    /**
+     * Execute commands on tasks.
+     *
+     * Supports:
+     * - Workflow resume commands (Complete, Cancel)
+     */
+    executeCommand(command: AXPExecuteCommand): AXPCommandExecuteResultPromise;
+    /** Keeps workflow action labels as i18n keys for the popover translate pipe. */
+    private resolveWorkflowActionTitle;
+    /**
+     * Get available actions for a task.
+     *
+     * Extracts actions from bookmark payload.
+     */
+    getActions(task?: AXPTask<Record<string, any>>): Promise<AXPTaskActionMenuItem[]>;
+    getExtraFields(): Promise<AXPExtraField[]>;
+    getStatuses(): Promise<AXPTaskStatus[]>;
+    /** Resolves task status from bookmark context `statusId` and entity status plugin; falls back to workflow Pending. */
+    private resolveTaskStatus;
+    /**
+     * Loads display status from {@link TaskManagement.Task} (lookup-backed status snapshot).
+     */
+    private loadTaskRowStatus;
+    private resolveEntityTypeForTask;
+    /** True when a bookmark value was stored without expression evaluation. */
+    private isUnresolvedWorkflowExpression;
+    /**
+     * Loads `statusId` from the linked entity row when bookmark context omits or stale-fails it.
+     */
+    private loadEntityStatusIdFromContext;
+    /**
+     * Finds a row of `entityType` linked to this workflow instance (e.g. LifecycleEvent.workflowInfo.instanceId).
+     */
+    private loadEntityStatusIdByWorkflowInstance;
+    private fetchEntityStatusIdByWorkflowInstance;
+    private loadEntityStatusId;
+    private fetchEntityStatusIdByKey;
+    /** Fallback workflow task-board status when no entity status plugin applies. */
+    private getWorkflowPendingStatus;
+    private getWorkflowTaskStatuses;
+    private mapStatusProviderToTaskStatuses;
+    private translateStatusTitle;
+    private readContextString;
+    private parseQualifiedEntityType;
+    private resolveEntityDefinition;
+    private fetchEntityDefinition;
+    private getStatusPluginDefinitionKey;
+    private entityTypeHasStatusPlugin;
+    private getStatusDefinitionKeyForEntityType;
+    /**
+     * Warms status-definition-key cache for an entity type (call after resolveEntityDefinition).
+     */
+    private rememberStatusDefinitionKeyForEntityType;
+    private getEntityStatusProvider;
+    private getStatusProviderByDefinitionKey;
+    private findStatusDefinition;
+    private warmStatusDefinitionKeyCache;
+    /**
+     * First `entity-create` target in this workflow whose entity has a status plugin (cached per provider).
+     */
+    private resolvePrimaryEntityTypeForProvider;
+    getPopoverMetadata(task: AXPTask<Record<string, unknown>>): Promise<AXPTaskPopoverMetadata>;
+    /**
+     * Builds label/value metadata rows for the workflow task popover (view-mode widgets).
+     */
+    private buildPopoverMetadata;
+    private hasMeaningfulPopoverValue;
+    private formatUserReferenceLabel;
+    private resolveDueDate;
+    private resolveEffectiveDateValue;
+    /** Parses `yyyy-mm-dd` (and ISO date prefixes) in local time to avoid UTC day shifts in the date widget. */
+    private parseDateOnlyString;
+    private resolveTaskPriorityColor;
+    getComponent(): (() => Promise<Type<AXPTaskPopoverComponent>>) | Type<AXPTaskPopoverComponent> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPGenericWorkflowTaskProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPGenericWorkflowTaskProvider>;
+}
+
+/** Minimal bookmark payload shape for continuation eligibility checks. */
+interface WorkflowTaskContinuationPayload {
+    activityType: string;
+    assignedUserIds?: string[] | null;
+    candidateUserIds?: string[] | null;
+}
+/** Bookmark row shape stored on WorkflowInstance.workflowInstance.bookmarks. */
+interface WorkflowTaskContinuationBookmark {
+    id: string;
+    activityId: string;
+    type: string;
+    payload?: Record<string, unknown> | null;
+    payloadJson?: string;
+    consumed?: boolean;
+    isConsumed?: boolean;
+    createdAt?: string;
+}
+interface WorkflowTaskContinuationContext {
+    instance: AXMWorkflowManagementWorkflowInstanceEntityModel;
+    bookmark: WorkflowTaskContinuationBookmark;
+    payload: WorkflowTaskContinuationPayload;
+    sessionService: AXPSessionService;
+    /** Bookmark id of the task that was just completed (excluded from next-step detection). */
+    completedBookmarkId?: string;
+    /** Activity id that was just completed (excluded from next-step detection). */
+    completedActivityId?: string;
+}
+/** Normalizes platform user id lists on bookmark payloads. */
+declare function normalizeWorkflowTaskUserIds(value: string[] | null | undefined): string[];
+/**
+ * Workflow instance creator (task-board "started by" / continuation initiator checks).
+ * Prefers audit creator, then workflow `initiatorUserId` (properties / variables table).
+ * Never falls back to the current session user.
+ */
+declare function getWorkflowInstanceInitiatorUserId(instance: AXMWorkflowManagementWorkflowInstanceEntityModel): string | null;
+/** Reads `initiatorUserId` from persisted workflow state / variables table. */
+declare function resolveWorkflowInitiatorUserIdFromVariables(instance: AXMWorkflowManagementWorkflowInstanceEntityModel): string | null;
+/** Bookmark types rendered on the workflow task board. */
+declare function isWorkflowTaskBoardBookmarkPayload(payload: WorkflowTaskContinuationPayload): boolean;
+/** Pooled task that must be claimed before acting (no direct continuation offer). */
+declare function isWorkflowPooledClaimablePayload(payload: WorkflowTaskContinuationPayload): boolean;
+/** Human-task assigned to another user; may be taken over when permitted. */
+declare function isWorkflowReassignableHumanTaskPayload(payload: WorkflowTaskContinuationPayload): boolean;
+/** Parses bookmark payload from entity storage. */
+declare function parseWorkflowTaskContinuationPayload(bookmark: WorkflowTaskContinuationBookmark): WorkflowTaskContinuationPayload | null;
+/**
+ * Whether the workflow moved forward enough to prompt "continue to next step".
+ * Skips draft save / cancel on questionnaire (same human-task bookmark remains).
+ */
+declare function shouldOfferWorkflowContinuationAfterStep(context: AXPWorkflowContinuationStepContext, activeBookmarkActivityIds: string[]): boolean;
+/**
+ * Assignee of the first active human-task / cartable bookmark (used for interactive-step continuation).
+ */
+declare function findActiveHumanTaskAssigneeId(bookmarks: WorkflowTaskContinuationBookmark[]): string | null;
+/**
+ * Assignee on a completed human-task activity (when inbox bookmarks are already consumed).
+ */
+declare function findHumanTaskAssigneeIdForActivity(bookmarks: WorkflowTaskContinuationBookmark[], activityId: string): string | null;
+/** Latest human-task assignee on the instance (active first, then any bookmark). */
+declare function resolveWorkflowHumanTaskAssigneeId(instance: AXMWorkflowManagementWorkflowInstanceEntityModel, preferredActivityId?: string): string | null;
+/**
+ * Whether a bookmark row (including consumed) was a task-board human-task / cartable step.
+ */
+declare function wasWorkflowTaskBoardActivity(bookmarks: WorkflowTaskContinuationBookmark[], activityId: string): boolean;
+/**
+ * Whether to show "continue?" before an inline interactive activity (sign-off, assessment, etc.).
+ */
+declare function shouldOfferWorkflowInteractiveStepContinuation(instance: AXMWorkflowManagementWorkflowInstanceEntityModel, sessionService: AXPSessionService, humanTaskAssigneeId: string | null): boolean;
+/**
+ * Skips a redundant pre-interactive prompt when the next UI would run immediately anyway.
+ */
+declare function shouldSkipContinuationBeforeInteractive(context: AXPWorkflowContinuationStepContext, nextTask: AXPWorkflowTask, sessionService: AXPSessionService, instance: AXMWorkflowManagementWorkflowInstanceEntityModel, bookmarks: WorkflowTaskContinuationBookmark[], humanTaskAssigneeId: string | null): boolean;
+/** Take-over copy before interactive steps when a human-task is owned by someone else. */
+declare function needsTakeOverForWorkflowInteractiveContinuation(instance: AXMWorkflowManagementWorkflowInstanceEntityModel, sessionService: AXPSessionService, humanTaskAssigneeId: string | null): boolean;
+/**
+ * Whether the UI should offer "continue to next step" after a successful resume.
+ *
+ * - Current user is the assignee (sequential tasks for the same person, e.g. line manager).
+ * - Workflow initiator and assignee are the same person and that person is the current user.
+ * - Current user may take over a human-task assigned to someone else.
+ */
+/**
+ * Resolves assignee id from bookmark payload, falling back to instance bookmarks / pending task input.
+ */
+declare function resolveWorkflowTaskContinuationAssigneeId(instance: AXMWorkflowManagementWorkflowInstanceEntityModel, payload: WorkflowTaskContinuationPayload, pendingActivityId?: string): string | null;
+declare function shouldOfferWorkflowTaskContinuation(ctx: WorkflowTaskContinuationContext): boolean;
+/** True when the user must take over the next bookmark before acting on it. */
+declare function needsTakeOverForWorkflowTaskContinuation(ctx: WorkflowTaskContinuationContext): boolean;
+
+/**
+ * Offers "continue to next step" / take-over after workflow start, resume, and interactive chains.
+ * Uses {@link AXPWorkflowInstanceHumanTaskService} only — not task board or popover.
+ */
+declare class AXPWorkflowTaskContinuationService implements AXPWorkflowContinuationHook {
+    private readonly sessionService;
+    private readonly translationService;
+    private readonly dialogService;
+    private readonly humanTaskService;
+    private readonly bookmarkAccess;
+    offerBeforeInteractiveFlow(context: AXPWorkflowContinuationStepContext): Promise<AXPWorkflowContinuationOfferResult>;
+    offerAfterWorkflowStep(context: AXPWorkflowContinuationStepContext): Promise<AXPWorkflowContinuationOfferResult>;
+    private offerFromPendingNextTask;
+    private offerFromInstanceBookmarks;
+    private confirmAndAdvance;
+    private isCompletedBookmark;
+    private enrichPayloadFromInstance;
+    private buildPayloadFromWorkflowTask;
+    private confirmContinueToNextStep;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowTaskContinuationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowTaskContinuationService>;
+}
+
+/** Bookmark row on WorkflowInstance.workflowInstance.bookmarks. */
+interface WorkflowInstanceBookmarkRow {
+    id: string;
+    activityId: string;
+    type: string;
+    payload?: Record<string, unknown> | null;
+    payloadJson?: string;
+    consumed?: boolean;
+    isConsumed?: boolean;
+}
+interface HumanTaskBookmarkPayload extends WorkflowTaskContinuationPayload {
+    activityType: string;
+    activityName: string;
+    taskToken: string;
+    title?: string;
+    description?: string;
+    actions?: {
+        prefix?: unknown[];
+        suffix?: unknown[];
+    };
+    context?: Record<string, unknown>;
+}
+declare function getActiveBookmarks(instance: AXMWorkflowManagementWorkflowInstanceEntityModel): WorkflowInstanceBookmarkRow[];
+/**
+ * Loads workflow instance entity rows (including embedded bookmarks).
+ */
+declare function createWorkflowInstanceBookmarkAccess(entityService?: AXPEntityService): {
+    loadInstance(instanceId: string): Promise<AXMWorkflowManagementWorkflowInstanceEntityModel | null>;
+    /**
+     * Reloads the instance until the expected human-task bookmark exists (post-submit race).
+     */
+    loadInstanceForContinuation(instanceId: string, expectedPendingActivityId?: string): Promise<AXMWorkflowManagementWorkflowInstanceEntityModel | null>;
+    getActiveBookmarks: typeof getActiveBookmarks;
+    findActiveBookmark(instanceId: string, activityId: string): Promise<{
+        instance: AXMWorkflowManagementWorkflowInstanceEntityModel;
+        bookmark: WorkflowInstanceBookmarkRow;
+    } | null>;
+    parseHumanTaskPayload(bookmark: WorkflowInstanceBookmarkRow): HumanTaskBookmarkPayload | null;
+};
+type WorkflowInstanceBookmarkAccess = ReturnType<typeof createWorkflowInstanceBookmarkAccess>;
+
+interface ResumeSuspendedHumanTaskRequest {
+    instanceId: string;
+    bookmarkId: string;
+    activityId: string;
+    taskToken: string;
+    outcome: string;
+    userInput?: Record<string, unknown>;
+    /** When true, skips the post-resume "continue to next step?" prompt on this resume. */
+    suppressContinuation?: boolean;
+}
+/**
+ * Workflow-instance human-task operations (resume, take-over, primary action).
+ * Independent of task board / popover — task board delegates here for the same behavior.
+ */
+declare class AXPWorkflowInstanceHumanTaskService {
+    private readonly injector;
+    private readonly sessionService;
+    private readonly translationService;
+    private readonly dialogService;
+    private readonly toastService;
+    private readonly eventService;
+    private readonly workflowEngine;
+    private readonly bookmarkAccess;
+    /** Resolved lazily to avoid DI cycle with {@link AXPWorkflowManager} continuation hook. */
+    private get workflowManager();
+    /**
+     * Resumes a suspended human-task bookmark (runs interactive activities via the workflow manager).
+     */
+    resumeSuspendedHumanTask(request: ResumeSuspendedHumanTaskRequest): Promise<WorkflowResumeResult>;
+    /**
+     * Runs the first configured action on a suspended human-task bookmark (e.g. start-fill → questionnaire).
+     */
+    executePrimaryHumanTaskAction(instanceId: string, activityId: string, options?: {
+        suppressContinuation?: boolean;
+        notifyViews?: boolean;
+    }): Promise<WorkflowResumeResult | null>;
+    /**
+     * Reassigns a human-task bookmark to the current user (take over) without advancing the workflow.
+     */
+    reassignBookmarkToCurrentUser(instanceId: string, bookmarkId: string, activityId: string): Promise<boolean>;
+    /**
+     * Take over with confirmation dialog (task board "Take Over" action).
+     */
+    reassignBookmarkToCurrentUserWithConfirm(instanceId: string, bookmarkId: string, activityId: string): Promise<boolean>;
+    /** First action command name on the human-task bookmark (e.g. start-fill, approve). */
+    resolvePrimaryTaskOutcome(payload: HumanTaskBookmarkPayload): string;
+    private canTakeOver;
+    private confirmReassignToSelf;
+    private showResumeError;
+    private showToast;
+    /** Optional broadcast so open task-board views refresh; does not require task-board module at runtime. */
+    notifyWorkflowTaskViewsChanged(provider?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowInstanceHumanTaskService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowInstanceHumanTaskService>;
+}
+
+/**
+ * Shared suspended {@link WorkflowManagement.WorkflowInstance} query for task-board providers.
+ * One API round-trip serves all per-definition workflow task providers.
+ */
+declare class AXPWorkflowTaskInstanceQueryService {
+    private readonly entityService;
+    private readonly destroyRef;
+    private readonly eventService;
+    private readonly workflowInstanceData;
+    private readonly cacheTtlMs;
+    private cachedInstances;
+    private cacheExpiresAt;
+    private inFlight;
+    constructor();
+    invalidate(): void;
+    /**
+     * Returns suspended workflow instances, optionally scoped to one definition.
+     * The underlying entity query always loads the full suspended set once per cache window.
+     */
+    getSuspendedInstances(definitionId?: string): Promise<AXMWorkflowManagementWorkflowInstanceEntityModel[]>;
+    private loadAllSuspendedInstances;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowTaskInstanceQueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowTaskInstanceQueryService>;
+}
+
+/**
+ * Discovers one workflow task provider per workflow definition.
+ * Re-runs discovery when {@link AXPWorkflowTaskProviderResolveOptions.force} is set.
+ */
+declare function discoverWorkflowTaskProviders(injector: Injector, options?: AXPWorkflowTaskProviderResolveOptions): Promise<AXPWorkflowTaskProvider[]>;
+
+export { AXCCategoryProvider, AXMMenuProvider, AXMWorkflowActivitiesDefinitionProvider, AXMWorkflowManagementModule, AXPCreateEntityActivity, AXPGenericWorkflowTaskProvider, AXPWorkflowInstanceHumanTaskService, AXPWorkflowTaskContinuationService, AXPWorkflowTaskInstanceQueryService, AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG, CartableTaskActivity, CreateEntityFormActivity, HumanTaskActivity, RejectionReasonActivity, ShowConfirmPopupActivity, ShowLayoutPopupActivity, ShowToastActivity, SignOffActivity, createWorkflowInstanceBookmarkAccess, discoverWorkflowTaskProviders, findActiveHumanTaskAssigneeId, findHumanTaskAssigneeIdForActivity, getWorkflowInstanceInitiatorUserId, isWorkflowPooledClaimablePayload, isWorkflowReassignableHumanTaskPayload, isWorkflowTaskBoardBookmarkPayload, needsTakeOverForWorkflowInteractiveContinuation, needsTakeOverForWorkflowTaskContinuation, normalizeWorkflowTaskUserIds, parseWorkflowTaskContinuationPayload, resolveWorkflowHumanTaskAssigneeId, resolveWorkflowInitiatorUserIdFromVariables, resolveWorkflowTaskContinuationAssigneeId, shouldOfferWorkflowContinuationAfterStep, shouldOfferWorkflowInteractiveStepContinuation, shouldOfferWorkflowTaskContinuation, shouldSkipContinuationBeforeInteractive, wasWorkflowTaskBoardActivity };
+export type { AXPGenericWorkflowTaskProviderConfig, CartableTaskInput, CartableTaskOutput, CreateEnityInput, CreateEnityOutput, CreateEntityFormInput, CreateEntityFormOutput, HumanTaskBookmarkPayload, HumanTaskInput, HumanTaskOutput, RejectionReasonActivityInput, RejectionReasonActivityOutput, ResumeSuspendedHumanTaskRequest, ShowConfirmPopupInput, ShowConfirmPopupOutput, ShowLayoutPopupInput, ShowToastCommandInput, ShowToastEntityCommandEnvelope, ShowToastInput, ShowToastOutput, SignOffActivityInput, SignOffActivityOutput, WorkflowInstanceBookmarkAccess, WorkflowInstanceBookmarkRow, WorkflowTaskContinuationBookmark, WorkflowTaskContinuationContext, WorkflowTaskContinuationPayload };