@acorex/platform 20.6.1 → 20.6.2

package/fesm2022/acorex-platform-workflow.mjs

@@ -578,79 +578,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
 // Compatible with Elsa backend while using ACoreX naming conventions
 // ============================================
 
-/**
- * Base abstract class for activities.
- * Extend this to create custom activities.
- */
-class Activity {
-    constructor(type, name) {
-        this.type = type;
-        this.name = name;
-    }
-    /**
-     * Helper method that returns Done outcome by default.
-     */
-    createResult(output, outcome = 'Done') {
-        return {
-            success: true,
-            data: {
-                output,
-                outcomes: { [outcome]: true },
-            },
-        };
-    }
-}
-/**
- * Activity registry for registering and creating activities.
- */
-class ActivityRegistry {
-    constructor() {
-        this.registry = new Map();
-        this.descriptors = new Map();
-    }
-    /**
-     * Register an activity type.
-     */
-    register(type, factory, descriptor) {
-        this.registry.set(type, factory);
-        this.descriptors.set(type, descriptor);
-    }
-    /**
-     * Create an activity instance.
-     */
-    create(type) {
-        const factory = this.registry.get(type);
-        if (!factory) {
-            throw new Error(`Unknown activity type: ${type}`);
-        }
-        return factory();
-    }
-    /**
-     * Get activity descriptor.
-     */
-    getDescriptor(type) {
-        return this.descriptors.get(type);
-    }
-    /**
-     * Get all registered types.
-     */
-    getTypes() {
-        return Array.from(this.registry.keys());
-    }
-    /**
-     * Get all descriptors.
-     */
-    getAllDescriptors() {
-        return Array.from(this.descriptors.values());
-    }
-    /**
-     * Get descriptors by category.
-     */
-    getDescriptorsByCategory(category) {
-        return this.getAllDescriptors().filter(d => d.category === category);
-    }
-}
-
 /**
  * Injection token for activity providers.
  */
