@acorex/connectivity 20.6.0-next.1 → 20.6.0-next.3

package/fesm2022/acorex-connectivity-mock.mjs

@@ -11,12 +11,13 @@ import { RootConfig, AXMUsersEntityService, AXMPolicyService } from '@acorex/mod
 import { Router } from '@angular/router';
 import { of, delay, filter, take, map, throttleTime } from 'rxjs';
 import { AXMPermissionsKeys, RootConfig as RootConfig$8, AXMFormTemplateTypes } from '@acorex/modules/form-template-management';
-import { AXMPermissionsKeys as AXMPermissionsKeys$1, RootConfig as RootConfig$p } from '@acorex/modules/help-desk';
+import { AXMPermissionsKeys as AXMPermissionsKeys$1, RootConfig as RootConfig$q } from '@acorex/modules/help-desk';
 import { RootConfig as RootConfig$1 } from '@acorex/modules/calendar-management';
 import { AXPFileStorageStatus, AXPFileStorageService, AXVChangeType as AXVChangeType$1, AXP_SEARCH_PROVIDER, AXPLockService, AXPVersioningService, AXPAppVersionService } from '@acorex/platform/common';
 import Dexie from 'dexie';
 import { AXFileService } from '@acorex/core/file';
 import { AXPActivityProviderService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXPWorkflowExecutionService } from '@acorex/platform/workflow';
+import { AXPCommandService, provideCommandSetups, provideQuerySetups, AXPQueryService, AXPRuntimeModule } from '@acorex/platform/runtime';
 import { RootConfig as RootConfig$2 } from '@acorex/modules/contact-management';
 import { RootConfig as RootConfig$3 } from '@acorex/modules/content-management';
 import { AXMChatManagementService, AXMChatRealtimeService, AXMCommentManagementService, AXMCommentRealtimeService, RootConfig as RootConfig$4 } from '@acorex/modules/conversation';
@@ -25,7 +26,6 @@ import { AXPTaskBoardShortcut, AXPTaskBoardWidget, RootConfig as RootConfig$k, A
 import { AXPMyNotificationDashboardWidget, RootConfig as RootConfig$e, AXMNotificationEntityServiceImpl, AXMNotificationEntityService } from '@acorex/modules/notification-management';
 import { RootConfig as RootConfig$6, AXMMetaDataDefinitionService } from '@acorex/modules/data-management';
 import { get, upperFirst, set } from 'lodash-es';
-import { provideQuerySetups, AXPCommandService, provideCommandSetups, AXPQueryService, AXPRuntimeModule } from '@acorex/platform/runtime';
 import { AXMDistributionServiceImpl, AXMDocumentService, AXMDistributionInteractionService, RootConfig as RootConfig$7, AXMFolderServiceImpl, AXMDocumentServiceImpl, AXMReviewService, AXMReviewServiceImpl, AXMDistributionInteractionServiceImpl, AXMFolderService, AXMDistributionService } from '@acorex/modules/document-management';
 import { AXDataSource } from '@acorex/cdk/common';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
@@ -44,10 +44,11 @@ import { RootConfig as RootConfig$i } from '@acorex/modules/project-management';
 import * as i1 from '@acorex/components/dialog';
 import * as i2 from '@acorex/core/translation';
 import { RootConfig as RootConfig$l } from '@acorex/modules/training-management';
+import { RootConfig as RootConfig$m } from '@acorex/modules/workflow-management';
 import { AXCalendarService } from '@acorex/core/date-time';
-import { RootConfig as RootConfig$m } from '@acorex/modules/application-management';
-import { RootConfig as RootConfig$n } from '@acorex/modules/assessment-management';
-import { RootConfig as RootConfig$o } from '@acorex/modules/customer-management';
+import { RootConfig as RootConfig$n } from '@acorex/modules/application-management';
+import { RootConfig as RootConfig$o } from '@acorex/modules/assessment-management';
+import { RootConfig as RootConfig$p } from '@acorex/modules/customer-management';
 import { AXCExternalAuthorizationService } from '@acorex/connectivity/utils';
 
 class AXCUserPassStrategyMock extends AXPAuthStrategy {
@@ -1516,7 +1517,7 @@ function computeFileDiff(prev, next, basePath, push) {
 }
 //#endregion
 //#region ----   Service   ----
-class VersioningService {
+class AXCVersioningService {
     constructor() {
         this.db = axVersionDB;
         this.fileStorage = inject(AXPFileStorageService);
@@ -1613,10 +1614,10 @@ class VersioningService {
             newValue: d.newValue,
         }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: VersioningService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: VersioningService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCVersioningService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCVersioningService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: VersioningService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCVersioningService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2665,8 +2666,120 @@ class AXCActivityProvider {
             },
         });
         // ============================================
+        // SECURITY ACTIVITIES
+        // ============================================
+        context.registerActivity({
+            key: 'workflow-activity:check-permission',
+            descriptor: {
+                type: 'workflow-activity:check-permission',
+                displayName: 'Check Permission',
+                description: 'Checks if current user has specific permission',
+                category: 'Security',
+                icon: 'fa-light fa-shield-check',
+                executionMode: 'backend', // Backend activity - permission check on server
+                inputs: [
+                    {
+                        name: 'permission',
+                        title: 'Permission',
+                        description: 'Permission key to check (e.g., "Users.Create")',
+                        schema: {
+                            dataType: 'string',
+                        },
+                        validations: [{ rule: 'required' }],
+                    },
+                    {
+                        name: 'userId',
+                        title: 'User ID',
+                        description: 'User ID to check (optional, defaults to current user)',
+                        schema: {
+                            dataType: 'string',
+                        },
+                    },
+                ],
+                outputs: [
+                    {
+                        name: 'hasPermission',
+                        title: 'Has Permission',
+                        description: 'Whether user has the permission',
+                        schema: {
+                            dataType: 'boolean',
+                        },
+                    },
+                ],
+                outcomes: ['HasPermission', 'NoPermission'],
+                isBrowsable: true,
+                isContainer: false,
+            },
+        });
+        // ============================================
         // FORM ACTIVITIES
         // ============================================
+        context.registerActivity({
+            key: 'workflow-activity:show-dialog',
+            descriptor: {
+                type: 'workflow-activity:show-dialog',
+                displayName: 'Show Dialog',
+                description: 'Shows a dialog with form or custom content',
+                category: 'Dialog',
+                icon: 'fa-light fa-window',
+                executionMode: 'frontend', // Frontend activity - shows UI dialog
+                inputs: [
+                    {
+                        name: 'title',
+                        title: 'Title',
+                        description: 'Dialog title',
+                        schema: {
+                            dataType: 'string',
+                        },
+                    },
+                    {
+                        name: 'formDefinition',
+                        title: 'Form Definition',
+                        description: 'Form definition key or inline definition',
+                        schema: {
+                            dataType: 'string',
+                        },
+                    },
+                    {
+                        name: 'size',
+                        title: 'Size',
+                        description: 'Dialog size (sm, md, lg, xl)',
+                        schema: {
+                            dataType: 'string',
+                        },
+                    },
+                    {
+                        name: 'closeButton',
+                        title: 'Close Button',
+                        description: 'Show close button',
+                        schema: {
+                            dataType: 'boolean',
+                        },
+                    },
+                ],
+                outputs: [
+                    {
+                        name: 'formData',
+                        title: 'Form Data',
+                        description: 'Form data submitted by user',
+                        schema: {
+                            dataType: 'object',
+                        },
+                    },
+                    {
+                        name: 'action',
+                        title: 'Action',
+                        description: 'Action taken by user',
+                        schema: {
+                            dataType: 'string',
+                        },
+                    },
+                ],
+                outcomes: ['Submitted', 'Cancelled'],
+                isBrowsable: true,
+                isContainer: false,
+            },
+        });
         context.registerActivity({
             key: 'workflow-activity:show-form',
             descriptor: {
@@ -2853,7 +2966,7 @@ class AXCActivityProvider {
                 isContainer: false,
             },
         });
-        console.log('[AXPBuiltinActivityProvider] Registered 17 built-in activities');
+        console.log('[AXPBuiltinActivityProvider] Registered 19 built-in activities');
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCActivityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCActivityProvider }); }
@@ -2862,14 +2975,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
             type: Injectable
         }] });
 
