@acorex/platform 21.0.0-next.7 → 21.0.0-next.70

package/{workflow/index.d.ts → types/acorex-platform-workflow.d.ts}

@@ -2,9 +2,7 @@ import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
 import { Type, ModuleWithProviders, Injector, InjectionToken } from '@angular/core';
-import { AXPCommand, AXPExecuteCommandResultPromise } from '@acorex/platform/runtime';
-import { AXPCategoryEntity, AXPValidationRules } from '@acorex/platform/core';
-import { AXPWidgetTypesMap } from '@acorex/platform/layout/widget-core';
+import { AXPProperty, AXPOptionsData, AXPMetaData, AXPEntityOp, AXPMultiLanguageString, AXPCategoryEntity, AXPExpressionEvaluatorScope } from '@acorex/platform/core';
 
 declare class AXPWorkflowError extends Error {
     inner: Error | null;
@@ -147,494 +145,170 @@ declare class AXPWorkflowService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowService>;
 }
 
-/**
- * Base entity with versioning support.
- */
-interface AXPVersionedEntity {
-    version: number;
-    isLatest: boolean;
-    isPublished: boolean;
-}
-/**
- * Workflow definition stored in database.
- * This is the stored format that matches Elsa backend structure.
- */
-interface AXPStoredWorkflowDefinition extends AXPVersionedEntity {
-    /**
-     * Unique ID of this workflow definition version.
-     */
-    id: string;
-    /**
-     * Unique workflow name (same across all versions).
-     * This is the primary identifier (replaces definitionId).
-     */
-    name: string;
-    /**
-     * Tenant ID (nullable).
-     */
-    tenantId?: string | null;
-    /**
-     * Description of what the workflow does.
-     */
-    description?: string | null;
-    /**
-     * Creation timestamp (ISO date-time).
-     */
-    createdAt: string;
-    /**
-     * Version of the tool that produced this definition (e.g. "3.2.0.0").
-     */
-    toolVersion?: string | null;
-    /**
-     * Materializer name for deserialization.
-     */
-    materializerName?: string;
-    /**
-     * JSON data (for simple workflows).
-     */
-    stringData?: string;
-    /**
-     * Binary data (for complex workflows).
-     */
-    binaryData?: Uint8Array;
-}
-/**
- * Variable definition.
- * Matches VariableDefinition from workflow definition schema.
- */
-interface AXPVariableDefinition {
-    /**
-     * Variable ID.
-     */
-    id?: string;
-    /**
-     * Variable name.
-     */
-    name: string;
-    /**
-     * Type name (e.g., "String", "Int32", "Boolean").
-     */
-    typeName: string;
-    /**
-     * Whether this is an array type.
-     */
-    isArray?: boolean;
-    /**
-     * Variable value (as string expression or literal).
-     */
-    value?: string | null;
-    /**
-     * Storage driver type name (for custom storage).
-     */
-    storageDriverTypeName?: string | null;
-}
-/**
- * Workflow input definition.
- * Matches WorkflowInputDefinition from workflow definition schema.
- */
-interface AXPWorkflowInputDefinition {
-    /**
-     * Input type (e.g., "String", "Int32", "Object").
-     */
-    type: string;
-    /**
-     * Input name.
-     */
+interface AXPWorkflowDefinition {
+    schemaVersion: 'acorex-platform-workflow/v1';
     name: string;
-    /**
-     * Display name.
-     */
-    displayName?: string;
-    /**
-     * Description.
-     */
-    description?: string;
-    /**
-     * Category for grouping.
-     */
-    category?: string;
-    /**
-     * UI hint (widget type).
-     */
-    uiHint?: string;
-    /**
-     * Storage driver type (for custom storage).
-     */
-    storageDriverType?: string | null;
+    title?: AXPMultiLanguageString | null;
+    description?: AXPMultiLanguageString | null;
+    variables?: AXPProperty[];
+    inputs?: AXPProperty[];
+    outputs?: AXPWorkflowOutputProperty[];
+    graph: AXPWorkflowGraph;
+    customProperties?: Record<string, any>;
+    /** engine specific (Elsa, ...) */
+    extensions?: AXPWorkflowExtensions;
+    /**
+     * Workflow bindings configuration.
+     * Defines which entities and events should trigger this workflow.
+     */
+    bindings?: AXPWorkflowBinding[];
+}
+interface AXPWorkflowGraph {
+    startActivityId: string;
+    activities: AXPWorkflowActivityInstance[];
+    connections: AXPConnection[];
+    /** purely designer */
+    designer?: {
+        nodes?: Record<string, {
+            x: number;
+            y: number;
+            nodeId?: string;
+            width?: number;
+            height?: number;
+        }>;
+        edges?: Array<{
+            from: string;
+            to: string;
+            vertices?: Array<{
+                x: number;
+                y: number;
+            }>;
+        }>;
+        /**
+         * When true, the Activities page has applied its initial auto-arrange (or the graph already had
+         * persisted node positions). Prevents re-running automatic layout on subsequent visits.
+         */
+        layoutArranged?: boolean;
+    };
 }
-/**
- * Workflow output definition.
- * Matches WorkflowOutputDefinition from workflow definition schema.
- */
-interface AXPWorkflowOutputDefinition {
-    /**
-     * Output type (e.g., "String", "Int32", "Object").
-     */
-    type: string;
+interface AXPWorkflowActivityInstance {
+    id: string;
+    nodeId?: string;
     /**
-     * Output name.
+     * Activity name - references AXPActivityDefinition.name
+     * Used to lookup activity definition for metadata (executionMode, title, etc.)
      */
     name: string;
     /**
-     * Display name.
-     */
-    displayName?: string;
-    /**
-     * Description.
-     */
-    description?: string;
-    /**
-     * Category for grouping.
-     */
-    category?: string;
-}
-/**
- * Expression.
- * Used for dynamic values in activities.
- */
-interface AXPExpression {
-    /**
-     * Expression type (e.g., "Literal", "JavaScript", "Liquid").
-     */
-    type: string;
-    /**
-     * Expression value.
-     */
-    value?: any;
-}
-/**
- * Input value wrapper.
- * Wraps an expression with type information.
- */
-interface AXPInputValue {
-    /**
-     * Type name.
-     */
-    typeName: string;
-    /**
-     * Expression (or null).
-     */
-    expression?: AXPExpression | null;
-}
-/**
- * Output value wrapper.
- * References memory location.
- */
-interface AXPOutputValue {
-    /**
-     * Type name.
-     */
-    typeName: string;
-    /**
-     * Memory reference (or null).
+     * Input values for this activity instance.
+     * Key-value pairs where keys match {@link AXPProperty.name} from AXPActivityDefinition.inputs
+     * Example: { "message": "Hello", "duration": 5000 }
      */
-    memoryReference?: {
-        id: string;
-    } | null;
-}
-/**
- * Position (for visual layout).
- */
-interface AXPPosition {
-    x: number;
-    y: number;
-}
-/**
- * Endpoint (connection point).
- */
-interface AXPEndpoint {
-    /**
-     * Activity ID.
-     */
-    activity: string;
+    inputs?: AXPOptionsData;
+    title?: string;
     /**
-     * Port name (nullable).
+     * Output mapping: process variable name → path in this activity's output (BPMN-style: activity → variable).
+     * When this activity completes, each entry sets variables[variableName] = output[outputPath].
+     * Example: { leaveRequestId: 'id' } → variables.leaveRequestId = activityOutput.id
      */
-    port?: string | null;
+    outputToVariables?: AXPOptionsData;
+    metadata?: AXPMetaData;
+    /** engine-specific override */
+    extensions?: Record<string, any>;
 }
-/**
- * Connection between activities.
- */
 interface AXPConnection {
-    /**
-     * Source endpoint.
-     */
-    source: AXPEndpoint;
-    /**
-     * Target endpoint.
-     */
-    target: AXPEndpoint;
-    /**
-     * Connection vertices (for curved paths).
-     */
-    vertices?: AXPPosition[];
-}
-/**
- * Variable model (for flowchart variables).
- */
-interface AXPVariableModel {
-    id: string;
-    name: string;
-    typeName: string;
-    value?: string | null;
-    storageDriverTypeName?: string | null;
-}
-/**
- * Metadata (designer annotations).
- */
-interface AXPMetadata {
-    [key: string]: any;
-}
-/**
- * Custom properties (free-form bag).
- */
-interface AXPCustomProperties {
-    /**
-     * Connections that reference non-existent activities.
-     */
-    notFoundConnections?: AXPConnection[];
-    /**
-     * Additional custom properties.
-     */
-    [key: string]: any;
-}
-/**
- * Base activity (workflow definition format).
- * Matches Activity from workflow definition schema.
- * Note: This is the workflow definition format, not the frontend Activity class.
- */
-interface AXPActivity$1 {
-    /**
-     * Activity ID.
-     */
-    id: string;
-    /**
-     * Node ID (for visual designer).
-     */
-    nodeId: string;
-    /**
-     * Activity name.
-     */
-    name?: string | null;
-    /**
-     * Activity type (e.g., "workflow-activity:write-line", "workflow-activity:if").
-     */
-    type: string;
-    /**
-     * Activity version.
-     */
-    version: number;
-    /**
-     * Execution mode for this activity instance.
-     * Determines where this activity should be executed:
-     * - 'frontend': Execute in browser (UI activities like dialogs, toasts, navigation)
-     * - 'backend': Execute in backend (business logic, database operations, API calls)
-     * - 'both': Execute in both frontend and backend (hybrid activities)
-     *
-     * If not specified, falls back to AXPActivity's executionMode.
-     * This allows per-instance override of the default execution mode.
-     *
-     * @example
-     * ```json
-     * {
-     *   "id": "show-dialog",
-     *   "type": "workflow-activity:show-dialog",
-     *   "executionMode": "frontend"
-     * }
-     * ```
-     */
-    executionMode?: 'frontend' | 'backend' | 'both';
-    /**
-     * Custom properties.
-     */
-    customProperties?: AXPCustomProperties;
-    /**
-     * Metadata (designer annotations).
-     */
-    metadata?: AXPMetadata;
-    /**
-     * Additional type-specific properties.
-     */
-    [key: string]: any;
+    source: {
+        activtyName: string;
+        port?: string | null;
+    };
+    target: {
+        activtyName: string;
+        port?: string | null;
+    };
+    vertices?: Array<{
+        x: number;
+        y: number;
+    }>;
 }
 /**
- * Flowchart activity (workflow definition format).
- * This is the root activity that contains all other activities.
+ * Workflow output: same as {@link AXPProperty} with optional source path and engine metadata.
  */
-interface AXPFlowchart extends AXPActivity$1 {
-    /**
-     * Type must be "workflow-activity:flowchart".
-     */
-    type: "workflow-activity:flowchart";
-    /**
-     * Activities in this flowchart.
-     */
-    activities: AXPActivity$1[];
-    /**
-     * Variables in this flowchart.
-     */
-    variables?: AXPVariableModel[];
+interface AXPWorkflowOutputProperty extends AXPProperty {
     /**
-     * Connections between activities.
+     * Optional: where this output comes from in your context/memory.
+     * Example: "$.result.orderId" or "vars.orderId"
      */
-    connections: AXPConnection[];
+    path?: string;
+    metadata?: Record<string, any>;
 }
 /**
- * Simplified workflow definition for JSON files.
- * This is what developers write - system fields are added automatically.
+ * Engine-specific extension bag for a workflow.
+ * Keep ALL engine-only fields here (Elsa, StepFunctions adapter, etc).
  */
-interface AXPWorkflowDefinitionJson {
-    /**
-     * Unique workflow name (used as key/identifier).
-     * This is the only required field for identification.
-     * Similar to entity system where 'name' is the unique key.
-     */
-    name: string;
-    /**
-     * Display title (human-readable name shown in UI).
-     * Similar to entity system where 'title' is the display name.
-     */
-    title?: string | null;
-    /**
-     * Description.
-     */
-    description?: string | null;
-    /**
-     * Workflow variables.
-     */
-    variables?: AXPVariableDefinition[];
-    /**
-     * Workflow inputs.
-     */
-    inputs?: AXPWorkflowInputDefinition[];
-    /**
-     * Workflow outputs.
-     */
-    outputs?: AXPWorkflowOutputDefinition[];
+interface AXPWorkflowExtensions {
     /**
-     * Workflow outcomes.
+     * Elsa-specific extensions (optional).
      */
-    outcomes?: string[];
-    /**
-     * Custom properties.
-     */
-    customProperties?: AXPCustomProperties;
-    /**
-     * Workflow options.
-     */
-    options?: AXPWorkflowOptions;
+    elsa?: AXPElsaWorkflowExtensions;
     /**
-     * Root activity (Flowchart).
+     * Other engines (future-proof).
+     * Example: stepFunctions, logicApps, temporal, ...
      */
-    root: AXPFlowchart;
+    [engine: string]: any;
 }
 /**
- * Complete workflow definition (v3.0.0 format).
- * This is the core workflow definition without system fields.
- * System fields ($schema, tenantId, createdAt, toolVersion, isPublished, id, version, isLatest, isReadonly, isSystem)
- * are managed by the entity system and stored in entity model.
+ * Elsa-only fields (Optional).
+ * Put strategy/tool/schema/raw payload here to keep Core model global.
  */
-interface AXPWorkflowDefinition {
-    /**
-     * Unique workflow name (used as key/identifier, same across all versions).
-     * This is the primary identifier for the workflow.
-     */
-    name: string;
-    /**
-     * Display title (human-readable name shown in UI).
-     */
-    title?: string | null;
-    /**
-     * Description.
-     */
-    description?: string | null;
-    /**
-     * Workflow variables.
-     */
-    variables?: AXPVariableDefinition[];
+interface AXPElsaWorkflowExtensions {
     /**
-     * Workflow inputs.
+     * Elsa schema URL (if you want to round-trip exact docs).
+     * Example: "https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json"
      */
-    inputs?: AXPWorkflowInputDefinition[];
-    /**
-     * Workflow outputs.
-     */
-    outputs?: AXPWorkflowOutputDefinition[];
-    /**
-     * Workflow outcomes.
-     */
-    outcomes?: string[];
-    /**
-     * Custom properties.
-     */
-    customProperties?: AXPCustomProperties;
-    /**
-     * Workflow options.
-     */
-    options?: AXPWorkflowOptions;
+    schema?: string;
+    toolVersion?: string;
+    materializerName?: string;
     /**
-     * @deprecated Use options.usableAsActivity instead.
+     * Elsa strategy/options (engine-level concerns).
      */
-    usableAsActivity?: boolean | null;
+    options?: {
+        activationStrategyType?: string | null;
+        incidentStrategyType?: string | null;
+        commitStrategyName?: string | null;
+        autoUpdateConsumingWorkflows?: boolean;
+        usableAsActivity?: boolean | null;
+        activityCategory?: string | null;
+    };
     /**
-     * Root activity (Flowchart).
+     * If you want lossless Elsa round-trip, keep the raw Elsa definition here.
      */
-    root: AXPFlowchart;
+    rawDefinition?: any;
 }
 /**
- * Workflow configuration options.
+ * Workflow binding configuration.
+ * Defines which entities and events should trigger a workflow.
  */
-interface AXPWorkflowOptions {
-    /**
-     * Activation strategy type.
-     */
-    activationStrategyType?: string | null;
-    /**
-     * Whether workflow can be used as an activity.
-     */
-    usableAsActivity?: boolean | null;
+interface AXPWorkflowBinding {
     /**
-     * Auto-update consuming workflows.
+     * Entity types this workflow applies to (e.g., ['ContentManagement.Promotion', 'ContentManagement.Article'])
+     * Empty array means applies to all entities with workflow plugin enabled.
      */
-    autoUpdateConsumingWorkflows?: boolean;
+    entityTypes: string[];
     /**
-     * Activity category (if usable as activity).
+     * Event types that trigger this workflow (e.g., ['create', 'update'])
+     * Uses AXPEntityOp directly (create, update, delete, etc.)
      */
-    activityCategory?: string | null;
+    eventTypes: AXPEntityOp[];
     /**
-     * Incident strategy type.
+     * Whether this binding is enabled
      */
-    incidentStrategyType?: string | null;
+    enabled: boolean;
     /**
-     * Commit strategy name.
+     * Optional conditions for when to trigger (future enhancement)
      */
-    commitStrategyName?: string | null;
+    conditions?: any;
 }
 
-/**
- * Workflow definition loader interface.
- * Implement this to provide workflow definitions from various sources (JSON files, database, etc.).
- */
-interface AXPWorkflowDefinitionLoader {
-    /**
-     * Get workflow definition by name (unique key).
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
-    /**
-     * Get all available workflow names.
-     * Used for preloading and discovery.
-     * @returns Array of workflow names
-     */
-    getAllNames?(): Promise<string[]>;
-}
-/**
- * Injection token for workflow definition loaders.
- * Multiple loaders can be provided (multi: true).
- */
-declare const AXP_WORKFLOW_DEFINITION_LOADER: InjectionToken<AXPWorkflowDefinitionLoader>;
-
 /**
  * Workflow status.
  */
@@ -930,6 +604,10 @@ interface AXPWorkflowState {
      * Finished at timestamp (ISO date-time, nullable).
      */
     finishedAt?: string | null;
+    /**
+     * Total number of activities/steps in the workflow (for progress display).
+     */
+    totalSteps?: number;
 }
 /**
  * Workflow instance (stored in database).
@@ -996,8 +674,36 @@ interface AXPWorkflowInstance {
      * Finished at timestamp (ISO date-time, nullable).
      */
     finishedAt?: string | null;
+    /**
+     * Entity reference ID (for linking workflow instances to business entities).
+     */
+    entityRefId?: string | null;
+    /**
+     * Entity reference type (e.g., 'HumanCapitalManagement.LeaveRequest').
+     */
+    entityRefType?: string | null;
 }
 
+/**
+ * Type of task for inbox handling.
+ * - 'human-task': Requires inbox - needs human interaction
+ * - 'ui-activity': UI-only activity (no inbox) - immediate execution
+ * - 'system-activity': System/backend activity (no inbox) - automated execution
+ */
+type AXPTaskType = 'human-task' | 'ui-activity' | 'system-activity';
+/**
+ * How the workflow engine should offer "continue to next step?" before an inline frontend activity.
+ * Declared on {@link AXPActivityDefinition} and copied onto {@link AXPWorkflowTask} at runtime.
+ */
+type AXPWorkflowContinuationBeforeInteractive = 'default'
+/** Skip when opened from a task-board human-task primary action (e.g. start-fill, review). */
+ | 'skip-when-chained-from-human-task'
+/** Skip for the natural assignee; initiator / reassign users still get the prompt (workflow-management). */
+ | 'skip-for-assignee';
+/** Optional continuation UX metadata for an activity definition. */
+interface AXPWorkflowContinuationMetadata {
+    beforeInteractive?: AXPWorkflowContinuationBeforeInteractive;
+}
 /**
  * Activity Category - Extends AXPCategoryEntity for consistency and performance
  *
@@ -1008,14 +714,18 @@ interface AXPWorkflowInstance {
  * - parentId?: string            - Parent category ID
  * - childrenCount: number        - Direct child categories count (enables lazy loading)
  * - itemsCount?: number          - Direct activities count
- * - totalChildren?: number       - Total nested categories (optional, for analytics)
- * - totalItems?: number          - Total activities in tree (optional, for analytics)
+ * - totalChildrenCount?: number  - Total nested categories (optional, for analytics)
+ * - totalItemsCount?: number     - Total activities in tree (optional, for analytics)
  */
 interface AXPActivityCategory extends AXPCategoryEntity {
 }
-interface ActivityPropertyWidget {
-    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
-    options?: Record<string, any>;
+/**
+ * Lightweight category snapshot embedded in activity-definition records.
+ */
+interface AXPActivityDefinitionCategoryRef {
+    id: string;
+    name: string;
+    title: AXPMultiLanguageString;
 }
 /**
  * Activity Definition - Metadata for UI and tooling.
@@ -1033,17 +743,18 @@ interface AXPActivityDefinition {
      */
     type: string;
     /**
-     * Display name for UI.
+     * Display name for UI (plain or per-locale map).
      */
-    title?: string;
+    title?: AXPMultiLanguageString;
+    instanceTitle?: string;
     /**
-     * Description of what the activity does.
+     * Description of what the activity does (plain or per-locale map).
      */
-    description?: string;
+    description?: AXPMultiLanguageString;
     /**
      * Category for grouping in toolbox.
      */
-    category?: string;
+    category?: AXPActivityDefinitionCategoryRef;
     /**
      * Icon name or class.
      */
@@ -1058,13 +769,22 @@ interface AXPActivityDefinition {
      */
     executionMode?: 'frontend' | 'backend' | 'both';
     /**
-     * Input descriptors.
+     * Type of task for inbox handling.
+     * - 'human-task': Requires inbox - needs human interaction
+     * - 'ui-activity': UI-only activity (no inbox) - immediate execution
+     * - 'system-activity': System/backend activity (no inbox) - automated execution
+     *
+     * Default: 'ui-activity' (for backward compatibility)
      */
-    inputs?: InputDescriptor[];
+    taskType?: AXPTaskType;
     /**
-     * Output descriptors.
+     * Input properties (form/schema for activity parameters).
      */
-    outputs?: OutputDescriptor[];
+    inputs?: AXPProperty[];
+    /**
+     * Output properties (result shape + optional path/metadata).
+     */
+    outputs?: AXPWorkflowOutputProperty[];
     /**
      * Static outcomes (exit points).
      * Example: ['Done', 'Success', 'Failed']
@@ -1080,54 +800,17 @@ interface AXPActivityDefinition {
      * Default: false
      */
     isContainer?: boolean;
-}
-/**
- * Activity - Command with specific TResult structure.
- * Extends AXPCommand with a fixed TResult that includes output and outcomes.
- * No additional properties beyond AXPCommand - pure command interface.
- */
-interface AXPActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
-    output: TOutput;
-    outcomes: Record<string, any>;
-}> {
     /**
-     * Execute the activity as a command.
-     * @param input - Activity input data
-     * @returns Promise with output and outcomes
+     * Continuation prompt behavior when this activity runs inline in the workflow manager.
      */
-    execute(input: TInput): AXPExecuteCommandResultPromise<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>;
+    workflowContinuation?: AXPWorkflowContinuationMetadata;
 }
 /**
- * Input property descriptor.
- * Similar to AXPEntityProperty structure.
+ * Query result shape for activity-definition catalog endpoints.
  */
-interface InputDescriptor {
-    name: string;
-    title: string;
-    description?: string;
-    schema: {
-        dataType: string;
-        nullable?: boolean;
-        readonly?: boolean;
-        hidden?: boolean | string;
-        defaultValue?: any | string | ((context: any | null) => any);
-        interface?: ActivityPropertyWidget;
-    };
-    validations?: AXPValidationRules;
-}
-/**
- * Output property descriptor.
- */
-interface OutputDescriptor {
-    name: string;
-    title: string;
-    description?: string;
-    schema: {
-        dataType: string;
-    };
+interface AXPActivityDefinitionQueryResult {
+    total: number;
+    items: AXPActivityDefinition[];
 }
 
 type AXPActivityProviderToken = AXPActivityProvider | Promise<AXPActivityProvider>;
@@ -1228,6 +911,11 @@ declare class AXPActivityDefinitionService {
      * @returns Activity definition or undefined if not found
      */
     getActivityByName(name: string): Promise<AXPActivityDefinition | undefined>;
+    /**
+     * Get all activity definitions (flat list) by loading root categories and their activities.
+     * Used by activity selector UIs (e.g. automation command configurator).
+     */
+    getAllActivities(): Promise<AXPActivityDefinition[]>;
     /**
      * Get category ID containing a specific activity definition
      *
@@ -1319,6 +1007,10 @@ interface AXPWorkflowTask {
      * - 'both': Execute in both frontend and backend (hybrid activities)
      */
     executionMode: 'frontend' | 'backend' | 'both';
+    /**
+     * Type of task for inbox handling.
+     */
+    taskType?: 'human-task' | 'ui-activity' | 'system-activity';
     /**
      * Input data for the activity (for frontend activities).
      */
@@ -1327,6 +1019,10 @@ interface AXPWorkflowTask {
      * Configuration for the activity (for frontend activities).
      */
     config?: Record<string, any>;
+    /**
+     * Continuation UX copied from the activity definition at task creation time.
+     */
+    continuation?: AXPWorkflowContinuationMetadata;
 }
 /**
  * Request to start a workflow instance.
@@ -1358,6 +1054,16 @@ interface AXPStartWorkflowResponse {
      * Client should execute this task based on executionMode.
      */
     pendingTask?: AXPWorkflowTask | null;
+    /**
+     * Activity outputs map (activityId -> output).
+     * Returned for expression evaluation in subsequent activities.
+     */
+    activityOutputs?: Record<string, any>;
+    /**
+     * Last activity output (convenience).
+     * Prefer using `activityOutputs[activityId]` when possible.
+     */
+    lastActivityOutput?: any;
 }
 /**
  * Request to resume a suspended workflow.
@@ -1379,7 +1085,7 @@ interface AXPResumeWorkflowRequest {
     /**
      * User action outcome (e.g., 'Confirmed', 'Cancelled').
      */
-    outcome: string;
+    outcome?: string;
     /**
      * Optional user input data.
      */
@@ -1439,6 +1145,16 @@ interface AXPWorkflowInstanceState {
      * Workflow variables (state).
      */
     variables: Record<string, any>;
+    /**
+     * Activity outputs map (activityId -> output).
+     * Used by expression evaluation scope as `outputs.activityId`.
+     */
+    activityOutputs?: Record<string, any>;
+    /**
+     * Last activity output (convenience).
+     * Useful when the next activity needs a quick access to the previous result.
+     */
+    lastActivityOutput?: any;
     /**
      * Initial input data.
      */
@@ -1452,6 +1168,79 @@ interface AXPWorkflowInstanceState {
      */
     lastUpdated: Date;
 }
+interface AXPFrontActivityCompleteRequest {
+    /**
+     * Instance ID.
+     */
+    instanceId: string;
+    activityNode: string;
+    output: Record<string, any>;
+    outcome?: string;
+}
+interface AXPFrontActivityCompleteResponse {
+    /**
+     * Activity execution output.
+     */
+    output?: any;
+    /**
+     * Activity execution outcomes.
+     */
+    outcomes?: Record<string, any>;
+    /**
+     * Next task to execute (if any).
+     */
+    nextTask?: AXPWorkflowTask | null;
+    /**
+     * Updated workflow state.
+     */
+    state?: AXPWorkflowInstanceState;
+}
+/**
+ * Activity types that use the task board (suspend until user acts via inbox), not inline interactive execution.
+ */
+declare const AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES: readonly string[];
+declare function axpIsWorkflowTaskBoardActivityType(activityType: string | undefined | null): boolean;
+/**
+ * Claim a pooled workflow task (updates bookmark assignee without resuming the workflow).
+ */
+interface AXPClaimWorkflowTaskRequest {
+    instanceId: string;
+    bookmarkId: string;
+    stepId: string;
+}
+interface AXPClaimWorkflowTaskResponse {
+    success: boolean;
+    error?: string;
+    errorCode?: string;
+}
+/**
+ * Reassign a human-task bookmark to the current user without resuming the workflow.
+ */
+interface AXPReassignWorkflowTaskToSelfRequest {
+    instanceId: string;
+    bookmarkId: string;
+    stepId: string;
+}
+interface AXPReassignWorkflowTaskToSelfResponse {
+    success: boolean;
+    error?: string;
+    errorCode?: string;
+}
+/** Restore task-board visibility after the user declines a pre-interactive continuation prompt. */
+interface AXPRevertResumeAfterDeclinedInteractiveContinuationRequest {
+    instanceId: string;
+    /** Human-task / cartable step that was resumed from the task board. */
+    suspendedStepId: string;
+    /** Inline frontend step that was about to run when the user declined. */
+    abortedStepId?: string;
+    /** Bookmark id of the suspended step (when known). */
+    bookmarkId?: string;
+}
+interface AXPRevertResumeAfterDeclinedInteractiveContinuationResponse {
+    success: boolean;
+    state?: AXPWorkflowInstanceState;
+    error?: string;
+}
 
 /**
  * Interface for workflow engine operations.
@@ -1487,6 +1276,24 @@ interface AXPWorkflowEngine {
      *
      */
     getState(request: AXPGetWorkflowStateRequest): Promise<AXPWorkflowInstanceState>;
+    frontActivtyComplete(request: AXPFrontActivityCompleteRequest): Promise<AXPFrontActivityCompleteResponse>;
+    /**
+     * Optional: claim a pooled task (e.g. cartable) without consuming the bookmark.
+     * Engines that do not support pooling should omit this method.
+     */
+    claimTask?(request: AXPClaimWorkflowTaskRequest): Promise<AXPClaimWorkflowTaskResponse>;
+    /**
+     * Optional: reassign a human-task bookmark to the current user (requires permission on the engine).
+     */
+    reassignTaskToSelf?(request: AXPReassignWorkflowTaskToSelfRequest): Promise<AXPReassignWorkflowTaskToSelfResponse>;
+    /**
+     * Optional: restore a suspended task-board step when the user declines a pre-interactive continuation prompt.
+     */
+    revertResumeAfterDeclinedInteractiveContinuation?(request: AXPRevertResumeAfterDeclinedInteractiveContinuationRequest): Promise<AXPRevertResumeAfterDeclinedInteractiveContinuationResponse>;
+    /**
+     * Optional: terminate a non-finished instance (e.g. superseded lifecycle run).
+     */
+    cancelInstance?(instanceId: string, reason?: string): Promise<void>;
 }
 /**
  * Injection token for workflow engine.
@@ -1495,44 +1302,33 @@ interface AXPWorkflowEngine {
 declare const AXP_WORKFLOW_ENGINE: InjectionToken<AXPWorkflowEngine>;
 
 /**
- * Result of executing a frontend task.
+ * Stable workflow engine error codes for UI branching (toasts, take-over flow, etc.).
  */
-interface FrontendTaskExecutionResult {
-    /**
-     * Task execution output.
-     */
-    output: any;
-    /**
-     * Task execution outcome (e.g., 'Done', 'Confirmed', 'Cancelled', 'Failed').
-     */
-    outcome: string;
-}
+declare const AXP_WORKFLOW_ERROR_CODES: {
+    readonly TASK_NOT_ASSIGNEE: "WORKFLOW_TASK_NOT_ASSIGNEE";
+    readonly CLAIM_REQUIRED: "WORKFLOW_CLAIM_REQUIRED";
+    readonly REASSIGN_NOT_ALLOWED: "WORKFLOW_REASSIGN_NOT_ALLOWED";
+};
+type AXPWorkflowErrorCode = (typeof AXP_WORKFLOW_ERROR_CODES)[keyof typeof AXP_WORKFLOW_ERROR_CODES];
 /**
- * Service responsible for executing frontend workflow tasks.
- *
- * This service handles the execution of frontend or hybrid tasks using
- * the command infrastructure. It translates command results into
- * workflow-compatible output and outcome format.
- *
- * This service is replaceable per platform and contains all execution logic.
+ * Business-rule failure from {@link AXPWorkflowEngine} (expected, user-facing).
  */
-declare class FrontendTaskExecutor {
-    private readonly commandService;
-    /**
-     * Execute a frontend workflow task.
-     *
-     * Only executes tasks with executionMode 'frontend' or 'both'.
-     * Backend tasks should not be passed to this executor.
-     *
-     * @param task - Task to execute
-     * @returns Execution result with output and outcome
-     *
-     * @throws Error if task is not a frontend task
-     */
-    execute(task: AXPWorkflowTask): Promise<FrontendTaskExecutionResult>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FrontendTaskExecutor, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FrontendTaskExecutor>;
+declare class AXPWorkflowEngineError extends Error {
+    readonly code: AXPWorkflowErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: AXPWorkflowErrorCode, details?: Record<string, unknown> | undefined);
 }
+/**
+ * Resolves a stable error code from an unknown thrown value.
+ */
+declare function getWorkflowEngineErrorCode(error: unknown): AXPWorkflowErrorCode | undefined;
+/**
+ * Resolves a user-facing message and optional code from an unknown thrown value.
+ */
+declare function getWorkflowEngineErrorInfo(error: unknown): {
+    message: string;
+    code?: AXPWorkflowErrorCode;
+};
 
 /**
  * Result of starting a workflow.
@@ -1620,6 +1416,28 @@ interface WorkflowResumeResult {
      * Error message (if failed).
      */
     error?: string;
+    /**
+     * Stable engine error code when available (e.g. WORKFLOW_TASK_NOT_ASSIGNEE).
+     */
+    errorCode?: string;
+}
+/**
+ * Result of claiming a pooled workflow task (cartable / candidate pool).
+ */
+interface WorkflowClaimTaskResult {
+    success: boolean;
+    instanceId: string;
+    error?: string;
+    errorCode?: string;
+}
+/**
+ * Result of reassigning a human-task bookmark to the current user.
+ */
+interface WorkflowReassignTaskToSelfResult {
+    success: boolean;
+    instanceId: string;
+    error?: string;
+    errorCode?: string;
 }
 /**
  * Workflow Manager - Facade for workflow lifecycle orchestration.
@@ -1629,20 +1447,21 @@ interface WorkflowResumeResult {
  *
  * Responsibilities:
  * - Orchestrate workflow lifecycle (start, execute, complete, resume)
- * - Delegate execution to FrontendTaskExecutor
+ * - Delegate execution to ActivityExecutor
  * - Cache workflow state in memory
  * - Expose a stable API for UI
  *
  * Rules:
  * - No HTTP calls (delegates to AXPWorkflowEngine)
- * - No CommandBus / Command execution (delegates to FrontendTaskExecutor)
+ * - No CommandBus / Command execution (delegates to ActivityExecutor)
  * - No workflow branching logic (backend decides)
  * - No business validation (backend validates)
  * - No backend assumptions (uses abstract runtime service)
  */
 declare class AXPWorkflowManager {
     private readonly workflowEngine;
-    private readonly frontendTaskExecutor;
+    private readonly activityExecutor;
+    private readonly continuationHook;
     /**
      * Cache workflow states in memory for quick access.
      * Key: instanceId
@@ -1653,6 +1472,29 @@ declare class AXPWorkflowManager {
      * Cache TTL in milliseconds (5 minutes).
      */
     private readonly CACHE_TTL;
+    /**
+     * Execute frontend activities interactively until reaching workflow-activity:human-task or completion.
+     *
+     * Interactive = show form/popup immediately (user sees and acts). Only workflow-activity:human-task
+     * is not interactive (goes to task board). Other frontend activities (show-layout-popup, show-toast, etc.)
+     * even with taskType human-task in definition are executed here.
+     *
+     * @param instanceId - Workflow instance ID
+     * @param task - Current task to execute
+     * @param state - Current workflow state
+     * @param lastActivityOutput - Last activity output (for expression evaluation)
+     * @returns Final result with nextTask (if workflow-activity:human-task) or completion status
+     */
+    private executeInteractiveFlow;
+    /**
+     * Runs inline interactive activities when allowed, with an optional pre-flow continuation prompt.
+     */
+    private runInteractiveFlowWithContinuation;
+    private invokeWorkflowContinuationAfterStep;
+    /**
+     * Restores the suspended task-board step when the user declines a pre-interactive continuation prompt.
+     */
+    private revertResumeAfterDeclinedInteractiveContinuation;
     /**
      * Start a new workflow instance.
      *
@@ -1677,31 +1519,6 @@ declare class AXPWorkflowManager {
      * ```
      */
     start(workflowId: string, input?: Record<string, any>): Promise<WorkflowStartResult>;
-    /**
-     * Execute a frontend task.
-     *
-     * Delegates to FrontendTaskExecutor for actual execution.
-     * Only executes tasks with executionMode 'frontend' or 'both'.
-     *
-     * @param task - Task to execute
-     * @returns Execution result with output and outcome
-     *
-     * @throws Error if task is not a frontend task
-     */
-    execute(task: AXPWorkflowTask): Promise<FrontendTaskExecutionResult>;
-    /**
-     * Complete a task and get next task from backend.
-     *
-     * Sends task result to backend API.
-     * Backend decides: next task, fail, or complete workflow.
-     *
-     * @param instanceId - Workflow instance ID
-     * @param task - Completed task
-     * @param outcome - Task outcome (e.g., 'Done', 'Confirmed', 'Cancelled')
-     * @param output - Task output/result (optional)
-     * @returns Complete result with next task (if any)
-     */
-    complete(instanceId: string, task: AXPWorkflowTask, outcome: string, output?: any): Promise<WorkflowCompleteResult>;
     /**
      * Resume a suspended workflow (e.g., after user interaction).
      *
@@ -1725,6 +1542,16 @@ declare class AXPWorkflowManager {
      * @returns Workflow instance state or null if not found
      */
     getState(instanceId: string): Promise<AXPWorkflowInstanceState | null>;
+    /**
+     * Claim a pooled workflow task (assign current user on the bookmark without advancing the workflow).
+     * Supported only when the injected workflow engine implements {@link AXPWorkflowEngine.claimTask}.
+     */
+    claimTask(instanceId: string, bookmarkId: string, stepId: string): Promise<WorkflowClaimTaskResult>;
+    /**
+     * Reassign a human-task bookmark to the current user without advancing the workflow.
+     * Supported only when the injected workflow engine implements {@link AXPWorkflowEngine.reassignTaskToSelf}.
+     */
+    reassignTaskToSelf(instanceId: string, bookmarkId: string, stepId: string): Promise<WorkflowReassignTaskToSelfResult>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowManager, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowManager>;
 }
@@ -1738,15 +1565,16 @@ declare class AXPWorkflowManager {
  * - Maintains workflow state in memory
  * - Does not require backend API calls
  *
- * Execution of frontend tasks is handled by AXPWorkflowManager via FrontendTaskExecutor.
+ * Execution of frontend tasks is handled by AXPWorkflowManager via ActivityExecutor.
  * This engine only manages workflow progression and state storage.
  *
  * This is the DEFAULT engine provider. Applications can override it with
  * an API-based engine implementation.
  */
 declare class AXPWorkflowLocalEngine implements AXPWorkflowEngine {
-    private readonly definitionLoaders;
-    constructor(definitionLoaders?: AXPWorkflowDefinitionLoader[] | null);
+    private readonly activityDefinitionService;
+    private readonly workflowProviders;
+    private readonly multiLanguageResolver;
     /**
      * In-memory storage for workflow instances.
      * Key: instanceId
@@ -1779,7 +1607,7 @@ declare class AXPWorkflowLocalEngine implements AXPWorkflowEngine {
      */
     getState(request: AXPGetWorkflowStateRequest): Promise<AXPWorkflowInstanceState>;
     /**
-     * Get workflow definition from available loaders.
+     * Get workflow definition from available providers.
      */
     private getDefinition;
     /**
@@ -1795,65 +1623,239 @@ declare class AXPWorkflowLocalEngine implements AXPWorkflowEngine {
      * Get next activity ID based on connections and outcomes.
      */
     private getNextActivityId;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowLocalEngine, [{ optional: true; }]>;
+    frontActivtyComplete(request: AXPFrontActivityCompleteRequest): Promise<AXPFrontActivityCompleteResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowLocalEngine, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowLocalEngine>;
 }
 
 /**
- * Workflow Category - Extends AXPCategoryEntity for consistency and performance
- *
- * Inherited properties from AXPCategoryEntity:
- * - id: string                   - Unique identifier
- * - title: string                - Display name
- * - description?: string         - Category description
- * - parentId?: string            - Parent category ID
- * - childrenCount: number        - Direct child categories count (enables lazy loading)
- * - itemsCount?: number          - Direct workflows count
- * - totalChildren?: number       - Total nested categories (optional, for analytics)
- * - totalItems?: number          - Total workflows in tree (optional, for analytics)
+ * Result of executing a workflow activity.
  */
-interface AXPWorkflowCategory extends AXPCategoryEntity {
+interface ActivityExecutionResult {
+    /**
+     * Activity execution output.
+     */
+    output: any;
+    /**
+     * Activity execution outcome (e.g., 'Done', 'Confirmed', 'Cancelled', 'Failed').
+     */
+    outcome: string;
 }
 /**
- * Workflow Definition - Metadata for UI and tooling.
- * Contains all metadata needed for displaying workflows in toolbox and designer.
- * The `name` property is used as the workflow identifier.
+ * Activity Executor Service
+ *
+ * Service for executing workflow activities via CommandBus.
+ * Automatically evaluates expressions in activity inputs before execution.
+ *
+ * @example
+ * ```typescript
+ * const executor = inject(ActivityExecutor);
+ *
+ * // Execute activity with task and workflow state (expressions will be evaluated)
+ * const result = await executor.execute(task, workflowState, activityOutputs);
+ * ```
  */
-interface AXPWorkflowDefinitionMetadata {
+declare class ActivityExecutor {
+    private readonly commandService;
+    private readonly expressionEvaluator;
+    private readonly expressionScopeService;
+    private readonly translateService;
     /**
-     * Workflow name - used as unique identifier.
-     * This is the unique identifier for the workflow.
+     * Execute a workflow activity with expression evaluation.
+     *
+     * Evaluates expressions in activity inputs using workflow state,
+     * then executes the activity via CommandBus.
+     *
+     * @param task - Workflow task containing activity information
+     * @param workflowState - Current workflow instance state (for expression evaluation)
+     * @param activityOutputs - Map of previous activity outputs (for expression evaluation)
+     * @returns Execution result with output and outcome
      */
-    name: string;
+    execute(task: AXPWorkflowTask, workflowState?: AXPWorkflowInstanceState, activityOutputs?: Map<string, any> | Record<string, any>): Promise<ActivityExecutionResult>;
     /**
-     * Display name for UI.
+     * Resolves command failure message text for workflow output: `@` keys via translate, MLS maps via resolve.
      */
-    title?: string;
+    private resolveCommandMessageTextForError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityExecutor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActivityExecutor>;
+}
+
+/**
+ * Workflow expression evaluation context.
+ * Contains workflow state data needed for expression evaluation.
+ */
+interface WorkflowExpressionContext {
+    /** Workflow input values */
+    inputs: Record<string, any>;
+    /** Workflow state variables */
+    variables: Record<string, any>;
+    /** Previous activity outputs (activityId -> output) */
+    outputs: Record<string, any>;
+}
+/**
+ * Workflow Expression Scope Service
+ *
+ * Shared service for building expression evaluation scope from workflow data.
+ * Used by both Local Engine and Mock Runtime to manage workflow data (inputs, variables, outputs).
+ *
+ * Responsibilities:
+ * - Build expression evaluation scope from workflow state
+ * - Provide context.eval() function for accessing workflow data
+ * - Manage workflow data structure (inputs, variables, outputs)
+ *
+ * This service does NOT:
+ * - Execute activities
+ * - Evaluate expressions (delegates to AXPExpressionEvaluatorService)
+ * - Manage workflow state (handled by runtime)
+ *
+ * @example
+ * ```typescript
+ * const scopeService = inject(WorkflowExpressionScopeService);
+ *
+ * // Build scope from workflow state
+ * const scope = scopeService.buildScope({
+ *   inputs: state.input || {},
+ *   variables: state.variables || {},
+ *   outputs: activityOutputs
+ * });
+ *
+ * // Or build from state directly
+ * const scope = scopeService.buildScopeFromState(state, activityOutputs);
+ * ```
+ */
+declare class WorkflowExpressionScopeService {
     /**
-     * Description of what the workflow does.
+     * Collect dot-notation key-value pairs from nested objects so that e.g.
+     * { metadata: { "metadata.questionnaire.id": "x" } } becomes { "metadata.questionnaire.id": "x" } at root.
+     * Top-level non-dot keys are kept as-is.
      */
-    description?: string;
+    private flattenDotKeysFromTree;
     /**
-     * Category for grouping in toolbox.
+     * Expand flat keys with dots into nested objects.
+     * e.g. { "metadata.questionnaire.id": "x" } -> { metadata: { questionnaire: { id: "x" } } }.
      */
-    category?: string;
+    private expandDotKeys;
     /**
-     * Icon name or class.
+     * Normalize workflow input so that flat dot-notation keys (e.g. from form schema
+     * "metadata.questionnaire.id") become nested for expression access (inputs.metadata.questionnaire.id).
      */
-    icon?: string;
+    private normalizeInputs;
     /**
-     * Whether this workflow is browsable in the toolbox.
-     * Default: true
+     * Build expression evaluation scope for workflow activities.
+     *
+     * Provides workflow-specific data (inputs, variables, outputs) and context.eval() function.
+     * Other data (session, current user, etc.) are provided by expression evaluator scope providers.
+     *
+     * Scope includes:
+     * - inputs: Workflow input values (accessible as inputs.propertyName)
+     * - variables: Workflow state variables (accessible as variables.propertyName or vars.propertyName)
+     * - outputs: Previous activity outputs (accessible as outputs.activityId)
+     * - context.eval(path): Function to access nested properties from workflow data
+     *
+     * Expressions can use:
+     * - {{inputs.userName}} - Direct access to workflow input
+     * - {{variables.someVar}} or {{vars.someVar}} - Direct access to workflow variable
+     * - {{outputs.activityId.property}} - Direct access to previous activity output
+     * - {{context.eval("inputs.userName")}} - Access via context.eval (supports nested paths)
+     * - {{context.eval("variables.someVar")}} - Access variables via context.eval
+     * - {{context.eval("outputs.activityId.property")}} - Access outputs via context.eval
+     * - {{session.currentUser().name}} - Access current user via expression evaluator scope providers
+     *
+     * The context.eval() function provides a unified way to access all workflow data,
+     * similar to how entity-detail-list uses context.eval() to access parent data.
+     *
+     * @param context - Workflow expression context containing inputs, variables, and outputs
+     * @returns Expression evaluator scope with workflow data and context.eval() function
      */
-    isBrowsable?: boolean;
+    buildScope(context: WorkflowExpressionContext): AXPExpressionEvaluatorScope;
     /**
-     * Version number.
+     * Build expression evaluation scope from workflow instance state.
+     *
+     * Convenience method that extracts data from AXPWorkflowInstanceState.
+     *
+     * @param state - Workflow instance state
+     * @param activityOutputs - Map of activity outputs (activityId -> output)
+     * @returns Expression evaluator scope with workflow data and context.eval() function
      */
-    version?: number;
+    buildScopeFromState(state: AXPWorkflowInstanceState, activityOutputs?: Map<string, any> | Record<string, any>): AXPExpressionEvaluatorScope;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowExpressionScopeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkflowExpressionScopeService>;
+}
+
+/** Context passed after a workflow step completes (resume, start, or interactive chain). */
+interface AXPWorkflowContinuationStepContext {
+    instanceId: string;
+    /** Consumed bookmark id from the task board (when known). */
+    completedBookmarkId?: string;
+    /** Activity id that just completed (human-task or interactive step). */
+    completedActivityId?: string;
+    /** Resume outcome that completed the step (e.g. start-fill, Submitted, Saved). */
+    resumeOutcome?: string;
+    /** Next pending task returned by the engine / workflow manager (when known). */
+    pendingNextTask?: AXPWorkflowTask | null;
+}
+/**
+ * Result of a continuation prompt in the current start/resume cycle.
+ * Used by {@link AXPWorkflowManager} to avoid duplicate dialogs in the same cycle.
+ */
+type AXPWorkflowContinuationOfferResult = 'not-offered' | 'confirmed' | 'declined';
+/**
+ * Optional hook: offer the current user to continue to the next workflow step.
+ * Implemented by workflow-management (task board UX); invoked from {@link AXPWorkflowManager}.
+ */
+interface AXPWorkflowContinuationHook {
     /**
-     * Whether this workflow is published.
+     * Before running an inline interactive activity chain (sign-off, forms, etc.).
+     * Return `declined` to skip executing that chain in this resume/start call.
      */
-    isPublished?: boolean;
+    offerBeforeInteractiveFlow?(context: AXPWorkflowContinuationStepContext): Promise<AXPWorkflowContinuationOfferResult>;
+    /** After resume/start when the next human-task is on the task board, or no before-offer ran. */
+    offerAfterWorkflowStep?(context: AXPWorkflowContinuationStepContext): Promise<AXPWorkflowContinuationOfferResult | void>;
+}
+declare const AXP_WORKFLOW_CONTINUATION_HOOK: InjectionToken<AXPWorkflowContinuationHook>;
+/** When true on resume `userInput`, skips the post-step continuation dialog (auto-advance). */
+declare const AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY = "_suppressWorkflowContinuation";
+declare function isWorkflowContinuationSuppressed(userInput: unknown): boolean;
+
+/**
+ * Frontend step executed inline (dialog/popup), not suspended on the task board.
+ * Derived from execution mode and task-board activity types — no per-activity hardcoding.
+ */
+declare function axpIsWorkflowInlineFrontendTask(task: AXPWorkflowTask | null | undefined): boolean;
+/** @deprecated Use {@link axpIsWorkflowInlineFrontendTask}. */
+declare function axpIsWorkflowInteractiveFrontendTask(task: AXPWorkflowTask | null | undefined): boolean;
+/** Resolved before-interactive behavior from task metadata (set by engine from activity definition). */
+declare function axpResolveWorkflowContinuationBeforeInteractive(task: AXPWorkflowTask | null | undefined): AXPWorkflowContinuationBeforeInteractive;
+/**
+ * Whether to skip the pre-interactive "continue?" prompt based on activity metadata.
+ * Assignee-specific rules are applied in workflow-management (needs session).
+ */
+declare function axpShouldSkipBeforeInteractiveFromMetadata(behavior: AXPWorkflowContinuationBeforeInteractive, completedWasHumanTask: boolean): boolean;
+/**
+ * Whether to show a "continue?" prompt before running inline frontend activities.
+ * Skips when the user already resumed a task-board step (primary action / resume).
+ */
+declare function axpShouldOfferBeforeInteractiveFlow(context: AXPWorkflowContinuationStepContext): boolean;
+/**
+ * Whether the workflow advanced enough to consider a continuation prompt.
+ * Includes pending interactive steps when inbox bookmarks are already consumed.
+ */
+declare function axpShouldOfferWorkflowContinuationAfterStep(context: AXPWorkflowContinuationStepContext, activeBookmarkActivityIds: string[]): boolean;
+
+/**
+ * Workflow Category - Extends AXPCategoryEntity for consistency and performance
+ *
+ * Inherited properties from AXPCategoryEntity:
+ * - id: string                   - Unique identifier
+ * - title: string                - Display name
+ * - description?: string         - Category description
+ * - parentId?: string            - Parent category ID
+ * - childrenCount: number        - Direct child categories count (enables lazy loading)
+ * - itemsCount?: number          - Direct workflows count
+ * - totalChildrenCount?: number  - Total nested categories (optional, for analytics)
+ * - totalItemsCount?: number     - Total workflows in tree (optional, for analytics)
+ */
+interface AXPWorkflowCategory extends AXPCategoryEntity {
 }
 type AXPWorkflowProviderToken = AXPWorkflowProvider | Promise<AXPWorkflowProvider>;
 declare const AXP_WORKFLOW_PROVIDER: InjectionToken<AXPWorkflowProviderToken[]>;
@@ -1861,15 +1863,16 @@ interface AXPWorkflowProvider {
     /**
      * Get list of workflow definitions for a category.
      * @param categoryId - Category ID to filter workflows
-     * @returns Promise of workflow definition metadata array
+     * @returns Promise of workflow definition array
      */
-    getList(categoryId: string): Promise<AXPWorkflowDefinitionMetadata[]>;
+    getList(categoryId: string): Promise<AXPWorkflowDefinition[]>;
     /**
-     * Get workflow definition metadata by name (unique identifier).
+     * Get full workflow definition by name (unique identifier).
+     * Used by workflow engines for execution and UI for metadata.
      * @param name - Workflow name (unique identifier)
-     * @returns Promise of workflow definition metadata or undefined if not found
+     * @returns Promise of full workflow definition or null if not found
      */
-    getById(name: string): Promise<AXPWorkflowDefinitionMetadata | undefined>;
+    getByName(name: string): Promise<AXPWorkflowDefinition | null>;
 }
 type AXPWorkflowCategoryProviderToken = AXPWorkflowCategoryProvider | Promise<AXPWorkflowCategoryProvider>;
 declare const AXP_WORKFLOW_CATEGORY_PROVIDER: InjectionToken<AXPWorkflowCategoryProviderToken[]>;
@@ -1940,18 +1943,18 @@ declare class AXPWorkflowDefinitionService {
      * - Returns cached result on subsequent calls
      *
      * @param categoryId - Category ID to get workflow definitions from
-     * @returns Array of workflow definition metadata
+     * @returns Array of workflow definitions
      */
-    getWorkflowsByCategoryId(categoryId: string): Promise<AXPWorkflowDefinitionMetadata[]>;
+    getWorkflowsByCategoryId(categoryId: string): Promise<AXPWorkflowDefinition[]>;
     /**
-     * Get single workflow definition metadata by name with O(1) lookup
+     * Get single workflow definition by name with O(1) lookup
      *
      * Optimization: Uses Map for instant retrieval
      *
      * @param name - Workflow name (unique identifier)
-     * @returns Workflow definition metadata or undefined if not found
+     * @returns Workflow definition or undefined if not found
      */
-    getWorkflowByName(name: string): Promise<AXPWorkflowDefinitionMetadata | undefined>;
+    getWorkflowByName(name: string): Promise<AXPWorkflowDefinition | undefined>;
     /**
      * Get category ID containing a specific workflow definition
      *
@@ -2015,5 +2018,5 @@ declare class AXPWorkflowDefinitionService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionService>;
 }
 
-export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_PROVIDER, FrontendTaskExecutor, createWorkFlowEvent, ofType };
-export type { AXPActivity, AXPActivityCategory, AXPActivityCategoryProvider, AXPActivityCategoryProviderToken, AXPActivityDefinition, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderToken, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPCustomProperties, AXPEndpoint, AXPExceptionState, AXPExpression, AXPFlowchart, AXPGetWorkflowStateRequest, AXPInputValue, AXPMetadata, AXPOutputValue, AXPPosition, AXPResumeWorkflowRequest, AXPResumeWorkflowResponse, AXPStartWorkflowRequest, AXPStartWorkflowResponse, AXPStoredWorkflowDefinition, AXPVariableDefinition, AXPVariableModel, AXPVersionedEntity, AXPWorkflow, AXPWorkflowActionInput, AXPActivity$1 as AXPWorkflowActivity, AXPWorkflowCategory, AXPWorkflowCategoryProvider, AXPWorkflowCategoryProviderToken, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionMetadata, AXPWorkflowEngine, AXPWorkflowEvent, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowInstanceState, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowProvider, AXPWorkflowProviderToken, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityPropertyWidget, FrontendTaskExecutionResult, InputDescriptor, OutputDescriptor, WorkflowCompleteResult, WorkflowResumeResult, WorkflowStartResult };
+export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowEngineError, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_ERROR_CODES, AXP_WORKFLOW_PROVIDER, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES, ActivityExecutor, WorkflowExpressionScopeService, axpIsWorkflowInlineFrontendTask, axpIsWorkflowInteractiveFrontendTask, axpIsWorkflowTaskBoardActivityType, axpResolveWorkflowContinuationBeforeInteractive, axpShouldOfferBeforeInteractiveFlow, axpShouldOfferWorkflowContinuationAfterStep, axpShouldSkipBeforeInteractiveFromMetadata, createWorkFlowEvent, getWorkflowEngineErrorCode, getWorkflowEngineErrorInfo, isWorkflowContinuationSuppressed, ofType };
+export type { AXPActivityCategory, AXPActivityCategoryProvider, AXPActivityCategoryProviderToken, AXPActivityDefinition, AXPActivityDefinitionCategoryRef, AXPActivityDefinitionQueryResult, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderToken, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPClaimWorkflowTaskRequest, AXPClaimWorkflowTaskResponse, AXPCompletionCallbackState, AXPConnection, AXPElsaWorkflowExtensions, AXPExceptionState, AXPFrontActivityCompleteRequest, AXPFrontActivityCompleteResponse, AXPGetWorkflowStateRequest, AXPReassignWorkflowTaskToSelfRequest, AXPReassignWorkflowTaskToSelfResponse, AXPResumeWorkflowRequest, AXPResumeWorkflowResponse, AXPRevertResumeAfterDeclinedInteractiveContinuationRequest, AXPRevertResumeAfterDeclinedInteractiveContinuationResponse, AXPStartWorkflowRequest, AXPStartWorkflowResponse, AXPTaskType, AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowActivityInstance, AXPWorkflowBinding, AXPWorkflowCategory, AXPWorkflowCategoryProvider, AXPWorkflowCategoryProviderToken, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowContinuationBeforeInteractive, AXPWorkflowContinuationHook, AXPWorkflowContinuationMetadata, AXPWorkflowContinuationOfferResult, AXPWorkflowContinuationStepContext, AXPWorkflowDefinition, AXPWorkflowEngine, AXPWorkflowErrorCode, AXPWorkflowEvent, AXPWorkflowExtensions, AXPWorkflowFaultState, AXPWorkflowGraph, AXPWorkflowInstance, AXPWorkflowInstanceState, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOutputProperty, AXPWorkflowProvider, AXPWorkflowProviderToken, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityExecutionResult, WorkflowClaimTaskResult, WorkflowCompleteResult, WorkflowExpressionContext, WorkflowReassignTaskToSelfResult, WorkflowResumeResult, WorkflowStartResult };