@@ -661,7 +588,6 @@ const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER');
  */
 class AXPActivityProviderService {
     constructor() {
-        this.activityDescriptors = new Map();
         this.categories = [];
         this.providers = [];
         this.categoryProviders = [];
@@ -704,22 +630,34 @@ class AXPActivityProviderService {
         this.initialized = true;
     }
     /**
-     * Get activity descriptor by key.
+     * Get activity instance by key.
+     * Activity metadata is part of the activity instance itself.
      */
-    getDescriptor(key) {
-        return this.activityDescriptors.get(key);
+    async getActivity(key) {
+        return this.createActivity(key);
     }
     /**
-     * Get all activity descriptors.
+     * Get all registered activity keys from Command Registry.
      */
-    getAllDescriptors() {
-        return Array.from(this.activityDescriptors.values());
+    getAllActivityKeys() {
+        // Get all registered command keys that are activities
+        // This would need to be implemented based on Command Registry capabilities
+        return [];
     }
     /**
-     * Get descriptors by category.
+     * Get activities by category.
+     * Note: This requires loading all activities and filtering by category.
      */
-    getDescriptorsByCategory(category) {
-        return this.getAllDescriptors().filter(d => d.category === category);
+    async getActivitiesByCategory(category) {
+        const keys = this.getAllActivityKeys();
+        const activities = [];
+        for (const key of keys) {
+            const activity = await this.getActivity(key);
+            if (activity && activity.category === category) {
+                activities.push(activity);
+            }
+        }
+        return activities;
     }
     /**
      * Get all categories.
@@ -753,11 +691,7 @@ class AXPActivityProviderService {
     // PRIVATE METHODS
     // ============================================
     async initializeProvider(provider) {
-        const context = {
-            registerActivity: (config) => {
-                this.activityDescriptors.set(config.key, config.descriptor);
-            }
-        };
+        const context = {};
         await provider.provide(context);
     }
     async initializeCategoryProvider(provider) {
@@ -1183,19 +1117,30 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * Usage:
  * ```typescript
  * const activity = new WriteLine();
- * await activity.execute({ text: 'Hello World' });
+ * await activity.execute({ type: 'workflow-activity:write-line', text: 'Hello World' });
  * ```
  */
-class WriteLine extends Activity {
+class WriteLine {
     constructor() {
-        super('WriteLine');
+        this.type = "workflow-activity:write-line";
     }
     async execute(input) {
         const text = input.text || '';
         if (text !== undefined && text !== null) {
             console.log(`[WriteLine] ${text}`);
         }
-        return this.createResult(undefined, 'Done');
+        return {
+            success: true,
+            message: {
+                text: 'WriteLine completed',
+            },
+            data: {
+                output: undefined,
+                outcomes: {
+                    Done: true,
+                },
+            },
+        };
     }
 }
 
@@ -1204,50 +1149,6 @@ var writeLine_activity = /*#__PURE__*/Object.freeze({
     WriteLine: WriteLine
 });
 
-/**
- * Sequence Activity - Executes activities in sequential order.
- *
- * Usage:
- * ```typescript
- * const sequence = new Sequence();
- * sequence.activities = [activity1, activity2, activity3];
- * await sequence.execute({});
- * ```
- */
-class Sequence extends Activity {
-    constructor() {
-        super('Sequence');
-        /**
-         * Activities to execute in sequence.
-         */
-        this.activities = [];
-    }
-    async execute(input) {
-        // Execute all activities in sequence
-        for (const activity of this.activities) {
-            const result = await activity.execute(input);
-            if (!result.success) {
-                return {
-                    success: false,
-                    message: result.message,
-                    data: {
-                        output: undefined,
-                        outcomes: {
-                            Failed: true,
-                        },
-                    },
-                };
-            }
-        }
-        return this.createResult(undefined, 'Done');
-    }
-}
-
-var sequence_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Sequence: Sequence
-});
-
 /**
  * Show Confirm Dialog Activity - Displays confirmation dialog to user.
  *
@@ -1259,20 +1160,21 @@ var sequence_activity = /*#__PURE__*/Object.freeze({
  * ```typescript
  * const dialog = new ShowConfirmDialog();
  * await dialog.execute({
+ *   type: 'workflow-activity:show-confirm-dialog',
  *   title: 'Confirm Delete',
  *   message: 'Are you sure?',
  *   color: 'danger'
  * });
  * ```
  */
-class ShowConfirmDialog extends Activity {
-    //#endregion
+class ShowConfirmDialog {
     constructor() {
-        super('ShowConfirmDialog');
+        this.type = "workflow-activity:show-confirm-dialog";
         //#region ----   Services & Dependencies   ----
         this.dialogService = inject(AXDialogService);
         this.translationService = inject(AXTranslationService);
     }
+    //#endregion
     async execute(input) {
         const { title = '', message = '', color = 'primary', defaultAction = 'cancel', align = 'horizontal', backdrop = false } = input;
         // Translate title and message only if they start with '@' (translation key)
@@ -1291,10 +1193,19 @@ class ShowConfirmDialog extends Activity {
             const confirmResult = await this.dialogService.confirm(translatedTitle, translatedMessage, color, align, backdrop, defaultAction);
             const result = confirmResult.result;
             const action = result ? 'confirm' : 'cancel';
-            return this.createResult({
-                result,
-                action
-            }, result ? 'Confirmed' : 'Cancelled');
+            return {
+                success: true,
+                message: {
+                    text: 'Dialog closed',
+                },
+                data: {
+                    output: {
+                        result,
+                        action
+                    },
+                    outcomes: result ? { Confirmed: true } : { Cancelled: true },
+                },
+            };
         }
         catch (err) {
             console.error('[ShowConfirmDialog] Error showing dialog:', err);
@@ -1332,20 +1243,21 @@ var showConfirmDialog_activity = /*#__PURE__*/Object.freeze({
  * ```typescript
  * const dialog = new ShowAlertDialog();
  * await dialog.execute({
+ *   type: 'workflow-activity:show-alert-dialog',
  *   title: 'Alert',
  *   message: 'This is an alert',
  *   color: 'info'
  * });
  * ```
  */
-class ShowAlertDialog extends Activity {
-    //#endregion
+class ShowAlertDialog {
     constructor() {
-        super('ShowAlertDialog');
+        this.type = "workflow-activity:show-alert-dialog";
         //#region ----   Services & Dependencies   ----
         this.dialogService = inject(AXDialogService);
         this.translationService = inject(AXTranslationService);
     }
+    //#endregion
     async execute(input) {
         const { title = '', message = '', color = 'primary' } = input;
         // Translate title and message only if they start with '@' (translation key)
@@ -1362,10 +1274,21 @@ class ShowAlertDialog extends Activity {
             : '';
         try {
             await this.dialogService.alert(translatedTitle, translatedMessage, color);
-            return this.createResult({
-                result: true,
-                action: 'ok'
-            }, 'Done');
+            return {
+                success: true,
+                message: {
+                    text: 'Dialog closed',
+                },
+                data: {
+                    output: {
+                        result: true,
+                        action: 'ok'
+                    },
+                    outcomes: {
+                        Done: true,
+                    },
+                },
+            };
         }
         catch (err) {
             console.error('[ShowAlertDialog] Error showing dialog:', err);
@@ -1498,13 +1421,13 @@ var showAlertDialog_activity = /*#__PURE__*/Object.freeze({
  * }
  * ```
  */
-class ShowDialogLayoutBuilder extends Activity {
-    //#endregion
+class ShowDialogLayoutBuilder {
     constructor() {
-        super('ShowDialogLayoutBuilder');
+        this.type = "workflow-activity:show-dialog-layout-builder";
         //#region ----   Services & Dependencies   ----
         this.layoutBuilder = inject(AXPLayoutBuilderService);
     }
+    //#endregion
     async execute(input) {
         const { title = '', size = 'md', context = {}, closeButton = false, message, content, actions } = input;
         try {
@@ -1572,12 +1495,21 @@ class ShowDialogLayoutBuilder extends Activity {
             dialogRef.close();
             // Return result with appropriate outcome
             const outcome = cancelled ? 'Cancelled' : confirmed ? 'Confirmed' : 'Done';
-            return this.createResult({
-                context: dialogContext,
-                action,
-                cancelled,
-                confirmed
-            }, outcome);
+            return {
+                success: true,
+                message: {
+                    text: 'Dialog closed',
+                },
+                data: {
+                    output: {
+                        context: dialogContext,
+                        action,
+                        cancelled,
+                        confirmed
+                    },
+                    outcomes: cancelled ? { Cancelled: true } : confirmed ? { Confirmed: true } : { Done: true },
+                },
+            };
         }
         catch (err) {
             console.error('[ShowDialogLayoutBuilder] Error showing dialog:', err);
@@ -1609,15 +1541,16 @@ class ShowDialogLayoutBuilder extends Activity {
  * ```typescript
  * const toast = new ShowToast();
  * await toast.execute({
+ *   type: 'workflow-activity:show-toast',
  *   color: 'success',
  *   title: 'Success',
  *   message: 'Operation completed successfully!'
  * });
  * ```
  */
-class ShowToast extends Activity {
+class ShowToast {
     constructor() {
-        super('ShowToast');
+        this.type = "workflow-activity:show-toast";
         this.toastService = inject(AXToastService);
         this.translationService = inject(AXTranslationService);
     }
@@ -1644,7 +1577,18 @@ class ShowToast extends Activity {
                 timeOut: duration,
                 timeOutProgress: true,
             });
-            return this.createResult(undefined, 'Done');
+            return {
+                success: true,
+                message: {
+                    text: 'Toast displayed successfully',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {
+                        Done: true,
+                    },
+                },
+            };
         }
         catch (err) {
             console.error('[ShowToast] Error showing toast:', err);
@@ -1676,15 +1620,16 @@ var showToast_activity = /*#__PURE__*/Object.freeze({
  * ```typescript
  * const navigate = new Navigate();
  * await navigate.execute({
+ *   type: 'workflow-activity:navigate',
  *   mode: 'route',
  *   route: '/users',
  *   params: { id: '123' }
  * });
  * ```
  */
-class Navigate extends Activity {
+class Navigate {
     constructor() {
-        super('Navigate');
+        this.type = "workflow-activity:navigate";
         this.router = inject(Router);
     }
     async execute(input) {
@@ -1722,7 +1667,18 @@ class Navigate extends Activity {
                         },
                     };
             }
-            return this.createResult(undefined, 'Done');
+            return {
+                success: true,
+                message: {
+                    text: 'Navigation completed',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {
+                        Done: true,
+                    },
+                },
+            };
         }
         catch (err) {
             console.error('[Navigate] Error navigating:', err);
@@ -1759,17 +1715,23 @@ var navigate_activity = /*#__PURE__*/Object.freeze({
  * });
  * ```
  */
-class SetVariable extends Activity {
-    constructor() {
-        super('workflow-activity:set-variable', 'Set Variable');
-    }
+class SetVariable {
     async execute(input) {
         const { variableName, value } = input;
         try {
             // In a real implementation, this would set the variable in workflow context
             // For now, we'll just log it
             console.log(`[SetVariable] Setting ${variableName} = ${JSON.stringify(value)}`);
-            return this.createResult(undefined, 'Done');
+            return {
+                success: true,
+                message: {
+                    text: 'Variable set successfully',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {},
+                },
+            };
         }
         catch (err) {
             console.error('[SetVariable] Error setting variable:', err);
@@ -1801,14 +1763,15 @@ var setVariable_activity = /*#__PURE__*/Object.freeze({
  * ```typescript
  * const dispatch = new DispatchEvent();
  * await dispatch.execute({
+ *   type: 'workflow-activity:dispatch-event',
  *   eventName: 'user-created',
  *   eventData: { userId: '123', name: 'John' }
  * });
  * ```
  */
-class DispatchEvent extends Activity {
+class DispatchEvent {
     constructor() {
-        super('DispatchEvent');
+        this.type = "workflow-activity:dispatch-event";
     }
     async execute(input) {
         const { eventName, eventData } = input;
@@ -1816,7 +1779,18 @@ class DispatchEvent extends Activity {
             // In a real implementation, this would dispatch the event through an event bus
             // For now, we'll just log it
             console.log(`[DispatchEvent] Dispatching event: ${eventName}`, eventData);
-            return this.createResult(undefined, 'Done');
+            return {
+                success: true,
+                message: {
+                    text: 'Event dispatched successfully',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {
+                        Done: true,
+                    },
+                },
+            };
         }
         catch (err) {
             console.error('[DispatchEvent] Error dispatching event:', err);
@@ -1847,14 +1821,17 @@ var dispatchEvent_activity = /*#__PURE__*/Object.freeze({
  * Usage:
  * ```typescript
  * const ifActivity = new If();
- * ifActivity.condition = '{{user.isAdmin}}';
- * ifActivity.thenActivities = [activity1, activity2];
- * ifActivity.elseActivities = [activity3];
+ * await ifActivity.execute({
+ *   type: 'workflow-activity:if',
+ *   condition: '{{user.isAdmin}}',
+ *   thenActivities: [activity1, activity2],
+ *   elseActivities: [activity3]
+ * });
  * ```
  */
-class If extends Activity {
+class If {
     constructor() {
-        super('If');
+        this.type = "workflow-activity:if";
     }
     async execute(input) {
         const { condition, thenActivities = [], elseActivities = [] } = input;
@@ -1887,98 +1864,26 @@ class If extends Activity {
                     };
                 }
             }
-            return this.createResult(result, conditionResult ? 'Then' : 'Else');
-        }
-        catch (err) {
-            console.error('[If] Error evaluating condition:', err);
             return {
-                success: false,
+                success: true,
                 message: {
-                    text: err instanceof Error ? err.message : 'Failed to evaluate condition',
+                    text: 'Condition evaluated successfully',
                 },
                 data: {
-                    output: { branch: 'error' },
-                    outcomes: {
-                        Failed: true,
-                    },
+                    output: result,
+                    outcomes: conditionResult ? { Then: true } : { Else: true },
                 },
             };
         }
-    }
-    evaluateCondition(condition) {
-        if (typeof condition === 'boolean') {
-            return condition;
-        }
-        if (typeof condition === 'string') {
-            // Simple evaluation - in real implementation, use proper expression evaluator
-            return condition === 'true' || condition === '1' || condition === 'yes';
-        }
-        return false;
-    }
-}
-
-var if_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    If: If
-});
-
-/**
- * While Activity - Loop execution while condition is true.
- *
- * Usage:
- * ```typescript
- * const whileActivity = new While();
- * whileActivity.condition = '{{counter < 10}}';
- * whileActivity.activities = [incrementActivity, logActivity];
- * ```
- */
-class While extends Activity {
-    constructor() {
-        super('While');
-    }
-    async execute(input) {
-        const { condition, activities = [], maxIterations = 1000 } = input;
-        try {
-            let iteration = 0;
-            let conditionResult = this.evaluateCondition(condition);
-            while (conditionResult && iteration < maxIterations) {
-                // Execute activities in the loop
-                for (const activity of activities) {
-                    const activityResult = await activity.execute(input);
-                    if (!activityResult.success) {
-                        return {
-                            success: false,
-                            message: activityResult.message,
-                            data: {
-                                output: {
-                                    iterations: iteration,
-                                    completed: false,
-                                },
-                                outcomes: {
-                                    Failed: true,
-                                },
-                            },
-                        };
-                    }
-                }
-                iteration++;
-                conditionResult = this.evaluateCondition(condition);
-            }
-            const result = {
-                iterations: iteration,
-                completed: iteration < maxIterations
-            };
-            return this.createResult(result, 'Done');
-        }
         catch (err) {
-            console.error('[While] Error in loop execution:', err);
+            console.error('[If] Error evaluating condition:', err);
             return {
                 success: false,
                 message: {
-                    text: err instanceof Error ? err.message : 'Failed during loop execution',
+                    text: err instanceof Error ? err.message : 'Failed to evaluate condition',
                 },
                 data: {
-                    output: { iterations: 0, completed: false },
+                    output: { branch: 'error' },
                     outcomes: {
                         Failed: true,
                     },
@@ -1998,9 +1903,9 @@ class While extends Activity {
     }
 }
 
-var while_activity = /*#__PURE__*/Object.freeze({
+var if_activity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    While: While
+    If: If
 });
 
 /**
@@ -2010,14 +1915,15 @@ var while_activity = /*#__PURE__*/Object.freeze({
  * ```typescript
  * const forEach = new ForEach();
  * await forEach.execute({
+ *   type: 'workflow-activity:for-each',
  *   items: ['item1', 'item2', 'item3'],
  *   activities: [processItemActivity]
  * });
  * ```
  */
-class ForEach extends Activity {
+class ForEach {
     constructor() {
-        super('ForEach');
+        this.type = "workflow-activity:for-each";
     }
     async execute(input) {
         const { items = [], activities = [], itemVariableName = 'currentItem', indexVariableName = 'currentIndex' } = input;
@@ -2062,7 +1968,18 @@ class ForEach extends Activity {
                 processedItems: results.length,
                 results
             };
-            return this.createResult(result, 'Done');
+            return {
+                success: true,
+                message: {
+                    text: 'ForEach completed successfully',
+                },
+                data: {
+                    output: result,
+                    outcomes: {
+                        Done: true,
+                    },
+                },
+            };
         }
         catch (err) {
             console.error('[ForEach] Error in iteration:', err);
@@ -2094,14 +2011,15 @@ var forEach_activity = /*#__PURE__*/Object.freeze({
  * ```typescript
  * const executeCmd = new ExecuteCommand();
  * await executeCmd.execute({
+ *   type: 'workflow-activity:execute-command',
  *   commandKey: 'UserManagement.CreateUser',
  *   input: { name: 'John', email: 'john@example.com' }
  * });
  * ```
  */
-class ExecuteCommand extends Activity {
+class ExecuteCommand {
     constructor() {
-        super('workflow-activity:execute-command', 'Execute Command');
+        this.type = "workflow-activity:execute-command";
         this.commandService = inject(AXPCommandService);
     }
     async execute(input) {
@@ -2118,7 +2036,18 @@ class ExecuteCommand extends Activity {
                     executedAt: new Date().toISOString(),
                     simulated: true
                 };
-                return this.createResult(result, 'Done');
+                return {
+                    success: true,
+                    message: {
+                        text: 'Command executed successfully',
+                    },
+                    data: {
+                        output: result,
+                        outcomes: {
+                            Done: true,
+                        },
+                    },
+                };
             }
             // Execute command through Command Bus
             const result = await this.commandService.execute(commandKey, commandInput);
@@ -2157,12 +2086,23 @@ class ExecuteCommand extends Activity {
                     },
                 };
             }
-            return this.createResult({
-                commandKey,
+            return {
                 success: true,
-                output: result.data,
-                executedAt: new Date().toISOString(),
-            }, 'Done');
+                message: {
+                    text: 'Command executed successfully',
+                },
+                data: {
+                    output: {
+                        commandKey,
+                        success: true,
+                        output: result.data,
+                        executedAt: new Date().toISOString(),
+                    },
+                    outcomes: {
+                        Done: true,
+                    },
+                },
+            };
         }
         catch (err) {
             console.error('[ExecuteCommand] Error executing command:', err);
@@ -2198,14 +2138,15 @@ var executeCommand_activity = /*#__PURE__*/Object.freeze({
  * ```typescript
  * const executeQuery = new ExecuteQuery();
  * await executeQuery.execute({
+ *   type: 'workflow-activity:execute-query',
  *   queryKey: 'UserManagement.GetUsers',
  *   input: { page: 1, pageSize: 10 }
  * });
  * ```
  */
-class ExecuteQuery extends Activity {
+class ExecuteQuery {
     constructor() {
-        super('workflow-activity:execute-query', 'Execute Query');
+        this.type = "workflow-activity:execute-query";
         this.queryService = inject(AXPQueryService);
     }
     async execute(input) {
@@ -2223,17 +2164,39 @@ class ExecuteQuery extends Activity {
                     executedAt: new Date().toISOString(),
                     simulated: true
                 };
-                return this.createResult(result, 'Done');
+                return {
+                    success: true,
+                    message: {
+                        text: 'Query executed successfully',
+                    },
+                    data: {
+                        output: result,
+                        outcomes: {
+                            Done: true,
+                        },
+                    },
+                };
             }
             // Execute query through Query Bus
             const result = await this.queryService.fetch(queryKey, queryInput);
-            return this.createResult({
-                queryKey,
+            return {
                 success: true,
-                data: result,
-                totalCount: Array.isArray(result) ? result.length : (result?.totalCount || 0),
-                executedAt: new Date().toISOString()
-            }, 'Done');
+                message: {
+                    text: 'Query executed successfully',
+                },
+                data: {
+                    output: {
+                        queryKey,
+                        success: true,
+                        data: result,
+                        totalCount: Array.isArray(result) ? result.length : (result?.totalCount || 0),
+                        executedAt: new Date().toISOString()
+                    },
+                    outcomes: {
+                        Done: true,
+                    },
+                },
+            };
         }
         catch (err) {
             console.error('[ExecuteQuery] Error executing query:', err);
@@ -2271,18 +2234,29 @@ var executeQuery_activity = /*#__PURE__*/Object.freeze({
  * Usage:
  * ```typescript
  * const start = new StartActivity();
- * await start.execute({});
+ * await start.execute({ type: 'workflow-activity:start' });
  * ```
  */
-class StartActivity extends Activity {
+class StartActivity {
     constructor() {
-        super('StartActivity');
+        this.type = "workflow-activity:start";
     }
     async execute(input) {
         // This activity is a visual marker only
         // It immediately completes and allows workflow to proceed
         console.log('[StartActivity] Workflow started');
-        return this.createResult(undefined, 'Done');
+        return {
+            success: true,
+            message: {
+                text: 'Workflow started',
+            },
+            data: {
+                output: undefined,
+                outcomes: {
+                    Done: true,
+                },
+            },
+        };
     }
 }
 
@@ -2300,17 +2274,28 @@ var startActivity_activity = /*#__PURE__*/Object.freeze({
  * Usage:
  * ```typescript
  * const end = new EndActivity();
- * await end.execute({});
+ * await end.execute({ type: 'workflow-activity:end' });
  * ```
  */
-class EndActivity extends Activity {
+class EndActivity {
     constructor() {
-        super('EndActivity');
+        this.type = "workflow-activity:end";
     }
     async execute(input) {
         // This activity marks the end of workflow execution
         console.log('[EndActivity] Workflow completed');
-        return this.createResult(undefined, 'Done');
+        return {
+            success: true,
+            message: {
+                text: 'Workflow completed',
+            },
+            data: {
+                output: undefined,
+                outcomes: {
+                    Done: true,
+                },
+            },
+        };
     }
 }
 
@@ -2339,18 +2324,10 @@ const provideWorkflowActivityCommands = () => provideCommandSetups([
         command: () => Promise.resolve().then(function () { return writeLine_activity; }).then(m => m.WriteLine),
     },
     // Control Flow Activities
-    {
-        key: 'workflow-activity:sequence',
-        command: () => Promise.resolve().then(function () { return sequence_activity; }).then(m => m.Sequence),
-    },
     {
         key: 'workflow-activity:if',
         command: () => Promise.resolve().then(function () { return if_activity; }).then(m => m.If),
     },
-    {
-        key: 'workflow-activity:while',
-        command: () => Promise.resolve().then(function () { return while_activity; }).then(m => m.While),
-    },
     {
         key: 'workflow-activity:for-each',
         command: () => Promise.resolve().then(function () { return forEach_activity; }).then(m => m.ForEach),
@@ -2512,5 +2489,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowDialogLayoutBuilder, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
+export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowDialogLayoutBuilder, ShowToast, StartActivity, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map