-//#endregion
 //#region ----   Dexie DB   ----
 /**
- * Dexie database for workflow execution states.
+ * Dexie database for workflow instances.
  */
 class AXCWorkflowExecutionDB extends Dexie {
     constructor() {
         super('ACoreXWorkflowExecutions');
+        this.version(2).stores({
+            instances: 'id, definitionId, status, subStatus, createdAt, updatedAt',
+        });
+        // Migration from v1 to v2: clear old executions table
         this.version(1).stores({
             executions: 'executionId, workflowId, status, currentStepId, lastUpdated',
         });
@@ -2899,13 +3015,15 @@ class AXCWorkflowExecutionService {
     constructor() {
         this.db = axWorkflowExecutionDB;
         this.activityProviderService = inject(AXPActivityProviderService);
+        this.commandService = inject(AXPCommandService);
     }
     /**
      * Start a new workflow execution.
+     * Creates a workflow instance and stores it in IndexedDB.
      */
     async startExecution(request) {
-        const executionId = AXPDataGenerator.uuid();
-        const now = new Date();
+        const instanceId = AXPDataGenerator.uuid();
+        const now = new Date().toISOString();
         // Get workflow definition to find first step
         const workflowResponse = await this.getWorkflowDefinition({
             workflowId: request.workflowId
@@ -2913,129 +3031,188 @@ class AXCWorkflowExecutionService {
         if (!workflowResponse.workflow) {
             throw new Error(`Workflow definition not found: ${request.workflowId}`);
         }
-        // Find first step (root activity)
-        const rootActivity = workflowResponse.workflow.root;
-        const firstStepId = rootActivity.id || 'root';
-        const state = {
-            executionId,
-            workflowId: request.workflowId,
-            status: 'running',
-            currentStepId: firstStepId, // Set first step as current
-            variables: {},
-            input: request.input || {},
-            lastUpdated: now,
-        };
-        // Store in IndexedDB (executionId is primary key)
-        // Convert Date to ISO string for IndexedDB storage
-        const stateToStore = {
-            ...state,
-            lastUpdated: state.lastUpdated.toISOString(),
-        };
-        await this.db.executions.add(stateToStore, state.executionId);
-        // Return first task metadata (without full workflow definition)
-        const pendingTask = rootActivity ? this.createTaskFromStep(rootActivity, state) : null;
-        return {
-            executionId,
-            state,
-            pendingTask
-        };
-    }
-    /**
-     * Execute a backend activity.
-     *
-     * In mock implementation, this simulates backend activity execution.
-     * For real backend activities (execute-command, execute-query, set-variable),
-     * you would typically make an HTTP call. In mock, we just update state.
-     */
-    async executeBackendActivity(request) {
-        // Get current state
-        const state = await this.getExecutionState({
-            executionId: request.executionId,
+        const workflow = workflowResponse.workflow;
+        // Find first step from Flowchart (activity with no incoming connections)
+        const flowchart = workflow.root;
+        const activities = flowchart.activities || [];
+        const connections = flowchart.connections || [];
+        // Build connection map: target -> source[]
+        const incomingConnections = new Map();
+        connections.forEach((conn) => {
+            const targetId = conn.target.activity;
+            if (!incomingConnections.has(targetId)) {
+                incomingConnections.set(targetId, []);
+            }
+            incomingConnections.get(targetId).push(conn.source.activity);
         });
-        if (!state) {
-            throw new Error(`Workflow execution not found: ${request.executionId}`);
+        // Find root activity (activity with no incoming connections, or first activity)
+        let firstActivity = null;
+        for (const activity of activities) {
+            if (!incomingConnections.has(activity.id)) {
+                firstActivity = activity;
+                break;
+            }
         }
-        // Get workflow definition to find activity details
-        const workflowResponse = await this.getWorkflowDefinition({
-            workflowId: request.workflowId
-        });
-        const workflow = workflowResponse.workflow;
-        // Find current activity in workflow
-        const currentActivity = this.findActivityInWorkflow(workflow.root, request.activityId);
-        if (!currentActivity) {
-            throw new Error(`Activity '${request.activityId}' not found in workflow '${request.workflowId}'`);
-        }
-        // Execute backend activity using the new backend activity executor
-        const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
-        // Update state variables with activity output
-        const updatedVariables = {
-            ...state.variables,
-            ...executionResult.output
+        // If no root found, use first activity
+        if (!firstActivity && activities.length > 0) {
+            firstActivity = activities[0];
+        }
+        const firstStepId = firstActivity?.id || 'root';
+        // Create workflow state
+        const workflowState = {
+            id: `state-${instanceId}`,
+            definitionId: workflow.definitionId,
+            definitionVersion: workflow.version,
+            correlationId: null,
+            status: 'Running',
+            subStatus: 'Executing',
+            bookmarks: [],
+            incidents: [],
+            fault: null,
+            completionCallbacks: [],
+            activityExecutionContexts: firstActivity ? [{
+                    id: `ctx-${firstStepId}`,
+                    parentContextId: null,
+                    scheduledActivityNodeId: firstStepId,
+                    ownerActivityNodeId: null,
+                    properties: {},
+                    activityState: null,
+                    dynamicVariables: [],
+                    status: 'Running',
+                    isExecuting: false,
+                    faultCount: 0,
+                    startedAt: now,
+                    completedAt: null,
+                    tag: null
+                }] : [],
+            input: request.input || {},
+            output: {},
+            properties: {},
+            createdAt: now,
+            updatedAt: now,
+            finishedAt: null
         };
-        // Find next task based on outcomes and outcomeConnections
-        let nextTask = null;
-        let nextStepId = undefined;
-        const outcome = Object.keys(executionResult.outcomes)[0];
-        if (currentActivity && currentActivity.outcomeConnections) {
-            // Find connection for this outcome
-            const connection = currentActivity.outcomeConnections.find((conn) => conn.outcome === outcome);
-            if (connection && connection.targetNodeId) {
-                const targetActivity = this.findActivityInWorkflow(workflow.root, connection.targetNodeId);
-                if (targetActivity) {
-                    nextStepId = targetActivity.id || connection.targetNodeId;
-                    nextTask = this.createTaskFromStep(targetActivity, state);
-                }
+        // Create workflow instance
+        const instance = {
+            $schema: 'https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json',
+            id: instanceId,
+            definitionId: workflow.definitionId,
+            definitionVersionId: workflow.id,
+            version: workflow.version,
+            parentWorkflowInstanceId: null,
+            workflowState,
+            status: 'Running',
+            subStatus: 'Executing',
+            correlationId: null,
+            name: workflow.name || null,
+            incidentCount: 0,
+            createdAt: now,
+            updatedAt: now,
+            finishedAt: null
+        };
+        // Store instance in IndexedDB
+        await this.db.instances.add(instance, instance.id);
+        // Convert to execution state for response
+        let state = this.instanceToExecutionState(instance);
+        // 🎯 KEY LOGIC: Execute all backend activities until we reach a frontend activity
+        let currentActivity = firstActivity;
+        let executionCount = 0;
+        const maxExecutions = 100; // Prevent infinite loops
+        while (currentActivity && executionCount < maxExecutions) {
+            executionCount++;
+            // Map activity type to ACoreX format
+            let activityType = currentActivity.type;
+            if (activityType.startsWith('Elsa.')) {
+                let type = activityType.replace(/^Elsa\./, '');
+                type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+                activityType = `workflow-activity:${type}`;
             }
+            // Determine execution mode
+            const executionMode = this.determineExecutionMode(activityType, currentActivity);
+            // If frontend activity → stop and return as pendingTask
+            if (executionMode === 'frontend') {
+                const pendingTask = this.createTaskFromActivity(currentActivity, state);
+                // Update state to suspended (waiting for frontend)
+                state = {
+                    ...state,
+                    status: 'suspended',
+                    currentStepId: currentActivity.id,
+                };
+                await this.updateInstanceFromExecutionState(instanceId, state);
+                return {
+                    executionId: instanceId,
+                    state,
+                    pendingTask
+                };
+            }
+            // Backend activity → execute it
+            console.log(`[WorkflowExecutionService] Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
+            const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
+            // Update variables with output
+            state = {
+                ...state,
+                variables: {
+                    ...state.variables,
+                    ...executionResult.output
+                },
+                currentStepId: currentActivity.id,
+                lastUpdated: new Date()
+            };
+            // Find next activity based on outcome
+            const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
+            const nextConnection = connections.find((conn) => conn.source.activity === currentActivity.id &&
+                (conn.source.port === outcome || (!conn.source.port && outcome === 'Done')));
+            if (!nextConnection) {
+                // No next activity → workflow completed
+                state = {
+                    ...state,
+                    status: 'completed',
+                    currentStepId: undefined,
+                    output: state.variables
+                };
+                await this.updateInstanceFromExecutionState(instanceId, state);
+                return {
+                    executionId: instanceId,
+                    state,
+                    pendingTask: null
+                };
+            }
+            // Find next activity
+            currentActivity = this.findActivityInFlowchart(flowchart, nextConnection.target.activity);
         }
-        // Update state with next step ID
-        const updatedState = {
+        // If we exit loop without frontend activity, workflow is complete
+        state = {
             ...state,
-            status: nextStepId ? 'running' : 'completed', // If no next step, workflow is completed
-            currentStepId: nextStepId, // Set next step ID to continue workflow
-            variables: updatedVariables,
-            lastUpdated: new Date(),
-        };
-        // Update nextTask with updated state
-        if (nextTask && nextStepId) {
-            nextTask = this.createTaskFromStep(this.findActivityInWorkflow(workflow.root, nextStepId), updatedState);
-        }
-        // Save to IndexedDB (convert Date to ISO string)
-        const stateToStore = {
-            ...updatedState,
-            lastUpdated: updatedState.lastUpdated.toISOString(),
+            status: 'completed',
+            currentStepId: undefined,
+            output: state.variables
         };
-        await this.db.executions.update(state.executionId, stateToStore);
+        await this.updateInstanceFromExecutionState(instanceId, state);
         return {
-            output: executionResult.output,
-            outcomes: executionResult.outcomes,
-            nextTask,
-            state: updatedState,
+            executionId: instanceId,
+            state,
+            pendingTask: null
         };
     }
     /**
-     * Find activity in workflow tree recursively.
+     * Find activity in Flowchart by ID.
      */
-    findActivityInWorkflow(activity, activityId) {
-        const activityAny = activity;
-        if (activityAny.id === activityId) {
-            return activity;
-        }
-        if (activityAny.children && Array.isArray(activityAny.children)) {
-            for (const child of activityAny.children) {
-                const found = this.findActivityInWorkflow(child, activityId);
-                if (found) {
-                    return found;
-                }
-            }
-        }
-        return null;
+    findActivityInFlowchart(flowchart, activityId) {
+        const activities = flowchart.activities || [];
+        return activities.find(a => a.id === activityId) || null;
     }
     /**
      * Resume a suspended workflow execution.
+     *
+     * After frontend completes its task:
+     * 1. Validates taskToken
+     * 2. Finds next activity based on outcome
+     * 3. Executes ALL backend activities in sequence
+     * 4. Stops at first frontend activity and returns it as pendingTask
      */
     async resumeExecution(request) {
         // Get current state
-        const state = await this.getExecutionState({
+        let state = await this.getExecutionState({
             executionId: request.executionId,
         });
         if (!state) {
@@ -3044,78 +3221,139 @@ class AXCWorkflowExecutionService {
         if (state.status !== 'suspended') {
             throw new Error(`Cannot resume workflow with status: ${state.status}. Expected: suspended`);
         }
-        // Find next step based on outcomeConnections and actual outcome
+        // TODO: Validate taskToken here for security
+        // For now, just verify stepId matches
+        if (state.currentStepId !== request.stepId) {
+            throw new Error(`Step mismatch: expected '${state.currentStepId}', got '${request.stepId}'`);
+        }
+        // Get workflow definition
         const workflowResponse = await this.getWorkflowDefinition({
             workflowId: state.workflowId
         });
         const workflow = workflowResponse.workflow;
-        // Find current step in workflow
-        const currentStep = this.findActivityInWorkflow(workflow.root, request.stepId);
-        let nextTask = null;
-        let nextStepId = undefined;
-        if (currentStep && currentStep.outcomeConnections) {
-            // Find connection for the outcome
-            const connection = currentStep.outcomeConnections.find((conn) => conn.outcome === request.outcome);
-            if (connection && connection.targetNodeId) {
-                const targetStep = this.findActivityInWorkflow(workflow.root, connection.targetNodeId);
-                if (targetStep) {
-                    nextStepId = targetStep.id || connection.targetNodeId;
-                    nextTask = this.createTaskFromStep(targetStep, state);
-                }
-            }
-        }
-        // Update state with outcome and user input
-        const updatedVariables = {
-            ...state.variables,
-            [`${request.stepId}_outcome`]: request.outcome,
-            [`${request.stepId}_userInput`]: request.userInput || {},
-        };
-        const updatedState = {
+        const connections = workflow.root.connections || [];
+        // Update state with frontend activity outcome and user input
+        state = {
             ...state,
-            status: nextStepId ? 'running' : 'completed', // If no next step, workflow is completed
-            currentStepId: nextStepId, // Set next step ID to continue workflow
-            variables: updatedVariables,
-            lastUpdated: new Date(),
-        };
-        // Save to IndexedDB (convert Date to ISO string)
-        const stateToStore = {
-            ...updatedState,
-            lastUpdated: updatedState.lastUpdated.toISOString(),
+            variables: {
+                ...state.variables,
+                [`${request.stepId}_outcome`]: request.outcome,
+                [`${request.stepId}_userInput`]: request.userInput || {},
+            },
+            lastUpdated: new Date()
         };
-        await this.db.executions.update(state.executionId, stateToStore);
-        // Update nextTask with updated state
-        if (nextTask && nextStepId) {
-            nextTask = this.createTaskFromStep(this.findActivityInWorkflow(workflow.root, nextStepId), updatedState);
+        // Find next activity based on outcome from frontend
+        const nextConnection = connections.find((conn) => conn.source.activity === request.stepId &&
+            (conn.source.port === request.outcome || (!conn.source.port && request.outcome === 'Done')));
+        if (!nextConnection) {
+            // No next activity → workflow completed
+            state = {
+                ...state,
+                status: 'completed',
+                currentStepId: undefined,
+                output: state.variables
+            };
+            await this.updateInstanceFromExecutionState(request.executionId, state);
+            return {
+                output: { outcome: request.outcome, userInput: request.userInput },
+                outcomes: { [request.outcome]: true },
+                nextTask: null,
+                state
+            };
         }
-        // Output based on outcome
-        const output = {
-            outcome: request.outcome,
-            stepId: request.stepId,
-            userInput: request.userInput,
-            resumedAt: new Date().toISOString(),
+        // 🎯 KEY LOGIC: Execute all backend activities until we reach next frontend activity
+        let currentActivity = this.findActivityInFlowchart(workflow.root, nextConnection.target.activity);
+        let executionCount = 0;
+        const maxExecutions = 100;
+        while (currentActivity && executionCount < maxExecutions) {
+            executionCount++;
+            // Map activity type
+            let activityType = currentActivity.type;
+            if (activityType.startsWith('Elsa.')) {
+                let type = activityType.replace(/^Elsa\./, '');
+                type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+                activityType = `workflow-activity:${type}`;
+            }
+            // Determine execution mode
+            const executionMode = this.determineExecutionMode(activityType, currentActivity);
+            // If frontend activity → stop and return as pendingTask
+            if (executionMode === 'frontend') {
+                const pendingTask = this.createTaskFromActivity(currentActivity, state);
+                state = {
+                    ...state,
+                    status: 'suspended',
+                    currentStepId: currentActivity.id,
+                };
+                await this.updateInstanceFromExecutionState(request.executionId, state);
+                return {
+                    output: { outcome: request.outcome, userInput: request.userInput },
+                    outcomes: { [request.outcome]: true },
+                    nextTask: pendingTask,
+                    state
+                };
+            }
+            // Backend activity → execute it
+            console.log(`[WorkflowExecutionService] Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
+            const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
+            // Update variables with output
+            state = {
+                ...state,
+                variables: {
+                    ...state.variables,
+                    ...executionResult.output
+                },
+                currentStepId: currentActivity.id,
+                lastUpdated: new Date()
+            };
+            // Find next activity based on outcome
+            const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
+            const nextConn = connections.find((conn) => conn.source.activity === currentActivity.id &&
+                (conn.source.port === outcome || (!conn.source.port && outcome === 'Done')));
+            if (!nextConn) {
+                // No next activity → workflow completed
+                state = {
+                    ...state,
+                    status: 'completed',
+                    currentStepId: undefined,
+                    output: state.variables
+                };
+                await this.updateInstanceFromExecutionState(request.executionId, state);
+                return {
+                    output: state.variables,
+                    outcomes: { Done: true },
+                    nextTask: null,
+                    state
+                };
+            }
+            // Find next activity
+            currentActivity = this.findActivityInFlowchart(workflow.root, nextConn.target.activity);
+        }
+        // If we exit loop, workflow is complete
+        state = {
+            ...state,
+            status: 'completed',
+            currentStepId: undefined,
+            output: state.variables
         };
+        await this.updateInstanceFromExecutionState(request.executionId, state);
         return {
-            output,
-            outcomes: {
-                [request.outcome]: true,
-            },
-            nextTask, // Next task from outcomeConnections
-            state: updatedState,
+            output: state.variables,
+            outcomes: { Done: true },
+            nextTask: null,
+            state
         };
     }
     /**
      * Get current workflow execution state.
      */
     async getExecutionState(request) {
-        const state = await this.db.executions.get(request.executionId);
-        if (!state) {
+        // Get instance from IndexedDB
+        const instance = await this.getInstance(request.executionId);
+        if (!instance) {
             throw new Error(`Workflow execution not found: ${request.executionId}`);
         }
-        // Convert Date string back to Date object (IndexedDB stores as ISO string)
-        return {
-            ...state,
-            lastUpdated: new Date(state.lastUpdated),
-        };
+        // Convert instance to execution state
+        return this.instanceToExecutionState(instance);
     }
     /**
      * Get workflow definition by ID.
@@ -3131,10 +3369,28 @@ class AXCWorkflowExecutionService {
         const storedWorkflow = localStorage.getItem(`workflow:${request.workflowId}`);
         if (storedWorkflow) {
             try {
-                const elsaDefinition = JSON.parse(storedWorkflow);
-                // Convert Elsa Workflow Definition v3.0.0 to AXPWorkflowEngine format
-                const workflow = this.convertElsaToWorkflowEngine(elsaDefinition);
-                return { workflow };
+                const workflowDefinition = JSON.parse(storedWorkflow);
+                // Validate format
+                if (workflowDefinition.root && workflowDefinition.root.type === 'Elsa.Flowchart') {
+                    return { workflow: workflowDefinition };
+                }
+                // If stored in materializerContext.stringData, parse it
+                if (workflowDefinition.materializerContext?.stringData) {
+                    try {
+                        const rootFlowchart = JSON.parse(workflowDefinition.materializerContext.stringData);
+                        if (rootFlowchart.type === 'Elsa.Flowchart') {
+                            return {
+                                workflow: {
+                                    ...workflowDefinition,
+                                    root: rootFlowchart
+                                }
+                            };
+                        }
+                    }
+                    catch (error) {
+                        console.warn('Failed to parse stringData from materializerContext:', error);
+                    }
+                }
             }
             catch (error) {
                 console.warn(`Failed to parse stored workflow ${request.workflowId}:`, error);
@@ -3142,181 +3398,39 @@ class AXCWorkflowExecutionService {
         }
         // If not found in localStorage, return a default mock workflow
         // In production, this would be an HTTP call to backend
+        const now = new Date().toISOString();
         const defaultWorkflow = {
+            $schema: 'https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json',
             id: request.workflowId,
-            name: `Workflow ${request.workflowId}`,
+            definitionId: request.workflowId,
+            createdAt: now,
             version: 1,
-            root: {
-                type: 'workflow-activity:sequence',
-                name: 'Root Sequence',
-                execute: async () => ({ output: undefined, outcomes: { Done: true } })
+            isLatest: true,
+            isPublished: false,
+            isReadonly: false,
+            isSystem: false,
+            name: `Workflow ${request.workflowId}`,
+            description: 'Default mock workflow',
+            variables: [],
+            inputs: [],
+            outputs: [],
+            outcomes: ['Done'],
+            customProperties: {},
+            options: {
+                usableAsActivity: false,
+                autoUpdateConsumingWorkflows: false
             },
-            activities: []
-        };
-        return { workflow: defaultWorkflow };
-    }
-    /**
-     * Convert Elsa Workflow Definition v3.0.0 to AXPWorkflowEngine format
-     * https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json
-     */
-    convertElsaToWorkflowEngine(elsaDefinition) {
-        // Extract root activity from Elsa format
-        let rootActivity;
-        if (elsaDefinition.root) {
-            // Root activity is directly available
-            rootActivity = elsaDefinition.root;
-        }
-        else if (elsaDefinition.materializerContext?.stringData) {
-            // Root activity is stored in materializerContext.stringData
-            try {
-                rootActivity = JSON.parse(elsaDefinition.materializerContext.stringData);
-            }
-            catch (error) {
-                console.warn('Failed to parse stringData from materializerContext:', error);
-                // Fallback to default
-                rootActivity = {
-                    type: 'workflow-activity:sequence',
-                    name: 'Root Sequence'
-                };
+            root: {
+                id: 'root-flowchart',
+                nodeId: 'root-flowchart',
+                type: 'Elsa.Flowchart',
+                version: 1,
+                activities: [],
+                connections: [],
+                variables: []
             }
-        }
-        else {
-            // Fallback to default
-            rootActivity = {
-                type: 'workflow-activity:sequence',
-                name: 'Root Sequence'
-            };
-        }
-        // Convert to AXPWorkflowEngine format
-        const workflow = {
-            id: elsaDefinition.id || elsaDefinition.definitionId || 'unknown',
-            name: elsaDefinition.name || 'Untitled Workflow',
-            description: elsaDefinition.description,
-            version: elsaDefinition.version || 1,
-            root: rootActivity,
-            activities: this.extractActivities(rootActivity)
         };
-        return workflow;
-    }
-    /**
-     * Extract all activities from root activity recursively
-     */
-    extractActivities(activity) {
-        const activities = [];
-        if (!activity) {
-            return activities;
-        }
-        // Add current activity
-        activities.push(activity);
-        // Extract from children (for sequence, parallel, etc.)
-        if (activity.children && Array.isArray(activity.children)) {
-            activity.children.forEach((child) => {
-                activities.push(...this.extractActivities(child));
-            });
-        }
-        // Extract from then/else (for if activity)
-        if (activity.then) {
-            activities.push(...this.extractActivities(activity.then));
-        }
-        if (activity.else) {
-            activities.push(...this.extractActivities(activity.else));
-        }
-        // Extract from try/catch/finally (for try-catch activity)
-        if (activity.try) {
-            activities.push(...this.extractActivities(activity.try));
-        }
-        if (activity.catch) {
-            activities.push(...this.extractActivities(activity.catch));
-        }
-        if (activity.finally) {
-            activities.push(...this.extractActivities(activity.finally));
-        }
-        // Extract from branches (for parallel activity)
-        if (activity.branches && Array.isArray(activity.branches)) {
-            activity.branches.forEach((branch) => {
-                activities.push(...this.extractActivities(branch));
-            });
-        }
-        return activities;
-    }
-    /**
-     * Execute current step from execution state.
-     *
-     * Backend handles everything: gets state, workflow definition, finds step, determines nextStep.
-     */
-    async executeCurrentStep(request) {
-        // Get current state
-        const state = await this.getExecutionState({
-            executionId: request.executionId,
-        });
-        if (!state.currentStepId) {
-            throw new Error(`No current step defined for execution: ${request.executionId}`);
-        }
-        // Get workflow definition
-        const workflowResponse = await this.getWorkflowDefinition({
-            workflowId: state.workflowId
-        });
-        if (!workflowResponse.workflow) {
-            throw new Error(`Workflow definition not found: ${state.workflowId}`);
-        }
-        // Find current step in workflow
-        const currentStep = this.findActivityInWorkflow(workflowResponse.workflow.root, state.currentStepId);
-        if (!currentStep) {
-            throw new Error(`Step '${state.currentStepId}' not found in workflow '${state.workflowId}'`);
-        }
-        // Determine execution mode from activity definition or descriptor
-        const stepAny = currentStep;
-        const executionMode = this.determineExecutionMode(stepAny.type, stepAny);
-        const isBackendActivity = executionMode === 'backend' || executionMode === 'both';
-        if (isBackendActivity) {
-            // Execute backend activity
-            const backendResponse = await this.executeBackendActivity({
-                workflowId: state.workflowId,
-                executionId: request.executionId,
-                activityType: stepAny.type,
-                activityId: state.currentStepId,
-                properties: stepAny.properties || {},
-                workflowState: {
-                    variables: state.variables,
-                    input: state.input
-                }
-            });
-            return {
-                output: backendResponse.output,
-                outcomes: backendResponse.outcomes,
-                nextTask: backendResponse.nextTask || null,
-                state: backendResponse.state
-            };
-        }
-        else {
-            // Frontend activity - return current task for frontend to execute
-            // The nextTask should be the CURRENT activity (frontend will execute it)
-            // After frontend executes, it will call resumeExecution with outcome
-            // Create task for current step (frontend will execute this)
-            const currentTask = this.createTaskFromStep(currentStep, state);
-            // Update state to indicate step is suspended (waiting for frontend execution)
-            const updatedState = {
-                ...state,
-                status: 'suspended', // Frontend activities suspend the workflow
-                lastUpdated: new Date()
-            };
-            // Save to IndexedDB
-            const stateToStore = {
-                ...updatedState,
-                lastUpdated: updatedState.lastUpdated.toISOString(),
-            };
-            await this.db.executions.update(state.executionId, stateToStore);
-            return {
-                output: {
-                    stepId: state.currentStepId,
-                    stepType: stepAny.type,
-                    properties: stepAny.properties || {}
-                },
-                outcomes: {},
-                nextTask: currentTask, // Return current task so frontend can execute it
-                state: updatedState
-            };
-        }
+        return { workflow: defaultWorkflow };
     }
     //#region ----   Task-Based Helper Methods   ----
     /**
@@ -3327,19 +3441,21 @@ class AXCWorkflowExecutionService {
         return `${executionId}:${activityId}:${Date.now()}`;
     }
     /**
-     * Determine execution mode for an activity from its descriptor.
+     * Determine execution mode for an activity.
      *
-     * First checks if activity has executionMode in its definition (from workflow JSON).
-     * If not, falls back to ActivityDescriptor from ActivityProviderService.
+     * Priority (highest to lowest):
+     * 1. Activity instance's executionMode (from AXPActivity in workflow definition)
+     * 2. ActivityDescriptor's executionMode (from ActivityProviderService)
+     * 3. Default: 'frontend'
      *
      * @param activityType - Activity type (e.g., 'workflow-activity:write-line')
-     * @param activityDefinition - Activity definition from workflow (may contain executionMode)
+     * @param activity - Activity from workflow definition (AXPActivity)
      * @returns Execution mode: 'frontend', 'backend', or 'both'
      */
-    determineExecutionMode(activityType, activityDefinition) {
-        // 1. Check if executionMode is defined in activity definition (from workflow JSON/database)
-        if (activityDefinition?.executionMode) {
-            return activityDefinition.executionMode;
+    determineExecutionMode(activityType, activity) {
+        // 1. Check if executionMode is explicitly set in activity instance (highest priority)
+        if (activity?.executionMode) {
+            return activity.executionMode;
         }
         // 2. Check ActivityDescriptor from ActivityProviderService
         const descriptor = this.activityProviderService.getDescriptor(activityType);
@@ -3350,39 +3466,117 @@ class AXCWorkflowExecutionService {
         return 'frontend';
     }
     /**
-     * Create a task from a workflow step.
+     * Create a task from a workflow activity.
      * Inspired by Temporal's Activity Task and Elsa's Bookmark pattern.
      */
-    createTaskFromStep(step, state) {
-        const stepAny = step;
-        // Get executionMode from activity definition or descriptor
-        const executionMode = this.determineExecutionMode(step.type, stepAny);
+    createTaskFromActivity(activity, state) {
+        // Extract properties from activity
+        // Activities have properties as AXPInputValue objects or primitives
+        const properties = {};
+        // Iterate through all properties of the activity
+        Object.keys(activity).forEach(key => {
+            // Skip standard Elsa fields
+            if (['id', 'nodeId', 'name', 'type', 'version', 'customProperties', 'metadata'].includes(key)) {
+                return;
+            }
+            const value = activity[key];
+            // Handle AXPInputValue format
+            if (value && typeof value === 'object' && 'typeName' in value && 'expression' in value) {
+                // It's an AXPInputValue - extract the expression value
+                if (value.expression && value.expression.value !== undefined) {
+                    properties[key] = value.expression.value;
+                }
+                else {
+                    properties[key] = null;
+                }
+            }
+            else {
+                // Direct value
+                properties[key] = value;
+            }
+        });
+        // Map activity type to ACoreX activity type
+        // Example: "Elsa.WriteLine" -> "workflow-activity:write-line"
+        let activityType = activity.type;
+        if (activityType.startsWith('Elsa.')) {
+            let type = activityType.replace(/^Elsa\./, '');
+            // Convert PascalCase to kebab-case
+            type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+            activityType = `workflow-activity:${type}`;
+        }
+        // Get executionMode from activity descriptor
+        const executionMode = this.determineExecutionMode(activityType, activity);
         return {
-            taskToken: this.generateTaskToken(state.executionId, stepAny.id),
-            activityId: stepAny.id,
-            activityType: step.type,
-            activityName: step.name,
+            taskToken: this.generateTaskToken(state.executionId, activity.id),
+            activityId: activity.id,
+            activityType,
+            activityName: activity.name || undefined,
             executionMode,
-            input: (executionMode === 'frontend' || executionMode === 'both') ? stepAny.properties : undefined,
-            config: (executionMode === 'frontend' || executionMode === 'both') ? stepAny.properties : undefined
+            input: (executionMode === 'frontend' || executionMode === 'both') ? properties : undefined,
+            config: (executionMode === 'frontend' || executionMode === 'both') ? properties : undefined
         };
     }
     //#endregion
     //#region ----   Backend Activity Executors   ----
     /**
-     * Execute backend activities locally in mock service.
-     * In production, these would be executed by the actual backend.
+     * Execute backend activities locally using CommandBus.
+     *
+     * Backend activities are registered as Commands and executed via CommandService.
+     * This provides a unified execution channel for all activities.
      */
     async executeBackendActivityLocally(activity, input, state) {
-        switch (activity.type) {
+        // Extract properties from activity
+        const properties = {};
+        Object.keys(activity).forEach(key => {
+            if (['id', 'nodeId', 'name', 'type', 'version', 'customProperties', 'metadata', 'executionMode'].includes(key)) {
+                return;
+            }
+            const value = activity[key];
+            if (value && typeof value === 'object' && 'typeName' in value && 'expression' in value) {
+                if (value.expression && value.expression.value !== undefined) {
+                    properties[key] = value.expression.value;
+                }
+                else {
+                    properties[key] = null;
+                }
+            }
+            else {
+                properties[key] = value;
+            }
+        });
+        // Map activity type to ACoreX activity type
+        let activityType = activity.type;
+        if (activityType.startsWith('Elsa.')) {
+            let type = activityType.replace(/^Elsa\./, '');
+            type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+            activityType = `workflow-activity:${type}`;
+        }
+        // Check if activity is registered as a Command
+        if (this.commandService.exists(activityType)) {
+            console.log(`[WorkflowExecutionService] Executing backend activity '${activityType}' via CommandBus`);
+            try {
+                // Execute via CommandBus
+                const result = await this.commandService.execute(activityType, properties);
+                return {
+                    output: result?.output || result,
+                    outcomes: result?.outcomes || { Done: true }
+                };
+            }
+            catch (error) {
+                console.error(`[WorkflowExecutionService] Backend activity '${activityType}' failed:`, error);
+                return {
+                    output: { error: error.message || 'Unknown error' },
+                    outcomes: { Failed: true }
+                };
+            }
+        }
+        // Fallback: Handle built-in activities that aren't Commands yet
+        console.warn(`[WorkflowExecutionService] Activity '${activityType}' not registered as Command, using fallback`);
+        switch (activityType) {
             case 'workflow-activity:set-variable':
-                return this.executeSetVariable(activity, input);
-            case 'workflow-activity:execute-command':
-                return this.executeCommandMock(activity, input);
-            case 'workflow-activity:execute-query':
-                return this.executeQueryMock(activity, input);
+                return this.executeSetVariable({ type: activityType, properties }, input);
             case 'workflow-activity:http-request':
-                return this.executeHttpRequest(activity, input);
+                return this.executeHttpRequest({ type: activityType, properties }, input);
             default:
                 return { output: null, outcomes: { Done: true } };
         }
@@ -3398,42 +3592,6 @@ class AXCWorkflowExecutionService {
             outcomes: { Done: true }
         };
     }
-    /**
-     * Execute command mock - simulates backend command execution.
-     */
-    async executeCommandMock(activity, input) {
-        // Simulate delay for backend processing
-        await new Promise(resolve => setTimeout(resolve, 500));
-        return {
-            output: {
-                commandKey: activity.properties?.commandKey,
-                success: true,
-                result: {
-                    id: 'mock-' + Date.now(),
-                    timestamp: new Date().toISOString()
-                }
-            },
-            outcomes: { Done: true }
-        };
-    }
-    /**
-     * Execute query mock - simulates backend query execution.
-     */
-    async executeQueryMock(activity, input) {
-        // Simulate delay for database query
-        await new Promise(resolve => setTimeout(resolve, 300));
-        return {
-            output: {
-                queryKey: activity.properties?.queryKey,
-                data: [
-                    { id: 1, name: 'Mock Item 1', createdAt: new Date().toISOString() },
-                    { id: 2, name: 'Mock Item 2', createdAt: new Date().toISOString() }
-                ],
-                count: 2
-            },
-            outcomes: { Done: true }
-        };
-    }
     /**
      * Execute HTTP request - makes real HTTP call.
      * Supports different HTTP methods and handles timeouts.
@@ -3499,6 +3657,117 @@ class AXCWorkflowExecutionService {
             };
         }
     }
+    //#endregion
+    //#region ----   Instance Management   ----
+    /**
+     * Convert workflow instance to execution state (for backward compatibility).
+     */
+    instanceToExecutionState(instance) {
+        const state = instance.workflowState;
+        // Find current activity from execution contexts
+        const currentContext = state.activityExecutionContexts.find(ctx => ctx.status === 'Running' && !ctx.completedAt);
+        // Map status
+        let status = 'running';
+        if (instance.status === 'Finished') {
+            if (instance.subStatus === 'Faulted') {
+                status = 'error';
+            }
+            else {
+                status = 'completed';
+            }
+        }
+        else if (instance.subStatus === 'Suspended') {
+            status = 'suspended';
+        }
+        return {
+            executionId: instance.id,
+            workflowId: instance.definitionId,
+            status,
+            currentStepId: currentContext?.scheduledActivityNodeId,
+            variables: state.properties || {},
+            input: state.input || {},
+            output: state.output || {},
+            lastUpdated: new Date(instance.updatedAt)
+        };
+    }
+    /**
+     * Update execution state in instance and save to IndexedDB.
+     */
+    async updateInstanceFromExecutionState(executionId, executionState) {
+        const instance = await this.getInstance(executionId);
+        if (!instance) {
+            throw new Error(`Workflow instance not found: ${executionId}`);
+        }
+        // Update instance from execution state
+        const now = new Date().toISOString();
+        // Map execution state status to instance status
+        let status = 'Running';
+        let subStatus = 'Executing';
+        if (executionState.status === 'completed') {
+            status = 'Finished';
+            subStatus = 'Finished';
+            instance.finishedAt = now;
+        }
+        else if (executionState.status === 'error') {
+            status = 'Finished';
+            subStatus = 'Faulted';
+            instance.finishedAt = now;
+        }
+        else if (executionState.status === 'suspended') {
+            subStatus = 'Suspended';
+        }
+        instance.status = status;
+        instance.subStatus = subStatus;
+        instance.updatedAt = now;
+        // Update workflow state
+        instance.workflowState.status = status;
+        instance.workflowState.subStatus = subStatus;
+        instance.workflowState.input = executionState.input || {};
+        instance.workflowState.output = executionState.output || {};
+        instance.workflowState.properties = executionState.variables || {};
+        instance.workflowState.updatedAt = now;
+        if (executionState.status === 'completed' || executionState.status === 'error') {
+            instance.workflowState.finishedAt = now;
+        }
+        // Update activity execution context if currentStepId changed
+        if (executionState.currentStepId) {
+            const existingContext = instance.workflowState.activityExecutionContexts.find(ctx => ctx.scheduledActivityNodeId === executionState.currentStepId);
+            if (!existingContext) {
+                // Add new context
+                instance.workflowState.activityExecutionContexts.push({
+                    id: `ctx-${executionState.currentStepId}`,
+                    parentContextId: null,
+                    scheduledActivityNodeId: executionState.currentStepId,
+                    ownerActivityNodeId: null,
+                    properties: {},
+                    activityState: null,
+                    dynamicVariables: [],
+                    status: 'Running',
+                    isExecuting: false,
+                    faultCount: 0,
+                    startedAt: now,
+                    completedAt: null,
+                    tag: null
+                });
+            }
+        }
+        // Save to IndexedDB
+        await this.updateInstance(instance);
+        return instance;
+    }
+    /**
+     * Get workflow instance from IndexedDB.
+     */
+    async getInstance(executionId) {
+        return await this.db.instances.get(executionId) || null;
+    }
+    /**
+     * Update workflow instance in IndexedDB.
+     */
+    async updateInstance(instance) {
+        instance.updatedAt = new Date().toISOString();
+        await this.db.instances.update(instance.id, instance);
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowExecutionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowExecutionService }); }
 }
@@ -3506,10 +3775,906 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
             type: Injectable
         }] });
 
+/**
+ * Mock workflow definitions for testing and demonstration.
+ */
+const workflowDefinitionMock = [
+    // Create User Workflow
+    {
+        $schema: 'https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json',
+        id: AXPDataGenerator.uuid(),
+        definitionId: 'create-user-workflow',
+        tenantId: null,
+        name: 'Create User Workflow',
+        description: 'Complete user registration workflow with permission check, form display, validation, and database save',
+        createdAt: new Date().toISOString(),
+        version: 1,
+        toolVersion: '3.2.0.0',
+        variables: [],
+        inputs: [
+            {
+                type: 'String',
+                name: 'currentUserId',
+                displayName: 'Current User ID',
+                description: 'ID of the user initiating the workflow',
+            },
+        ],
+        outputs: [
+            {
+                type: 'Object',
+                name: 'createdUser',
+                displayName: 'Created User',
+                description: 'The newly created user object',
+            },
+        ],
+        outcomes: ['Done', 'NoPermission', 'Cancelled'],
+        customProperties: {},
+        isReadonly: false,
+        isSystem: false,
+        isLatest: true,
+        isPublished: true,
+        options: {
+            usableAsActivity: false,
+            autoUpdateConsumingWorkflows: false,
+        },
+        root: {
+            id: 'root-flowchart',
+            nodeId: 'root-flowchart',
+            type: 'Elsa.Flowchart',
+            version: 1,
+            activities: [
+                {
+                    id: 'check-permission',
+                    nodeId: 'check-permission',
+                    name: 'Check User Create Permission',
+                    type: 'Elsa.CheckPermission',
+                    version: 1,
+                    executionMode: 'backend',
+                    permission: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'Users.Create',
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 100,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'show-error-toast',
+                    nodeId: 'show-error-toast',
+                    name: 'Show Permission Error',
+                    type: 'Elsa.ShowToast',
+                    version: 1,
+                    executionMode: 'frontend',
+                    message: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: "You don't have permission to create users",
+                        },
+                    },
+                    type_: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'error',
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 100,
+                                y: 250,
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'show-user-form',
+                    nodeId: 'show-user-form',
+                    name: 'Show User Registration Form',
+                    type: 'Elsa.ShowDialog',
+                    version: 1,
+                    executionMode: 'frontend',
+                    formDefinition: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'user-create-form',
+                        },
+                    },
+                    title: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'Create New User',
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 300,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'validate-email',
+                    nodeId: 'validate-email',
+                    name: 'Check Email Uniqueness',
+                    type: 'Elsa.ExecuteQuery',
+                    version: 1,
+                    executionMode: 'backend',
+                    queryKey: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'User:CheckEmailExists',
+                        },
+                    },
+                    parameters: {
+                        typeName: 'Object',
+                        expression: {
+                            type: 'JavaScript',
+                            value: "{ email: getVariable('userEmail') }",
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 500,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'show-validation-error',
+                    nodeId: 'show-validation-error',
+                    name: 'Show Email Exists Error',
+                    type: 'Elsa.ShowToast',
+                    version: 1,
+                    executionMode: 'frontend',
+                    message: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'Email already exists. Please use a different email.',
+                        },
+                    },
+                    type_: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'error',
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 500,
+                                y: 250,
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'save-user',
+                    nodeId: 'save-user',
+                    name: 'Save User to Database',
+                    type: 'Elsa.ExecuteCommand',
+                    version: 1,
+                    executionMode: 'backend',
+                    commandKey: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'User:Create',
+                        },
+                    },
+                    input: {
+                        typeName: 'Object',
+                        expression: {
+                            type: 'JavaScript',
+                            value: "{ email: getVariable('userEmail'), name: getVariable('userName'), role: getVariable('userRole') }",
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 700,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'show-success-toast',
+                    nodeId: 'show-success-toast',
+                    name: 'Show Success Message',
+                    type: 'Elsa.ShowToast',
+                    version: 1,
+                    executionMode: 'frontend',
+                    message: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'User created successfully',
+                        },
+                    },
+                    type_: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'success',
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 900,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+            ],
+            connections: [
+                {
+                    source: {
+                        activity: 'check-permission',
+                        port: 'NoPermission',
+                    },
+                    target: {
+                        activity: 'show-error-toast',
+                    },
+                },
+                {
+                    source: {
+                        activity: 'check-permission',
+                        port: 'HasPermission',
+                    },
+                    target: {
+                        activity: 'show-user-form',
+                    },
+                },
+                {
+                    source: {
+                        activity: 'show-user-form',
+                        port: 'Submitted',
+                    },
+                    target: {
+                        activity: 'validate-email',
+                    },
+                },
+                {
+                    source: {
+                        activity: 'show-user-form',
+                        port: 'Cancelled',
+                    },
+                    target: {
+                        activity: 'show-error-toast',
+                    },
+                },
+                {
+                    source: {
+                        activity: 'validate-email',
+                        port: 'Exists',
+                    },
+                    target: {
+                        activity: 'show-validation-error',
+                    },
+                },
+                {
+                    source: {
+                        activity: 'show-validation-error',
+                        port: 'Done',
+                    },
+                    target: {
+                        activity: 'show-user-form',
+                    },
+                },
+                {
+                    source: {
+                        activity: 'validate-email',
+                        port: 'Valid',
+                    },
+                    target: {
+                        activity: 'save-user',
+                    },
+                },
+                {
+                    source: {
+                        activity: 'save-user',
+                        port: 'Done',
+                    },
+                    target: {
+                        activity: 'show-success-toast',
+                    },
+                },
+            ],
+            variables: [],
+        },
+    },
+    // Simple Welcome Workflow
+    {
+        $schema: 'https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json',
+        id: AXPDataGenerator.uuid(),
+        definitionId: 'welcome-workflow',
+        tenantId: null,
+        name: 'Welcome Workflow',
+        description: 'Simple workflow to welcome new users',
+        createdAt: new Date().toISOString(),
+        version: 1,
+        toolVersion: '3.2.0.0',
+        variables: [],
+        inputs: [
+            {
+                type: 'String',
+                name: 'userName',
+                displayName: 'User Name',
+                description: 'Name of the user to welcome',
+            },
+        ],
+        outputs: [],
+        outcomes: ['Done'],
+        customProperties: {},
+        isReadonly: false,
+        isSystem: false,
+        isLatest: true,
+        isPublished: true,
+        options: {
+            usableAsActivity: false,
+            autoUpdateConsumingWorkflows: false,
+        },
+        root: {
+            id: 'root-flowchart',
+            nodeId: 'root-flowchart',
+            type: 'Elsa.Flowchart',
+            version: 1,
+            activities: [
+                {
+                    id: 'welcome-toast',
+                    nodeId: 'welcome-toast',
+                    name: 'Show Welcome Message',
+                    type: 'Elsa.ShowToast',
+                    version: 1,
+                    executionMode: 'frontend',
+                    message: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'JavaScript',
+                            value: "'Welcome ' + getInput('userName') + '!'",
+                        },
+                    },
+                    type_: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'success',
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 100,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+            ],
+            connections: [],
+            variables: [],
+        },
+    },
+    // Data Processing Workflow
+    {
+        $schema: 'https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json',
+        id: AXPDataGenerator.uuid(),
+        definitionId: 'data-processing-workflow',
+        tenantId: null,
+        name: 'Data Processing Workflow',
+        description: 'Backend workflow for data processing and validation',
+        createdAt: new Date().toISOString(),
+        version: 1,
+        toolVersion: '3.2.0.0',
+        variables: [],
+        inputs: [
+            {
+                type: 'Object',
+                name: 'data',
+                displayName: 'Data',
+                description: 'Data to process',
+            },
+        ],
+        outputs: [
+            {
+                type: 'Object',
+                name: 'processedData',
+                displayName: 'Processed Data',
+                description: 'Processed data result',
+            },
+        ],
+        outcomes: ['Done', 'Failed'],
+        customProperties: {},
+        isReadonly: false,
+        isSystem: false,
+        isLatest: true,
+        isPublished: true,
+        options: {
+            usableAsActivity: false,
+            autoUpdateConsumingWorkflows: false,
+        },
+        root: {
+            id: 'root-flowchart',
+            nodeId: 'root-flowchart',
+            type: 'Elsa.Flowchart',
+            version: 1,
+            activities: [
+                {
+                    id: 'validate-data',
+                    nodeId: 'validate-data',
+                    name: 'Validate Data',
+                    type: 'Elsa.ExecuteQuery',
+                    version: 1,
+                    executionMode: 'backend',
+                    queryKey: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'Data:Validate',
+                        },
+                    },
+                    parameters: {
+                        typeName: 'Object',
+                        expression: {
+                            type: 'JavaScript',
+                            value: "{ data: getInput('data') }",
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 100,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'process-data',
+                    nodeId: 'process-data',
+                    name: 'Process Data',
+                    type: 'Elsa.ExecuteCommand',
+                    version: 1,
+                    executionMode: 'backend',
+                    commandKey: {
+                        typeName: 'String',
+                        expression: {
+                            type: 'Literal',
+                            value: 'Data:Process',
+                        },
+                    },
+                    input: {
+                        typeName: 'Object',
+                        expression: {
+                            type: 'JavaScript',
+                            value: "{ data: getInput('data') }",
+                        },
+                    },
+                    metadata: {
+                        designer: {
+                            position: {
+                                x: 300,
+                                y: 100,
+                            },
+                        },
+                    },
+                },
+            ],
+            connections: [
+                {
+                    source: {
+                        activity: 'validate-data',
+                        port: 'Valid',
+                    },
+                    target: {
+                        activity: 'process-data',
+                    },
+                },
+            ],
+            variables: [],
+        },
+    },
+];
+/**
+ * Export definitionId list for easy access
+ */
+const workflowDefinitionIds = {
+    createUser: 'create-user-workflow',
+    welcome: 'welcome-workflow',
+    dataProcessing: 'data-processing-workflow',
+};
+
+/**
+ * Seeds workflow definitions into localStorage for mock/demo purposes.
+ *
+ * Workflow definitions are stored in localStorage with key pattern:
+ * `workflow:{definitionId}`
+ *
+ * This allows the mock workflow execution service to retrieve definitions
+ * without making HTTP calls.
+ */
+let AXCWorkflowDefinitionDataSeeder$1 = class AXCWorkflowDefinitionDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    async seed() {
+        // Store each workflow definition in localStorage
+        for (const workflow of workflowDefinitionMock) {
+            localStorage.setItem(`workflow:${workflow.definitionId}`, JSON.stringify(workflow));
+            console.log(`[WorkflowDefinitionSeeder] Seeded workflow: ${workflow.name} (${workflow.definitionId})`);
+        }
+        // Also store in entity storage for entity-based access
+        await this.storageService.initial('Workflow.WorkflowDefinition', workflowDefinitionMock);
+        console.log(`[WorkflowDefinitionSeeder] Successfully seeded ${workflowDefinitionMock.length} workflow definitions`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder }); }
+};
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder$1, decorators: [{
+            type: Injectable
+        }] });
+
+//#endregion
+/**
+ * CheckPermission Activity (Backend)
+ *
+ * Checks if a user has specific permission.
+ * This is a mock implementation that always grants permission for demo purposes.
+ *
+ * In production, this would check against real permission system.
+ *
+ * Execution Mode: backend
+ * Activity Type: workflow-activity:check-permission
+ *
+ * Outcomes:
+ * - HasPermission: User has the permission
+ * - NoPermission: User does not have the permission
+ */
+class CheckPermissionActivity {
+    //#region ----   AXPCommand Implementation   ----
+    async execute(input) {
+        // Mock implementation: always grant permission for demo
+        // In production, check against permission service
+        const hasPermission = true; // TODO: Integrate with real permission system
+        const output = {
+            hasPermission,
+            userId: input.userId || 'current-user',
+            permission: input.permission,
+        };
+        // Determine outcome based on permission check
+        const outcomes = hasPermission
+            ? { HasPermission: true }
+            : { NoPermission: true };
+        console.log(`[CheckPermissionActivity] Checked permission '${input.permission}' for user '${output.userId}': ${hasPermission ? 'GRANTED' : 'DENIED'}`);
+        return {
+            output,
+            outcomes,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: CheckPermissionActivity, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: CheckPermissionActivity }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: CheckPermissionActivity, decorators: [{
+            type: Injectable
+        }] });
+
+//#endregion
+/**
+ * ExecuteQuery Activity (Backend)
+ *
+ * Executes a query operation.
+ * This is a mock implementation that simulates common queries.
+ *
+ * Execution Mode: backend
+ * Activity Type: workflow-activity:execute-query
+ *
+ * Outcomes:
+ * - Done: Query executed successfully
+ * - Valid: Data is valid (for validation queries)
+ * - Exists: Data exists (for existence checks)
+ * - NotFound: Data not found
+ * - Failed: Query execution failed
+ */
+class ExecuteQueryActivity {
+    constructor() {
+        //#region ----   Services   ----
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    //#endregion
+    //#region ----   AXPCommand Implementation   ----
+    async execute(input) {
+        try {
+            console.log(`[ExecuteQueryActivity] Executing query '${input.queryKey}' with parameters:`, input.parameters);
+            // Route to appropriate query handler based on queryKey
+            const result = await this.routeQuery(input.queryKey, input.parameters || {});
+            return result;
+        }
+        catch (error) {
+            console.error(`[ExecuteQueryActivity] Query '${input.queryKey}' failed:`, error);
+            return {
+                output: {
+                    data: null,
+                    success: false,
+                    error: error.message || 'Unknown error',
+                },
+                outcomes: {
+                    Failed: true,
+                },
+            };
+        }
+    }
+    //#endregion
+    //#region ----   Query Routing   ----
+    /**
+     * Routes query to appropriate handler based on queryKey.
+     */
+    async routeQuery(queryKey, parameters) {
+        switch (queryKey) {
+            case 'User:CheckEmailExists':
+                return await this.checkEmailExists(parameters);
+            case 'Data:Validate':
+                return await this.validateData(parameters);
+            default:
+                // Mock: return empty result for unknown queries
+                console.warn(`[ExecuteQueryActivity] Unknown query key: ${queryKey}`);
+                return {
+                    output: {
+                        data: null,
+                        success: true,
+                    },
+                    outcomes: {
+                        Done: true,
+                    },
+                };
+        }
+    }
+    //#endregion
+    //#region ----   Query Handlers   ----
+    /**
+     * Checks if email already exists in database.
+     */
+    async checkEmailExists(parameters) {
+        const email = parameters['email'] || parameters['userEmail'];
+        // Mock implementation: randomly decide if email exists
+        // In production, check against real database
+        const exists = Math.random() > 0.8; // 20% chance email exists
+        console.log(`[ExecuteQueryActivity] Checking email '${email}': ${exists ? 'EXISTS' : 'AVAILABLE'}`);
+        const outcome = exists ? 'Exists' : 'Valid';
+        return {
+            output: {
+                data: {
+                    email,
+                    exists,
+                    available: !exists,
+                },
+                success: true,
+            },
+            outcomes: {
+                [outcome]: true,
+                Done: true,
+            },
+        };
+    }
+    /**
+     * Validates data structure and content.
+     */
+    async validateData(parameters) {
+        const data = parameters['data'];
+        // Mock validation: check if data exists and has content
+        const isValid = data && Object.keys(data).length > 0;
+        console.log(`[ExecuteQueryActivity] Validating data: ${isValid ? 'VALID' : 'INVALID'}`);
+        const outcome = isValid ? 'Valid' : 'Invalid';
+        return {
+            output: {
+                data: {
+                    valid: isValid,
+                    errors: isValid ? [] : ['Data is empty or invalid'],
+                },
+                success: true,
+            },
+            outcomes: {
+                [outcome]: true,
+                Done: true,
+            },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteQueryActivity, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteQueryActivity }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteQueryActivity, decorators: [{
+            type: Injectable
+        }] });
+
+//#endregion
+/**
+ * ExecuteCommand Activity (Backend)
+ *
+ * Executes a command operation.
+ * This is a mock implementation that simulates common commands.
+ *
+ * Execution Mode: backend
+ * Activity Type: workflow-activity:execute-command
+ *
+ * Outcomes:
+ * - Done: Command executed successfully
+ * - Failed: Command execution failed
+ */
+class ExecuteCommandActivity {
+    constructor() {
+        //#region ----   Services   ----
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    //#endregion
+    //#region ----   AXPCommand Implementation   ----
+    async execute(input) {
+        try {
+            console.log(`[ExecuteCommandActivity] Executing command '${input.commandKey}' with input:`, input.input);
+            // Route to appropriate command handler based on commandKey
+            const result = await this.routeCommand(input.commandKey, input.input || {});
+            return result;
+        }
+        catch (error) {
+            console.error(`[ExecuteCommandActivity] Command '${input.commandKey}' failed:`, error);
+            return {
+                output: {
+                    result: null,
+                    success: false,
+                    error: error.message || 'Unknown error',
+                },
+                outcomes: {
+                    Failed: true,
+                },
+            };
+        }
+    }
+    //#endregion
+    //#region ----   Command Routing   ----
+    /**
+     * Routes command to appropriate handler based on commandKey.
+     */
+    async routeCommand(commandKey, input) {
+        switch (commandKey) {
+            case 'User:Create':
+                return await this.createUser(input);
+            case 'Data:Process':
+                return await this.processData(input);
+            default:
+                // Mock: return success for unknown commands
+                console.warn(`[ExecuteCommandActivity] Unknown command key: ${commandKey}`);
+                return {
+                    output: {
+                        result: { success: true },
+                        success: true,
+                    },
+                    outcomes: {
+                        Done: true,
+                    },
+                };
+        }
+    }
+    //#endregion
+    //#region ----   Command Handlers   ----
+    /**
+     * Creates a new user in the system.
+     */
+    async createUser(input) {
+        // Extract user data from input
+        const email = input['email'] || input['userEmail'];
+        const name = input['name'] || input['userName'] || 'New User';
+        const role = input['role'] || input['userRole'] || 'User';
+        // Create new user object
+        const userId = AXPDataGenerator.uuid();
+        const newUser = {
+            id: userId,
+            email,
+            name,
+            role,
+            createdAt: new Date().toISOString(),
+            isActive: true,
+        };
+        console.log(`[ExecuteCommandActivity] Creating user:`, newUser);
+        // In production, save to database via EntityStorageService or API
+        // For mock, we'll just simulate success
+        // await this.storageService.create('User', newUser);
+        return {
+            output: {
+                result: newUser,
+                success: true,
+                entityId: userId,
+            },
+            outcomes: {
+                Done: true,
+            },
+        };
+    }
+    /**
+     * Processes data according to business rules.
+     */
+    async processData(input) {
+        const data = input['data'];
+        // Mock processing: just add timestamp and processed flag
+        const processedData = {
+            ...data,
+            processed: true,
+            processedAt: new Date().toISOString(),
+        };
+        console.log(`[ExecuteCommandActivity] Processed data:`, processedData);
+        return {
+            output: {
+                result: processedData,
+                success: true,
+            },
+            outcomes: {
+                Done: true,
+            },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteCommandActivity, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteCommandActivity }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteCommandActivity, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Provides all backend workflow activities as Commands.
+ *
+ * These activities are registered with the CommandBus and can be executed
+ * by the workflow execution service.
+ *
+ * Usage:
+ * ```typescript
+ * @NgModule({
+ *   providers: [
+ *     provideWorkflowActivities(),
+ *   ]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+function provideWorkflowActivities() {
+    return provideCommandSetups([
+        {
+            key: 'workflow-activity:check-permission',
+            command: () => CheckPermissionActivity,
+        },
+        {
+            key: 'workflow-activity:execute-query',
+            command: () => ExecuteQueryActivity,
+        },
+        {
+            key: 'workflow-activity:execute-command',
+            command: () => ExecuteCommandActivity,
+        },
+    ]);
+}
+
 class AXCCommonMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCommonMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: AXCCommonMockModule }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCommonMockModule, providers: [
+            provideWorkflowActivities(),
             {
                 provide: AXP_ACTIVITY_LOG_PROVIDER,
                 useClass: AXCPActivityLogService,
@@ -3530,7 +4695,7 @@ class AXCCommonMockModule {
             },
             {
                 provide: AXPVersioningService,
-                useClass: VersioningService,
+                useClass: AXCVersioningService,
             },
             {
                 provide: AXP_ACTIVITY_CATEGORY_PROVIDER,
@@ -3546,6 +4711,11 @@ class AXCCommonMockModule {
                 provide: AXPWorkflowExecutionService,
                 useClass: AXCWorkflowExecutionService,
             },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXCWorkflowDefinitionDataSeeder$1,
+                multi: true,
+            },
         ] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCommonMockModule, decorators: [{
@@ -3555,6 +4725,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                     exports: [],
                     declarations: [],
                     providers: [
+                        provideWorkflowActivities(),
                         {
                             provide: AXP_ACTIVITY_LOG_PROVIDER,
                             useClass: AXCPActivityLogService,
@@ -3575,7 +4746,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                         },
                         {
                             provide: AXPVersioningService,
-                            useClass: VersioningService,
+                            useClass: AXCVersioningService,
                         },
                         {
                             provide: AXP_ACTIVITY_CATEGORY_PROVIDER,
@@ -3591,6 +4762,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                             provide: AXPWorkflowExecutionService,
                             useClass: AXCWorkflowExecutionService,
                         },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXCWorkflowDefinitionDataSeeder$1,
+                            multi: true,
+                        },
                     ],
                 }]
         }] });
@@ -37463,6 +38639,38 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                 }]
         }] });
 
+/**
+ * Mock workflow definition entities for the entity list.
+ */
+const workflowDefinitionEntityMock = workflowDefinitionMock.map((def) => ({
+    id: def.id,
+    definitionId: def.definitionId,
+    name: def.name || 'Unnamed Workflow',
+    description: def.description || undefined,
+    version: def.version,
+    isLatest: def.isLatest,
+    isPublished: def.isPublished,
+    isReadonly: def.isReadonly,
+    isSystem: def.isSystem,
+    createdAt: def.createdAt,
+    workflowDefinition: def,
+}));
+
+class AXCWorkflowDefinitionDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig$m.module.name}.${RootConfig$m.entities.workflowDefinition.name}`, workflowDefinitionEntityMock);
+        console.log(`[WorkflowDefinitionSeeder] Seeded ${workflowDefinitionEntityMock.length} workflow definitions`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
 class AXCWorkflowManagementMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowManagementMockModule }); }
@@ -37473,16 +38681,11 @@ class AXCWorkflowManagementMockModule {
                     command: () => import('./acorex-connectivity-mock-distribution-record.command-w3zoeELy.mjs').then((c) => c.AXCDistributionCommand),
                 },
             ]),
-            // {
-            //   provide: AXP_WORKFLOW_TASK_PROVIDER,
-            //   useClass: AXPTaskBoardProjectManagementTaskProvider,
-            //   multi: true,
-            // },
-            // {
-            //   provide: AXP_WORKFLOW_TASK_PROVIDER,
-            //   useClass: AXPTaskBoardPlatformManagementTaskProvider,
-            //   multi: true,
-            // },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXCWorkflowDefinitionDataSeeder,
+                multi: true,
+            },
         ] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCWorkflowManagementMockModule, decorators: [{
@@ -37498,16 +38701,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                                 command: () => import('./acorex-connectivity-mock-distribution-record.command-w3zoeELy.mjs').then((c) => c.AXCDistributionCommand),
                             },
                         ]),
-                        // {
-                        //   provide: AXP_WORKFLOW_TASK_PROVIDER,
-                        //   useClass: AXPTaskBoardProjectManagementTaskProvider,
-                        //   multi: true,
-                        // },
-                        // {
-                        //   provide: AXP_WORKFLOW_TASK_PROVIDER,
-                        //   useClass: AXPTaskBoardPlatformManagementTaskProvider,
-                        //   multi: true,
-                        // },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXCWorkflowDefinitionDataSeeder,
+                            multi: true,
+                        },
                     ],
                 }]
         }] });
@@ -38870,7 +40068,7 @@ class AXCApplicationDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$m.module.name}.${RootConfig$m.entities.application.name}`, APPLICATIONS);
+        await this.storageService.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.application.name}`, APPLICATIONS);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCApplicationDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCApplicationDataSeeder }); }
@@ -38884,7 +40082,7 @@ class AXCEditionDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$m.module.name}.${RootConfig$m.entities.edition.name}`, EDITIONS);
+        await this.storageService.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.edition.name}`, EDITIONS);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCEditionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCEditionDataSeeder }); }
@@ -38898,7 +40096,7 @@ class AXCFeatureDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$m.module.name}.${RootConfig$m.entities.feature.name}`, FEATURES);
+        await this.storageService.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.feature.name}`, FEATURES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCFeatureDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCFeatureDataSeeder }); }
@@ -38912,7 +40110,7 @@ class AXCModuleDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$m.module.name}.${RootConfig$m.entities.module.name}`, MODULES);
+        await this.storageService.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.module.name}`, MODULES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCModuleDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCModuleDataSeeder }); }
@@ -39195,7 +40393,7 @@ class AXMQuestionBankItemCategoryDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.questionBankItem.name}Category`, QUESTION_BANK_ITEM_CATEGORY_MOCK);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.questionBankItem.name}Category`, QUESTION_BANK_ITEM_CATEGORY_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionBankItemCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionBankItemCategoryDataSeeder }); }
@@ -39516,7 +40714,7 @@ class AXMQuestionnaireCategoryDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.questionnaire.name}Category`, QUESTIONNAIRE_CATEGORY_MOCK);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.questionnaire.name}Category`, QUESTIONNAIRE_CATEGORY_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionnaireCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionnaireCategoryDataSeeder }); }
@@ -39530,7 +40728,7 @@ class AXMQuestionBankItemDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.questionBankItem.name}`, questionBankItemMock);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.questionBankItem.name}`, questionBankItemMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionBankItemDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionBankItemDataSeeder }); }
@@ -39544,7 +40742,7 @@ class AXMQuestionnaireDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.questionnaire.name}`, questionnaireMock);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.questionnaire.name}`, questionnaireMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionnaireDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMQuestionnaireDataSeeder }); }
@@ -39631,7 +40829,7 @@ class AXMPublicationDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.publication.name}`, publicationMock);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.publication.name}`, publicationMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMPublicationDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMPublicationDataSeeder }); }
@@ -39732,7 +40930,7 @@ class AXMResponseSessionDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.responseSession.name}`, responseSessionMock);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.responseSession.name}`, responseSessionMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMResponseSessionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMResponseSessionDataSeeder }); }
@@ -39818,7 +41016,7 @@ class AXMCollaboratorDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.collaborator.name}`, collaboratorMock);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.collaborator.name}`, collaboratorMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMCollaboratorDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMCollaboratorDataSeeder }); }
@@ -39927,7 +41125,7 @@ class AXMResponseEntryDataSeeder {
         this.storage = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storage.initial(`${RootConfig$n.module.name}.${RootConfig$n.entities.responseEntry.name}`, responseEntryMock);
+        await this.storage.initial(`${RootConfig$o.module.name}.${RootConfig$o.entities.responseEntry.name}`, responseEntryMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMResponseEntryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMResponseEntryDataSeeder }); }
@@ -40055,7 +41253,7 @@ class AXCCustomerTypeDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.customerType.source, CUSTOMER_TYPES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.customerType.source, CUSTOMER_TYPES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCustomerTypeDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCustomerTypeDataSeeder }); }
@@ -40069,7 +41267,7 @@ class AXCCustomerSegmentDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.customerSegment.source, CUSTOMER_SEGMENTS_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.customerSegment.source, CUSTOMER_SEGMENTS_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCustomerSegmentDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCustomerSegmentDataSeeder }); }
@@ -40083,7 +41281,7 @@ class AXCCustomerDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.customer.source, CUSTOMERS_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.customer.source, CUSTOMERS_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCustomerDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCustomerDataSeeder }); }
@@ -40107,7 +41305,7 @@ class AXCCrmOpportunityStageDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.opportunityStage.source, OPPORTUNITY_STAGES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.opportunityStage.source, OPPORTUNITY_STAGES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmOpportunityStageDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmOpportunityStageDataSeeder }); }
@@ -40126,7 +41324,7 @@ class AXCCrmSalesPipelineDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.salesPipeline.source, SALES_PIPELINES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.salesPipeline.source, SALES_PIPELINES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmSalesPipelineDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmSalesPipelineDataSeeder }); }
@@ -40149,7 +41347,7 @@ class AXCCrmLifecycleStageDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.lifecycleStage.source, LIFECYCLE_STAGES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.lifecycleStage.source, LIFECYCLE_STAGES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmLifecycleStageDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmLifecycleStageDataSeeder }); }
@@ -40170,7 +41368,7 @@ class AXCCrmSalesTerritoryDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.salesTerritory.source, SALES_TERRITORIES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.salesTerritory.source, SALES_TERRITORIES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmSalesTerritoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmSalesTerritoryDataSeeder }); }
@@ -40190,7 +41388,7 @@ class AXCCrmLeadDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.lead.source, LEADS_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.lead.source, LEADS_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmLeadDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmLeadDataSeeder }); }
@@ -40236,7 +41434,7 @@ class AXCCrmOpportunityDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.opportunity.source, OPPORTUNITIES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.opportunity.source, OPPORTUNITIES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmOpportunityDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmOpportunityDataSeeder }); }
@@ -40256,7 +41454,7 @@ class AXCCrmActivityDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.activity.source, ACTIVITIES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.activity.source, ACTIVITIES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmActivityDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmActivityDataSeeder }); }
@@ -40280,7 +41478,7 @@ class AXCCrmDealContactRoleDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(RootConfig$o.entities.dealContactRole.source, DEAL_CONTACT_ROLES_MOCK);
+        await this.storageService.initial(RootConfig$p.entities.dealContactRole.source, DEAL_CONTACT_ROLES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmDealContactRoleDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCCrmDealContactRoleDataSeeder }); }
@@ -40396,7 +41594,7 @@ class AXPIssueTypeDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$p.module.name}.${RootConfig$p.entities.issueType.name}`, ISSUE_TYPES);
+        await this.storageService.initial(`${RootConfig$q.module.name}.${RootConfig$q.entities.issueType.name}`, ISSUE_TYPES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPIssueTypeDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPIssueTypeDataSeeder }); }
@@ -40827,7 +42025,7 @@ const createFileCastMiddleware = {
             const hasValidSource = obj.source &&
                 typeof obj.source === 'object' &&
                 obj.source.kind &&
-                ['blob', 'url', 'preview', 'none', 'fileId'].includes(obj.source.kind);
+                ['blob', 'url', 'preview', 'none', 'fileId', 'reference'].includes(obj.source.kind);
             // At least one of these conditions must be true for it to be a file
             const isFileObject = hasValidStatus || hasValidSource;
             // Additional validation for file-specific properties
@@ -40910,7 +42108,38 @@ const createFileCastMiddleware = {
                 // Return null to indicate this file should be removed from the list
                 return null;
             }
-            // Case 2: Already uploaded file (keep existing ID)
+            // Case 2: Reference-based file (handle document updates)
+            if (file.source?.kind === 'reference' && file.source.value && typeof file.source.value === 'object' && 'id' in file.source.value && 'type' in file.source.value) {
+                const reference = file.source.value;
+                // Only handle document references
+                if (reference.type === 'document' && documentService) {
+                    try {
+                        const document = await documentService.getOne(reference.id);
+                        if (document) {
+                            // Check if name has changed and update document if needed
+                            if (document.name !== file.name || document.title !== file.name) {
+                                try {
+                                    await documentService.updateOne(reference.id, {
+                                        name: file.name,
+                                        title: file.name,
+                                    });
+                                }
+                                catch (error) {
+                                    console.error('[file-cast] Failed to update document name:', error);
+                                }
+                            }
+                            // Return reference identifier
+                            return { id: serializeReference(reference), kind: 'reference' };
+                        }
+                    }
+                    catch (error) {
+                        console.error('[file-cast] Failed to process reference:', error);
+                    }
+                }
+                // For non-document references or if document service is not available, return reference as-is
+                return { id: serializeReference(reference), kind: 'reference' };
+            }
+            // Case 3: Already uploaded file (keep existing ID)
             if ((file.status === 'uploaded' || file.status === 'remote') &&
                 file.source?.kind === 'fileId' &&
                 typeof file.source.value === 'string') {
@@ -40936,7 +42165,7 @@ const createFileCastMiddleware = {
                 }
                 return { id: cleanFileId, kind: 'file' };
             }
-            // Case 3: New file that needs uploading
+            // Case 4: New file that needs uploading
             if (!file.source?.value) {
                 return null;
             }
@@ -40991,25 +42220,45 @@ const createFileCastMiddleware = {
         };
         const FILE_PREFIX = 'file:';
         const DOCUMENT_PREFIX = 'document:';
+        const REFERENCE_PREFIX = 'reference:';
         const addFilePrefix = (fileId) => {
             return `${FILE_PREFIX}${fileId}`;
         };
         const addDocumentPrefix = (docId) => {
             return `${DOCUMENT_PREFIX}${docId}`;
         };
+        const addReferencePrefix = (reference) => {
+            return `${REFERENCE_PREFIX}${reference.type}:${reference.id}`;
+        };
         const removeFilePrefix = (prefixedId) => {
             return prefixedId.startsWith(FILE_PREFIX) ? prefixedId.substring(FILE_PREFIX.length) : prefixedId;
         };
         const removeDocumentPrefix = (prefixedId) => {
             return prefixedId.startsWith(DOCUMENT_PREFIX) ? prefixedId.substring(DOCUMENT_PREFIX.length) : prefixedId;
         };
+        const parseReference = (prefixedId) => {
+            if (!prefixedId.startsWith(REFERENCE_PREFIX))
+                return null;
+            const withoutPrefix = prefixedId.substring(REFERENCE_PREFIX.length);
+            const colonIndex = withoutPrefix.indexOf(':');
+            if (colonIndex === -1)
+                return null;
+            return {
+                type: withoutPrefix.substring(0, colonIndex),
+                id: withoutPrefix.substring(colonIndex + 1),
+            };
+        };
+        const serializeReference = (reference) => {
+            return addReferencePrefix(reference);
+        };
         const ensureCleanFileId = (fileId) => {
             // Remove prefix if it exists to get clean file ID
             return removeFilePrefix(fileId);
         };
         const isFileId = (value) => value.startsWith(FILE_PREFIX);
         const isDocumentId = (value) => value.startsWith(DOCUMENT_PREFIX);
-        const isAnyFileRef = (value) => isFileId(value) || isDocumentId(value);
+        const isReference = (value) => value.startsWith(REFERENCE_PREFIX);
+        const isAnyFileRef = (value) => isFileId(value) || isDocumentId(value) || isReference(value);
         const hasDocumentMeta = (obj) => {
             const candidate = obj;
             if (!candidate || typeof candidate !== 'object' || !candidate.meta || typeof candidate.meta !== 'object') {
@@ -41113,7 +42362,11 @@ const createFileCastMiddleware = {
                             if (isFileListItem(file)) {
                                 const processed = await processFileForStorage(file, ctx.id?.toString());
                                 if (processed) {
-                                    const prefixedId = processed.kind === 'document' ? addDocumentPrefix(processed.id) : addFilePrefix(processed.id);
+                                    const prefixedId = processed.kind === 'document'
+                                        ? addDocumentPrefix(processed.id)
+                                        : processed.kind === 'reference'
+                                            ? processed.id
+                                            : addFilePrefix(processed.id);
                                     return prefixedId;
                                 }
                                 else {
@@ -41135,7 +42388,11 @@ const createFileCastMiddleware = {
                     else if (isFileListItem(value)) {
                         const processed = await processFileForStorage(value, ctx.id?.toString());
                         if (processed) {
-                            const prefixedId = processed.kind === 'document' ? addDocumentPrefix(processed.id) : addFilePrefix(processed.id);
+                            const prefixedId = processed.kind === 'document'
+                                ? addDocumentPrefix(processed.id)
+                                : processed.kind === 'reference'
+                                    ? processed.id
+                                    : addFilePrefix(processed.id);
                             setValueByPath(ctx.data, keyPath, prefixedId);
                         }
                         else {
@@ -41197,22 +42454,31 @@ const createFileCastMiddleware = {
                     await Promise.all(fileIdKeys.map(async (keyPath) => {
                         const value = getValueByPath(resultData, keyPath);
                         if (Array.isArray(value)) {
-                            // Split file and document IDs
+                            // Split file, document, and reference IDs
                             const fileIdList = [];
                             const documentIdList = [];
+                            const referenceList = [];
                             value.forEach((item) => {
                                 if (typeof item === 'string') {
                                     if (isFileId(item))
                                         fileIdList.push(removeFilePrefix(item));
                                     else if (isDocumentId(item))
                                         documentIdList.push(removeDocumentPrefix(item));
+                                    else if (isReference(item)) {
+                                        const ref = parseReference(item);
+                                        if (ref)
+                                            referenceList.push(ref);
+                                    }
                                 }
                             });
                             try {
+                                // Fetch documents for references
+                                const referenceDocIds = referenceList.filter((ref) => ref.type === 'document').map((ref) => ref.id);
+                                const allDocIds = [...documentIdList, ...referenceDocIds];
                                 const [manyInfos, documents] = await Promise.all([
                                     fileIdList.length ? fileStorageService.findMany(fileIdList) : Promise.resolve([]),
-                                    documentIdList.length && documentService
-                                        ? documentService.findMany(documentIdList)
+                                    allDocIds.length && documentService
+                                        ? documentService.findMany(allDocIds)
                                         : Promise.resolve([]),
                                 ]);
                                 const infoMap = new Map(manyInfos.map((i) => [i.fileId, i]));
@@ -41254,6 +42520,33 @@ const createFileCastMiddleware = {
                                             source: { kind: 'fileId', value: actualDocId },
                                         };
                                     }
+                                    if (typeof item === 'string' && isReference(item)) {
+                                        const reference = parseReference(item);
+                                        if (reference && reference.type === 'document' && documentService) {
+                                            const doc = docMap.get(reference.id);
+                                            if (doc) {
+                                                const listItem = {
+                                                    id: reference.id,
+                                                    name: doc.name || 'Document',
+                                                    size: doc.size,
+                                                    status: 'uploaded',
+                                                    source: { kind: 'reference', value: reference },
+                                                };
+                                                // Expose full document object for downstream listeners/plugins
+                                                listItem.documentData = doc;
+                                                if (doc.metaDataForm)
+                                                    listItem.meta = doc.metaDataForm;
+                                                return listItem;
+                                            }
+                                        }
+                                        // Fallback for non-document references or when document not found
+                                        return {
+                                            id: reference?.id || 'unknown',
+                                            name: 'Unknown Reference',
+                                            status: 'remote',
+                                            source: { kind: 'reference', value: reference || { id: 'unknown', type: 'unknown' } },
+                                        };
+                                    }
                                     return item;
                                 });
                                 setValueByPath(resultData, keyPath, convertedArray);
@@ -41339,6 +42632,55 @@ const createFileCastMiddleware = {
                                     });
                                 }
                             }
+                            else if (isReference(value)) {
+                                const reference = parseReference(value);
+                                if (reference && reference.type === 'document' && documentService) {
+                                    try {
+                                        const docs = await documentService.findMany([reference.id]);
+                                        const doc = docs?.[0];
+                                        if (doc) {
+                                            const listItem = {
+                                                id: reference.id,
+                                                name: doc.name || 'Document',
+                                                size: doc.size,
+                                                status: 'uploaded',
+                                                source: { kind: 'reference', value: reference },
+                                            };
+                                            // Expose full document object for downstream listeners/plugins
+                                            listItem.documentData = doc;
+                                            if (doc.metaDataForm)
+                                                listItem.meta = doc.metaDataForm;
+                                            setValueByPath(resultData, keyPath, listItem);
+                                        }
+                                        else {
+                                            setValueByPath(resultData, keyPath, {
+                                                id: reference.id,
+                                                name: 'Unknown Document',
+                                                status: 'remote',
+                                                source: { kind: 'reference', value: reference },
+                                            });
+                                        }
+                                    }
+                                    catch (error) {
+                                        console.error('[file-cast] ❌ Failed to get reference document info', { keyPath, reference, error });
+                                        setValueByPath(resultData, keyPath, {
+                                            id: reference.id,
+                                            name: 'Unknown Document',
+                                            status: 'remote',
+                                            source: { kind: 'reference', value: reference },
+                                        });
+                                    }
+                                }
+                                else {
+                                    // Fallback for non-document references
+                                    setValueByPath(resultData, keyPath, {
+                                        id: reference?.id || 'unknown',
+                                        name: 'Unknown Reference',
+                                        status: 'remote',
+                                        source: { kind: 'reference', value: reference || { id: 'unknown', type: 'unknown' } },
+                                    });
+                                }
+                            }
                         }
                     }));
                 }
@@ -41365,7 +42707,7 @@ const historyLoggerMiddleware = {
     target: { ops: ['create', 'update', 'delete'], order: 80 },
     execute: async (ctx, next) => {
         const sessionService = inject(AXPSessionService);
-        const versioning = inject(VersioningService);
+        const versioning = inject(AXCVersioningService);
         // Capture previous for update/delete
         if (ctx.op === 'update' || ctx.op === 'delete') {
             try {
@@ -42348,6 +43690,148 @@ const signatureLoaderMiddleware = {
     //#endregion
 };
 
+//#region ----   Lock Guard Middleware   ----
+/**
+ * Middleware that prevents editing or deleting locked records.
+ *
+ * Supports two types of locks:
+ * 1. 'user' lock: Automatic lock when edit popup is opened.
+ *    - Only the user who locked it can edit
+ *    - Other users cannot edit
+ *
+ * 2. 'admin' lock: Manual lock by admin for a specific duration or permanently.
+ *    - Even the admin who locked it cannot edit
+ *    - All users are blocked until lock expires (if expireAt is set)
+ */
+const lockGuardMiddleware = {
+    target: { ops: ['update', 'delete'], order: 10 },
+    execute: async (ctx, next) => {
+        const lockService = inject(AXPLockService);
+        const session = inject(AXPSessionService);
+        // Skip if no ID is provided (shouldn't happen for update/delete, but safety check)
+        if (!ctx.id) {
+            await next();
+            return;
+        }
+        // First, check for 'admin' lock (highest priority - blocks everyone including the admin who locked it)
+        try {
+            const adminLockExists = await lockService.check({
+                refId: ctx.id,
+                refType: ctx.entityName,
+                type: 'admin'
+            });
+            if (adminLockExists) {
+                try {
+                    const adminLockInfo = await lockService.getInfo({
+                        refId: ctx.id,
+                        refType: ctx.entityName,
+                        type: 'admin'
+                    });
+                    if (adminLockInfo) {
+                        // Check if admin lock has expired
+                        let isExpired = false;
+                        if (adminLockInfo.expireAt) {
+                            const now = new Date();
+                            const expireDate = new Date(adminLockInfo.expireAt);
+                            isExpired = now > expireDate;
+                        }
+                        // If admin lock exists and hasn't expired, block everyone (including the admin who locked it)
+                        if (!isExpired) {
+                            throw new AXPMiddlewareAbortError('This record is locked by administrator and cannot be edited or deleted.', {
+                                status: 409,
+                                code: 'RECORD_ADMIN_LOCKED',
+                                details: {
+                                    entity: ctx.entityName,
+                                    id: ctx.id,
+                                    lockedBy: adminLockInfo.lockedBy,
+                                    lockType: adminLockInfo.type,
+                                    expireAt: adminLockInfo.expireAt,
+                                    operation: ctx.op,
+                                },
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    // If getInfo throws an error (e.g., lock not found), continue to check user lock
+                    if (error instanceof AXPMiddlewareAbortError) {
+                        throw error;
+                    }
+                    // Otherwise, ignore and continue
+                }
+            }
+        }
+        catch (error) {
+            // If it's already an AXPMiddlewareAbortError, re-throw it
+            if (error instanceof AXPMiddlewareAbortError) {
+                throw error;
+            }
+            // Otherwise, continue to check user lock
+        }
+        // Second, check for 'user' lock (only blocks other users, not the user who locked it)
+        try {
+            const userLockExists = await lockService.check({
+                refId: ctx.id,
+                refType: ctx.entityName,
+                type: 'user'
+            });
+            if (userLockExists) {
+                try {
+                    const userLockInfo = await lockService.getInfo({
+                        refId: ctx.id,
+                        refType: ctx.entityName,
+                        type: 'user'
+                    });
+                    if (userLockInfo) {
+                        // Check if user lock has expired
+                        let isExpired = false;
+                        if (userLockInfo.expireAt) {
+                            const now = new Date();
+                            const expireDate = new Date(userLockInfo.expireAt);
+                            isExpired = now > expireDate;
+                        }
+                        // If user lock exists and hasn't expired, check if current user is the one who locked it
+                        if (!isExpired) {
+                            // If current user is not the one who locked it, prevent the operation
+                            if (session.user && userLockInfo.lockedBy.id !== session.user.id) {
+                                throw new AXPMiddlewareAbortError('This record is locked by another user and cannot be edited or deleted.', {
+                                    status: 409,
+                                    code: 'RECORD_USER_LOCKED',
+                                    details: {
+                                        entity: ctx.entityName,
+                                        id: ctx.id,
+                                        lockedBy: userLockInfo.lockedBy,
+                                        lockType: userLockInfo.type,
+                                        operation: ctx.op,
+                                    },
+                                });
+                            }
+                            // If current user is the one who locked it, allow the operation (continue to next())
+                        }
+                    }
+                }
+                catch (error) {
+                    // If getInfo throws an error (e.g., lock not found), continue
+                    if (error instanceof AXPMiddlewareAbortError) {
+                        throw error;
+                    }
+                    // Otherwise, ignore and continue
+                }
+            }
+        }
+        catch (error) {
+            // If it's already an AXPMiddlewareAbortError, re-throw it
+            if (error instanceof AXPMiddlewareAbortError) {
+                throw error;
+            }
+            // Otherwise, continue
+        }
+        // If no blocking locks found, proceed with the operation
+        await next();
+    },
+};
+//#endregion
+
 class AXCMiddlewaresModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXCMiddlewaresModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: AXCMiddlewaresModule }); }
@@ -42366,6 +43850,7 @@ class AXCMiddlewaresModule {
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: primaryMiddleware },
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: historyLoggerMiddleware },
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: signatureLoaderMiddleware },
+            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: lockGuardMiddleware },
             // Sample entity event listener to show logs for all entity.* events
             //{ provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, multi: true, useValue: AXCMockEntityLogListener },
         ] }); }
@@ -42391,6 +43876,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: primaryMiddleware },
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: historyLoggerMiddleware },
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: signatureLoaderMiddleware },
+                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: lockGuardMiddleware },
                         // Sample entity event listener to show logs for all entity.* events
                         //{ provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, multi: true, useValue: AXCMockEntityLogListener },
                     ],
@@ -42670,5 +44156,5 @@ const AXCMockEntityLogListener = {
  * Generated bundle index. Do not edit.
  */
 
-export { APPLICATIONS, AXCAppTermDataSeeder, AXCAppVersionDataSeeder, AXCApplicationDataSeeder, AXCApplicationManagementMockModule, AXCAssessmentManagementMockModule, AXCAuthMockModule, AXCCalendarDataSeeder, AXCCalendarEventDataSeeder, AXCCalendarManagementMockModule, AXCCommonMockModule, AXCContactManagementMockModule, AXCContentManagementMockModule, AXCConversationMockModule, AXCCustomerManagementMockModule, AXCDashboardManagementMockModule, AXCDataManagementMockModule, AXCDexieEntityStorageService, AXCDocumentManagementMockModule, AXCEditionDataSeeder, AXCFeatureDataSeeder, AXCFileStorageService, AXCFormTemplateManagementMockModule, AXCGlobalVariablesDataSeeder, AXCGoogleStrategyMock, AXCHelpDeskMockModule, AXCHumanCapitalManagementMockModule, AXCIdentifierManagementMockModule, AXCJsaSeeder, AXCLocaleManagementMockModule, AXCLocationManagementMockModule, AXCLockService, AXCLogManagementMockModule, AXCLogReportCategoryProvider, AXCLogReportDefinitionProvider, AXCMeetingManagementMockModule, AXCMetaDataDefinitionDataSeeder, AXCMiddlewaresModule, AXCMockEntityLogListener, AXCMockModule, AXCModuleDataSeeder, AXCNotificationManagementMockModule, AXCOrganizationManagementMockModule, AXCPartyManagementMockModule, AXCPlatformManagementMockModule, AXCProjectManagementMockModule, AXCQueryCategoryMetadataInheritanceQuery, AXCReportManagementMockModule, AXCSecurityManagementMockModule, AXCTaskManagementMockModule, AXCTrainingManagementMockModule, AXCUserPassStrategyMock, AXCVersionDB, AXCWorkflowExecutionDB, AXCWorkflowExecutionService, AXCWorkflowManagementMockModule, AXC_LOG_REPORT_CATEGORY_PROVIDER, AXC_LOG_REPORT_DEFINITION_PROVIDER, AXMAiResponderService, AXMBusinessUnitDataSeeder, AXMCalendarEventTypeSeeder, AXMCollaboratorDataSeeder, AXMEmployeeDataSeeder, AXMEmployeeSkillDataSeeder, AXMEmployeeSkillsCategoryProvider, AXMEmployeeSkillsReportDefinitionProvider, AXMEmploymentTypeDataSeeder, AXMFormDataSourcesProvider, AXMIndustryDataSeeder, AXMLeaveRequestDataSeeder, AXMMeetingDataSeeder, AXMMeetingFilesDataSeeder, AXMMeetingParticipantDataSeeder, AXMMeetingRoleTypeDataSeeder, AXMMeetingSessionDataSeeder, AXMMeetingTypeDataSeeder, AXMMeetingTypeFileTemplateDataSeeder, AXMPositionAssignmentDataSeeder, AXMPositionDataSeeder, AXMPublicationDataSeeder, AXMQuestionBankItemCategoryDataSeeder, AXMQuestionBankItemDataSeeder, AXMQuestionnaireCategoryDataSeeder, AXMQuestionnaireDataSeeder, AXMReportCategoryDataSeeder, AXMReportDefinitionDataSeeder, AXMReportExecuteCommand, AXMReportMockDataService, AXMResponseEntryDataSeeder, AXMResponseSessionDataSeeder, AXMResponsibilityDataSeeder, AXMRoleDataSeeder, AXMSkillDataSeeder, AXMSkillLevelDataSeeder, AXMTagDataSeeder, AXMTeamDataSeeder, AXM_EMPLOYEE_SKILLS_CATEGORY_PROVIDER, AXM_EMPLOYEE_SKILLS_DEFINITION_PROVIDER, AXPDashboardDataSeeder, AXPIdentifierDB, AXPMessageDataSeeder, AXPMockChecksumProvider, AXPMockClockProvider, AXPMockIdentifierService, AXPMockLookupProvider, AXPMockPolicyProvider, AXPMockSequenceProvider, AXPRoomDataSeeder, AXPSecurityManagementRoleDataSeeder, AXPSecurityManagementUserDataSeeder, AXPTaskBoardPlatformManagementTaskProvider, AXPTaskBoardProjectManagementTaskProvider, AXQEmployeeSkillsLevelPercentagesQuery, AXQEmployeeSkillsLevelsQuery, AXQEmployeeSkillsListQuery, AXQEmployeeSkillsSkillPercentagesQuery, AXQEmployeeSkillsStatsQuery, AXQEmployeeSkillsTrendQuery, AXVChangeType, BUSINESS_UNITS_MOCK, DASHBOARDS, EDITIONS, EMPLOYEES_MOCK, EMPLOYEE_SKILLS_MOCK, EMPLOYMENT_TYPES_MOCK, FEATURES, GLOBAL_VARIABLES, LEAVE_REQUESTS_MOCK, MODULES, POSITIONS_CATEGORY_MOCK, POSITIONS_MOCK, POSITION_ASSIGNMENTS_MOCK, QUESTIONNAIRE_CATEGORY_MOCK, QUESTION_BANK_ITEM_CATEGORY_MOCK, RESPONSIBILITIES_CATEGORY_MOCK, RESPONSIBILITIES_MOCK, ROLES_CATEGORY_MOCK, ROLES_MOCK, SKILLS_CATEGORY_MOCK, SKILLS_MOCK, SKILL_LEVELS_MOCK, TAGS_MOCK, TASKS, TASK_STATUSES, TASK_TEMPLATES, TASK_TYPES, TEAMS_MOCK, VersioningService, applications, auditLoggerMiddleware, axVersionDB, axWorkflowExecutionDB, calendarEventMock, calendarEventTypeMockData, calendarMock, childCountMiddleware, collaboratorMock, computeDiff, createAndSaveDashboardForUser, createDashboardForUser, createFileCastMiddleware, findContactMethod, findEmployeeById, findPartyById, generateUserDashboard, historyLoggerMiddleware, identifierCommitMiddleware, lookupResolverMiddleware, meetingFilesMock, meetingIds, meetingMock, meetingParticipantMock, meetingRoleTypeMock, meetingSessionMock, meetingTimeSlotMock, meetingTypeFileTemplateMock, meetingTypeMock, mergeDetailRelationMiddleware, mockRoleDefinitions, mockUsers, normalizeAnyFileArrayForView, normalizeSnapshotFileFieldsForView, participantIds, primaryMiddleware, publicationMock, questionBankItemMock, questionnaireMock, responseEntryMock, responseSessionMock, signatureLoaderMiddleware, tenantsMock, toUiRows };
+export { APPLICATIONS, AXCAppTermDataSeeder, AXCAppVersionDataSeeder, AXCApplicationDataSeeder, AXCApplicationManagementMockModule, AXCAssessmentManagementMockModule, AXCAuthMockModule, AXCCalendarDataSeeder, AXCCalendarEventDataSeeder, AXCCalendarManagementMockModule, AXCCommonMockModule, AXCContactManagementMockModule, AXCContentManagementMockModule, AXCConversationMockModule, AXCCustomerManagementMockModule, AXCDashboardManagementMockModule, AXCDataManagementMockModule, AXCDexieEntityStorageService, AXCDocumentManagementMockModule, AXCEditionDataSeeder, AXCFeatureDataSeeder, AXCFileStorageService, AXCFormTemplateManagementMockModule, AXCGlobalVariablesDataSeeder, AXCGoogleStrategyMock, AXCHelpDeskMockModule, AXCHumanCapitalManagementMockModule, AXCIdentifierManagementMockModule, AXCJsaSeeder, AXCLocaleManagementMockModule, AXCLocationManagementMockModule, AXCLockService, AXCLogManagementMockModule, AXCLogReportCategoryProvider, AXCLogReportDefinitionProvider, AXCMeetingManagementMockModule, AXCMetaDataDefinitionDataSeeder, AXCMiddlewaresModule, AXCMockEntityLogListener, AXCMockModule, AXCModuleDataSeeder, AXCNotificationManagementMockModule, AXCOrganizationManagementMockModule, AXCPartyManagementMockModule, AXCPlatformManagementMockModule, AXCProjectManagementMockModule, AXCQueryCategoryMetadataInheritanceQuery, AXCReportManagementMockModule, AXCSecurityManagementMockModule, AXCTaskManagementMockModule, AXCTrainingManagementMockModule, AXCUserPassStrategyMock, AXCVersionDB, AXCVersioningService, AXCWorkflowDefinitionDataSeeder, AXCWorkflowExecutionDB, AXCWorkflowExecutionService, AXCWorkflowManagementMockModule, AXC_LOG_REPORT_CATEGORY_PROVIDER, AXC_LOG_REPORT_DEFINITION_PROVIDER, AXMAiResponderService, AXMBusinessUnitDataSeeder, AXMCalendarEventTypeSeeder, AXMCollaboratorDataSeeder, AXMEmployeeDataSeeder, AXMEmployeeSkillDataSeeder, AXMEmployeeSkillsCategoryProvider, AXMEmployeeSkillsReportDefinitionProvider, AXMEmploymentTypeDataSeeder, AXMFormDataSourcesProvider, AXMIndustryDataSeeder, AXMLeaveRequestDataSeeder, AXMMeetingDataSeeder, AXMMeetingFilesDataSeeder, AXMMeetingParticipantDataSeeder, AXMMeetingRoleTypeDataSeeder, AXMMeetingSessionDataSeeder, AXMMeetingTypeDataSeeder, AXMMeetingTypeFileTemplateDataSeeder, AXMPositionAssignmentDataSeeder, AXMPositionDataSeeder, AXMPublicationDataSeeder, AXMQuestionBankItemCategoryDataSeeder, AXMQuestionBankItemDataSeeder, AXMQuestionnaireCategoryDataSeeder, AXMQuestionnaireDataSeeder, AXMReportCategoryDataSeeder, AXMReportDefinitionDataSeeder, AXMReportExecuteCommand, AXMReportMockDataService, AXMResponseEntryDataSeeder, AXMResponseSessionDataSeeder, AXMResponsibilityDataSeeder, AXMRoleDataSeeder, AXMSkillDataSeeder, AXMSkillLevelDataSeeder, AXMTagDataSeeder, AXMTeamDataSeeder, AXM_EMPLOYEE_SKILLS_CATEGORY_PROVIDER, AXM_EMPLOYEE_SKILLS_DEFINITION_PROVIDER, AXPDashboardDataSeeder, AXPIdentifierDB, AXPMessageDataSeeder, AXPMockChecksumProvider, AXPMockClockProvider, AXPMockIdentifierService, AXPMockLookupProvider, AXPMockPolicyProvider, AXPMockSequenceProvider, AXPRoomDataSeeder, AXPSecurityManagementRoleDataSeeder, AXPSecurityManagementUserDataSeeder, AXPTaskBoardPlatformManagementTaskProvider, AXPTaskBoardProjectManagementTaskProvider, AXQEmployeeSkillsLevelPercentagesQuery, AXQEmployeeSkillsLevelsQuery, AXQEmployeeSkillsListQuery, AXQEmployeeSkillsSkillPercentagesQuery, AXQEmployeeSkillsStatsQuery, AXQEmployeeSkillsTrendQuery, AXVChangeType, BUSINESS_UNITS_MOCK, CheckPermissionActivity, DASHBOARDS, EDITIONS, EMPLOYEES_MOCK, EMPLOYEE_SKILLS_MOCK, EMPLOYMENT_TYPES_MOCK, ExecuteCommandActivity, ExecuteQueryActivity, FEATURES, GLOBAL_VARIABLES, LEAVE_REQUESTS_MOCK, MODULES, POSITIONS_CATEGORY_MOCK, POSITIONS_MOCK, POSITION_ASSIGNMENTS_MOCK, QUESTIONNAIRE_CATEGORY_MOCK, QUESTION_BANK_ITEM_CATEGORY_MOCK, RESPONSIBILITIES_CATEGORY_MOCK, RESPONSIBILITIES_MOCK, ROLES_CATEGORY_MOCK, ROLES_MOCK, SKILLS_CATEGORY_MOCK, SKILLS_MOCK, SKILL_LEVELS_MOCK, TAGS_MOCK, TASKS, TASK_STATUSES, TASK_TEMPLATES, TASK_TYPES, TEAMS_MOCK, applications, auditLoggerMiddleware, axVersionDB, axWorkflowExecutionDB, calendarEventMock, calendarEventTypeMockData, calendarMock, childCountMiddleware, collaboratorMock, computeDiff, createAndSaveDashboardForUser, createDashboardForUser, createFileCastMiddleware, findContactMethod, findEmployeeById, findPartyById, generateUserDashboard, historyLoggerMiddleware, identifierCommitMiddleware, lockGuardMiddleware, lookupResolverMiddleware, meetingFilesMock, meetingIds, meetingMock, meetingParticipantMock, meetingRoleTypeMock, meetingSessionMock, meetingTimeSlotMock, meetingTypeFileTemplateMock, meetingTypeMock, mergeDetailRelationMiddleware, mockRoleDefinitions, mockUsers, normalizeAnyFileArrayForView, normalizeSnapshotFileFieldsForView, participantIds, primaryMiddleware, provideWorkflowActivities, publicationMock, questionBankItemMock, questionnaireMock, responseEntryMock, responseSessionMock, signatureLoaderMiddleware, tenantsMock, toUiRows, workflowDefinitionEntityMock, workflowDefinitionIds, workflowDefinitionMock };
 //# sourceMappingURL=acorex-connectivity-mock.mjs.map