@acorex/platform 20.6.0 → 20.6.2

package/workflow/index.d.ts

@@ -2,9 +2,9 @@ import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
 import { Type, ModuleWithProviders, Injector, InjectionToken } from '@angular/core';
-import { AXPCommand } from '@acorex/platform/runtime';
+import { AXPCommand, AXPExecuteCommandResultPromise } from '@acorex/platform/runtime';
 import * as _acorex_platform_core from '@acorex/platform/core';
-import { AXPExecuteCommandResult, AXPValidationRules, AXPActionMenuItem } from '@acorex/platform/core';
+import { AXPValidationRules, AXPActionMenuItem } from '@acorex/platform/core';
 import { AXPWidgetTypesMap, AXPWidgetNode } from '@acorex/platform/layout/widget-core';
 import { AXStyleColorType } from '@acorex/cdk/common';
 import { AXPopupSizeType } from '@acorex/components/popup';
@@ -407,7 +407,7 @@ interface AXPCustomProperties {
  * Matches Activity from workflow definition schema.
  * Note: This is the workflow definition format, not the frontend Activity class.
  */
-interface AXPActivity {
+interface AXPActivity$1 {
     /**
      * Activity ID.
      */
@@ -435,7 +435,7 @@ interface AXPActivity {
      * - 'backend': Execute in backend (business logic, database operations, API calls)
      * - 'both': Execute in both frontend and backend (hybrid activities)
      *
-     * If not specified, falls back to ActivityDescriptor's executionMode.
+     * If not specified, falls back to AXPActivity's executionMode.
      * This allows per-instance override of the default execution mode.
      *
      * @example
@@ -465,7 +465,7 @@ interface AXPActivity {
  * Flowchart activity (workflow definition format).
  * This is the root activity that contains all other activities.
  */
-interface AXPFlowchart extends AXPActivity {
+interface AXPFlowchart extends AXPActivity$1 {
     /**
      * Type must be "workflow-activity:flowchart".
      */
@@ -473,7 +473,7 @@ interface AXPFlowchart extends AXPActivity {
     /**
      * Activities in this flowchart.
      */
-    activities: AXPActivity[];
+    activities: AXPActivity$1[];
     /**
      * Variables in this flowchart.
      */
@@ -1095,68 +1095,22 @@ interface ActivityPropertyWidget {
     options?: Record<string, any>;
 }
 /**
- * Simple activity interface - just a command with outcomes.
+ * Activity interface - command with outcomes and metadata.
  * All activities are AXPCommand for unified execution through Command Bus.
+ * Contains both execution logic and metadata for UI and tooling.
  */
-interface IActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
+interface AXPActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
     output: TOutput;
     outcomes: Record<string, any>;
 }> {
     /**
-     * Activity type name.
-     * Example: "WriteLine", "ShowDialog", "CreateUserCommand"
-     */
-    type: string;
-    /**
-     * Display name for UI.
-     */
-    name?: string;
-    /**
-     * Execute the activity as a command.
-     * @param input - Activity input data
-     * @returns Promise with output and outcomes
-     */
-    execute(input: TInput): Promise<AXPExecuteCommandResult<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>>;
-}
-/**
- * Base abstract class for activities.
- * Extend this to create custom activities.
- */
-declare abstract class Activity<TInput = any, TOutput = any> implements IActivity<TInput, TOutput> {
-    type: string;
-    name?: string;
-    constructor(type: string, name?: string);
-    /**
-     * Execute the activity as a command.
-     * Override this method in subclasses to implement activity logic.
-     */
-    abstract execute(input: TInput): Promise<AXPExecuteCommandResult<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>>;
-    /**
-     * Helper method that returns Done outcome by default.
-     */
-    protected createResult(output: TOutput, outcome?: string): AXPExecuteCommandResult<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>;
-}
-/**
- * Activity descriptor - metadata about an activity type.
- */
-interface ActivityDescriptor {
-    /**
-     * Activity type name.
+     * Activity type.
      */
     type: string;
     /**
      * Display name for UI.
      */
-    displayName: string;
+    title?: string;
     /**
      * Description of what the activity does.
      */
@@ -1164,7 +1118,7 @@ interface ActivityDescriptor {
     /**
      * Category for grouping in toolbox.
      */
-    category: string;
+    category?: string;
     /**
      * Icon name or class.
      */
@@ -1181,11 +1135,11 @@ interface ActivityDescriptor {
     /**
      * Input descriptors.
      */
-    inputs: InputDescriptor[];
+    inputs?: InputDescriptor[];
     /**
      * Output descriptors.
      */
-    outputs: OutputDescriptor[];
+    outputs?: OutputDescriptor[];
     /**
      * Static outcomes (exit points).
      * Example: ['Done', 'Success', 'Failed']
@@ -1201,6 +1155,15 @@ interface ActivityDescriptor {
      * Default: false
      */
     isContainer?: boolean;
+    /**
+     * Execute the activity as a command.
+     * @param input - Activity input data
+     * @returns Promise with output and outcomes
+     */
+    execute(input: TInput): AXPExecuteCommandResultPromise<{
+        output: TOutput;
+        outcomes: Record<string, any>;
+    }>;
 }
 /**
  * Input property descriptor.
@@ -1231,37 +1194,6 @@ interface OutputDescriptor {
         dataType: string;
     };
 }
-/**
- * Activity registry for registering and creating activities.
- */
-declare class ActivityRegistry {
-    private registry;
-    private descriptors;
-    /**
-     * Register an activity type.
-     */
-    register(type: string, factory: () => IActivity, descriptor: ActivityDescriptor): void;
-    /**
-     * Create an activity instance.
-     */
-    create(type: string): IActivity;
-    /**
-     * Get activity descriptor.
-     */
-    getDescriptor(type: string): ActivityDescriptor | undefined;
-    /**
-     * Get all registered types.
-     */
-    getTypes(): string[];
-    /**
-     * Get all descriptors.
-     */
-    getAllDescriptors(): ActivityDescriptor[];
-    /**
-     * Get descriptors by category.
-     */
-    getDescriptorsByCategory(category: string): ActivityDescriptor[];
-}
 
 interface ActivityCategoryDescriptor {
     name: string;
@@ -1298,15 +1230,9 @@ declare class AXPActivityCategoryProviderService {
 
 /**
  * Context for registering activities in a provider.
+ * Activities are registered through Command Registry, so this context is mainly for category registration.
  */
 interface AXPActivityProviderContext {
-    /**
-     * Register an activity with its descriptor.
-     */
-    registerActivity(config: {
-        key: string;
-        descriptor: ActivityDescriptor;
-    }): void;
 }
 /**
  * Interface for activity providers.
@@ -1322,25 +1248,11 @@ interface AXPActivityProvider {
  * Injection token for activity providers.
  */
 declare const AXP_ACTIVITY_PROVIDER: InjectionToken<AXPActivityProvider[]>;
-/**
- * Category definition for activity categorization.
- */
-interface ActivityCategory {
-    name: string;
-    displayName: string;
-    description?: string;
-    icon?: string;
-    color?: string;
-    order?: number;
-    isVisible?: boolean;
-    tags?: string[];
-}
 /**
  * Activity Provider Service.
  * Collects all activity providers and manages activity registration.
  */
 declare class AXPActivityProviderService {
-    private activityDescriptors;
     private categories;
     private providers;
     private categoryProviders;
@@ -1360,25 +1272,27 @@ declare class AXPActivityProviderService {
      */
     initialize(): Promise<void>;
     /**
-     * Get activity descriptor by key.
+     * Get activity instance by key.
+     * Activity metadata is part of the activity instance itself.
      */
-    getDescriptor(key: string): ActivityDescriptor | undefined;
+    getActivity(key: string): Promise<AXPActivity | null>;
     /**
-     * Get all activity descriptors.
+     * Get all registered activity keys from Command Registry.
      */
-    getAllDescriptors(): ActivityDescriptor[];
+    getAllActivityKeys(): string[];
     /**
-     * Get descriptors by category.
+     * Get activities by category.
+     * Note: This requires loading all activities and filtering by category.
      */
-    getDescriptorsByCategory(category: string): ActivityDescriptor[];
+    getActivitiesByCategory(category: string): Promise<AXPActivity[]>;
     /**
      * Get all categories.
      */
-    getCategories(): ActivityCategory[];
+    getCategories(): ActivityCategoryDescriptor[];
     /**
      * Create an activity instance by key using AXPCommandService.
      */
-    createActivity(key: string): Promise<IActivity | null>;
+    createActivity(key: string): Promise<AXPActivity | null>;
     private initializeProvider;
     private initializeCategoryProvider;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityProviderService, never>;
@@ -1816,41 +1730,29 @@ declare abstract class AXPWorkflowExecutionService {
  * Usage:
  * ```typescript
  * const activity = new WriteLine();
- * await activity.execute({ text: 'Hello World' });
+ * await activity.execute({ type: 'workflow-activity:write-line', text: 'Hello World' });
  * ```
  */
-declare class WriteLine extends Activity<{
+declare class WriteLine implements AXPActivity<{
+    type: "workflow-activity:write-line";
     text?: string;
 }, void> {
-    constructor();
+    type: "workflow-activity:write-line";
     execute(input: {
+        type: "workflow-activity:write-line";
         text?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Sequence Activity - Executes activities in sequential order.
- *
- * Usage:
- * ```typescript
- * const sequence = new Sequence();
- * sequence.activities = [activity1, activity2, activity3];
- * await sequence.execute({});
- * ```
- */
-declare class Sequence extends Activity<{}, void> {
-    /**
-     * Activities to execute in sequence.
-     */
-    activities: IActivity[];
-    constructor();
-    execute(input: {}): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Done: boolean;
+            };
+        };
+    }>;
 }
 
 /**
@@ -1864,13 +1766,15 @@ declare class Sequence extends Activity<{}, void> {
  * ```typescript
  * const dialog = new ShowConfirmDialog();
  * await dialog.execute({
+ *   type: 'workflow-activity:show-confirm-dialog',
  *   title: 'Confirm Delete',
  *   message: 'Are you sure?',
  *   color: 'danger'
  * });
  * ```
  */
-declare class ShowConfirmDialog extends Activity<{
+declare class ShowConfirmDialog implements AXPActivity<{
+    type: "workflow-activity:show-confirm-dialog";
     title?: string;
     message?: string;
     color?: AXStyleColorType;
@@ -1881,23 +1785,36 @@ declare class ShowConfirmDialog extends Activity<{
     result: boolean;
     action: string;
 }> {
+    type: "workflow-activity:show-confirm-dialog";
     private readonly dialogService;
     private readonly translationService;
-    constructor();
     execute(input: {
+        type: "workflow-activity:show-confirm-dialog";
         title?: string;
         message?: string;
         color?: AXStyleColorType;
         defaultAction?: 'confirm' | 'cancel';
         align?: 'horizontal' | 'vertical';
         backdrop?: boolean;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: {
-            result: boolean;
-            action: string;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
         };
-        outcomes: Record<string, any>;
-    }>>;
+        data: {
+            output: {
+                result: boolean;
+                action: string;
+            };
+            outcomes: {
+                Confirmed: boolean;
+                Cancelled?: undefined;
+            } | {
+                Cancelled: boolean;
+                Confirmed?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -1910,13 +1827,15 @@ declare class ShowConfirmDialog extends Activity<{
  * ```typescript
  * const dialog = new ShowAlertDialog();
  * await dialog.execute({
+ *   type: 'workflow-activity:show-alert-dialog',
  *   title: 'Alert',
  *   message: 'This is an alert',
  *   color: 'info'
  * });
  * ```
  */
-declare class ShowAlertDialog extends Activity<{
+declare class ShowAlertDialog implements AXPActivity<{
+    type: "workflow-activity:show-alert-dialog";
     title?: string;
     message?: string;
     color?: AXStyleColorType;
@@ -1924,20 +1843,45 @@ declare class ShowAlertDialog extends Activity<{
     result: boolean;
     action: string;
 }> {
+    type: "workflow-activity:show-alert-dialog";
     private readonly dialogService;
     private readonly translationService;
-    constructor();
     execute(input: {
+        type: "workflow-activity:show-alert-dialog";
         title?: string;
         message?: string;
         color?: AXStyleColorType;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: {
-            result: boolean;
-            action: string;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
         };
-        outcomes: Record<string, any>;
-    }>>;
+        data: {
+            output: {
+                result: boolean;
+                action: string;
+            };
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                result: boolean;
+                action: string;
+            };
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2045,7 +1989,8 @@ declare class ShowAlertDialog extends Activity<{
  * }
  * ```
  */
-declare class ShowDialogLayoutBuilder extends Activity<{
+declare class ShowDialogLayoutBuilder implements AXPActivity<{
+    type: "workflow-activity:show-dialog-layout-builder";
     /**
      * Dialog title
      */
@@ -2106,9 +2051,10 @@ declare class ShowDialogLayoutBuilder extends Activity<{
      */
     confirmed: boolean;
 }> {
+    type: "workflow-activity:show-dialog-layout-builder";
     private readonly layoutBuilder;
-    constructor();
     execute(input: {
+        type: "workflow-activity:show-dialog-layout-builder";
         title?: string;
         size?: AXPopupSizeType;
         context?: Record<string, any>;
@@ -2120,15 +2066,55 @@ declare class ShowDialogLayoutBuilder extends Activity<{
             submit?: string;
             custom?: AXPActionMenuItem[];
         };
-    }): Promise<AXPExecuteCommandResult<{
-        output: {
-            context: Record<string, any>;
-            action: string;
-            cancelled: boolean;
-            confirmed: boolean;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
         };
-        outcomes: Record<string, any>;
-    }>>;
+        data: {
+            output: {
+                context: Record<string, any>;
+                action: string;
+                cancelled: boolean;
+                confirmed: boolean;
+            };
+            outcomes: {
+                Cancelled: boolean;
+                Confirmed?: undefined;
+                Done?: undefined;
+                Error?: undefined;
+            } | {
+                Confirmed: boolean;
+                Cancelled?: undefined;
+                Done?: undefined;
+                Error?: undefined;
+            } | {
+                Done: boolean;
+                Cancelled?: undefined;
+                Confirmed?: undefined;
+                Error?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                context: {};
+                action: string;
+                cancelled: boolean;
+                confirmed: boolean;
+            };
+            outcomes: {
+                Error: boolean;
+                Cancelled?: undefined;
+                Confirmed?: undefined;
+                Done?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2138,30 +2124,54 @@ declare 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!'
  * });
  * ```
  */
-declare class ShowToast extends Activity<{
+declare class ShowToast implements AXPActivity<{
+    type: "workflow-activity:show-toast";
     color?: AXStyleColorType;
     title?: string;
     message?: string;
     duration?: number;
 }, void> {
+    type: "workflow-activity:show-toast";
     private readonly toastService;
     private readonly translationService;
-    constructor();
     execute(input: {
+        type: "workflow-activity:show-toast";
         color?: AXStyleColorType;
         title?: string;
         message?: string;
         duration?: number;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2171,13 +2181,15 @@ declare class ShowToast extends Activity<{
  * ```typescript
  * const navigate = new Navigate();
  * await navigate.execute({
+ *   type: 'workflow-activity:navigate',
  *   mode: 'route',
  *   route: '/users',
  *   params: { id: '123' }
  * });
  * ```
  */
-declare class Navigate extends Activity<{
+declare class Navigate implements AXPActivity<{
+    type: "workflow-activity:navigate";
     mode?: 'route' | 'entity-details' | 'entity-list' | 'external';
     route?: string;
     params?: Record<string, any>;
@@ -2186,9 +2198,10 @@ declare class Navigate extends Activity<{
     entityId?: string;
     url?: string;
 }, void> {
+    type: "workflow-activity:navigate";
     private readonly router;
-    constructor();
     execute(input: {
+        type: "workflow-activity:navigate";
         mode?: 'route' | 'entity-details' | 'entity-list' | 'external';
         route?: string;
         params?: Record<string, any>;
@@ -2196,10 +2209,31 @@ declare class Navigate extends Activity<{
         entity?: string;
         entityId?: string;
         url?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2214,18 +2248,41 @@ declare class Navigate extends Activity<{
  * });
  * ```
  */
-declare class SetVariable extends Activity<{
+declare class SetVariable implements AXPActivity<{
+    type: "set-variable";
+    variableName: string;
+    value: any;
+}, any> {
+    type: "set-variable";
     variableName: string;
     value: any;
-}, void> {
-    constructor();
     execute(input: {
+        type: "set-variable";
         variableName: string;
         value: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Failed: boolean;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2235,23 +2292,47 @@ declare class SetVariable extends Activity<{
  * ```typescript
  * const dispatch = new DispatchEvent();
  * await dispatch.execute({
+ *   type: 'workflow-activity:dispatch-event',
  *   eventName: 'user-created',
  *   eventData: { userId: '123', name: 'John' }
  * });
  * ```
  */
-declare class DispatchEvent extends Activity<{
+declare class DispatchEvent implements AXPActivity<{
+    type: "workflow-activity:dispatch-event";
     eventName: string;
     eventData?: any;
 }, void> {
-    constructor();
+    type: "workflow-activity:dispatch-event";
     execute(input: {
+        type: "workflow-activity:dispatch-event";
         eventName: string;
         eventData?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2260,52 +2341,74 @@ declare class DispatchEvent extends Activity<{
  * Usage:
  * ```typescript
  * const ifActivity = new If();
- * ifActivity.condition = '{{user.isAdmin}}';
- * ifActivity.thenActivities = [activity1, activity2];
- * ifActivity.elseActivities = [activity3];
- * ```
- */
-declare class If extends Activity<{
-    condition: string | boolean;
-    thenActivities?: IActivity[];
-    elseActivities?: IActivity[];
-}, any> {
-    constructor();
-    execute(input: {
-        condition: string | boolean;
-        thenActivities?: IActivity[];
-        elseActivities?: IActivity[];
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-    private evaluateCondition;
-}
-
-/**
- * While Activity - Loop execution while condition is true.
- *
- * Usage:
- * ```typescript
- * const whileActivity = new While();
- * whileActivity.condition = '{{counter < 10}}';
- * whileActivity.activities = [incrementActivity, logActivity];
+ * await ifActivity.execute({
+ *   type: 'workflow-activity:if',
+ *   condition: '{{user.isAdmin}}',
+ *   thenActivities: [activity1, activity2],
+ *   elseActivities: [activity3]
+ * });
  * ```
  */
-declare class While extends Activity<{
+declare class If implements AXPActivity<{
+    type: "workflow-activity:if";
     condition: string | boolean;
-    activities?: IActivity[];
-    maxIterations?: number;
+    thenActivities?: AXPActivity[];
+    elseActivities?: AXPActivity[];
 }, any> {
-    constructor();
+    type: "workflow-activity:if";
     execute(input: {
+        type: "workflow-activity:if";
         condition: string | boolean;
-        activities?: IActivity[];
-        maxIterations?: number;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
+        thenActivities?: AXPActivity[];
+        elseActivities?: AXPActivity[];
+    }): Promise<{
+        success: boolean;
+        message: _acorex_platform_core.AXPCommandMessage | undefined;
+        data: {
+            output: {
+                branch: string;
+                failedActivity: AXPActivity<any, any>;
+            };
+            outcomes: {
+                Failed: boolean;
+                Then?: undefined;
+                Else?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: any;
+            outcomes: {
+                Then: boolean;
+                Failed?: undefined;
+                Else?: undefined;
+            } | {
+                Else: boolean;
+                Failed?: undefined;
+                Then?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                branch: string;
+                failedActivity?: undefined;
+            };
+            outcomes: {
+                Failed: boolean;
+                Then?: undefined;
+                Else?: undefined;
+            };
+        };
+    }>;
     private evaluateCondition;
 }
 
@@ -2316,27 +2419,57 @@ declare class While extends Activity<{
  * ```typescript
  * const forEach = new ForEach();
  * await forEach.execute({
+ *   type: 'workflow-activity:for-each',
  *   items: ['item1', 'item2', 'item3'],
  *   activities: [processItemActivity]
  * });
  * ```
  */
-declare class ForEach extends Activity<{
+declare class ForEach implements AXPActivity<{
+    type: "workflow-activity:for-each";
     items: any[];
-    activities?: IActivity[];
+    activities?: AXPActivity[];
     itemVariableName?: string;
     indexVariableName?: string;
 }, any> {
-    constructor();
+    type: "workflow-activity:for-each";
     execute(input: {
+        type: "workflow-activity:for-each";
         items: any[];
-        activities?: IActivity[];
+        activities?: AXPActivity[];
         itemVariableName?: string;
         indexVariableName?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: _acorex_platform_core.AXPCommandMessage | undefined;
+        data: {
+            output: {
+                totalItems: number;
+                processedItems: number;
+                results: any[];
+            };
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                totalItems: number;
+                processedItems: number;
+                results: any[];
+            };
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2346,24 +2479,112 @@ declare class ForEach extends Activity<{
  * ```typescript
  * const executeCmd = new ExecuteCommand();
  * await executeCmd.execute({
+ *   type: 'workflow-activity:execute-command',
  *   commandKey: 'UserManagement.CreateUser',
  *   input: { name: 'John', email: 'john@example.com' }
  * });
  * ```
  */
-declare class ExecuteCommand extends Activity<{
+declare class ExecuteCommand implements AXPActivity<{
+    type: "workflow-activity:execute-command";
     commandKey: string;
     input?: any;
 }, any> {
+    type: "workflow-activity:execute-command";
     private readonly commandService;
-    constructor();
     execute(input: {
+        type: "workflow-activity:execute-command";
         commandKey: string;
         input?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                commandKey: string;
+                success: boolean;
+                output: any;
+                executedAt: string;
+                simulated: boolean;
+            };
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                commandKey: string;
+                success: boolean;
+                executedAt: string;
+                error?: undefined;
+                output?: undefined;
+            };
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: _acorex_platform_core.AXPCommandMessage | undefined;
+        data: {
+            output: {
+                commandKey: string;
+                success: boolean;
+                executedAt: string;
+                error: string | undefined;
+                output?: undefined;
+            };
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                commandKey: string;
+                success: boolean;
+                output: any;
+                executedAt: string;
+                error?: undefined;
+            };
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                commandKey: string;
+                success: boolean;
+                error: string;
+                executedAt?: undefined;
+                output?: undefined;
+            };
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2373,24 +2594,81 @@ declare class ExecuteCommand extends Activity<{
  * ```typescript
  * const executeQuery = new ExecuteQuery();
  * await executeQuery.execute({
+ *   type: 'workflow-activity:execute-query',
  *   queryKey: 'UserManagement.GetUsers',
  *   input: { page: 1, pageSize: 10 }
  * });
  * ```
  */
-declare class ExecuteQuery extends Activity<{
+declare class ExecuteQuery implements AXPActivity<{
+    type: "workflow-activity:execute-query";
     queryKey: string;
     input?: any;
 }, any> {
+    type: "workflow-activity:execute-query";
     private readonly queryService;
-    constructor();
     execute(input: {
+        type: "workflow-activity:execute-query";
         queryKey: string;
         input?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                queryKey: string;
+                success: boolean;
+                data: never[];
+                totalCount: number;
+                executedAt: string;
+                simulated: boolean;
+            };
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                queryKey: string;
+                success: boolean;
+                data: any;
+                totalCount: any;
+                executedAt: string;
+                error?: undefined;
+            };
+            outcomes: {
+                Done: boolean;
+                Failed?: undefined;
+            };
+        };
+    } | {
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: {
+                queryKey: string;
+                success: boolean;
+                error: string;
+                data?: undefined;
+                totalCount?: undefined;
+                executedAt?: undefined;
+            };
+            outcomes: {
+                Failed: boolean;
+                Done?: undefined;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2402,15 +2680,27 @@ declare class ExecuteQuery extends Activity<{
  * Usage:
  * ```typescript
  * const start = new StartActivity();
- * await start.execute({});
+ * await start.execute({ type: 'workflow-activity:start' });
  * ```
  */
-declare class StartActivity extends Activity<Record<string, never>, void> {
-    constructor();
-    execute(input: Record<string, never>): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+declare class StartActivity implements AXPActivity<{
+    type: "workflow-activity:start";
+}, void> {
+    type: "workflow-activity:start";
+    execute(input: {
+        type: "workflow-activity:start";
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Done: boolean;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2422,15 +2712,27 @@ declare class StartActivity extends Activity<Record<string, never>, void> {
  * Usage:
  * ```typescript
  * const end = new EndActivity();
- * await end.execute({});
+ * await end.execute({ type: 'workflow-activity:end' });
  * ```
  */
-declare class EndActivity extends Activity<Record<string, never>, void> {
-    constructor();
-    execute(input: Record<string, never>): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+declare class EndActivity implements AXPActivity<{
+    type: "workflow-activity:end";
+}, void> {
+    type: "workflow-activity:end";
+    execute(input: {
+        type: "workflow-activity:end";
+    }): Promise<{
+        success: boolean;
+        message: {
+            text: string;
+        };
+        data: {
+            output: undefined;
+            outcomes: {
+                Done: boolean;
+            };
+        };
+    }>;
 }
 
 /**
@@ -2439,5 +2741,5 @@ declare class EndActivity extends Activity<Record<string, never>, void> {
  */
 declare const provideWorkflowActivityCommands: () => i0.EnvironmentProviders;
 
-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 type { AXPActivity, AXPActivityCategoryProvider, AXPActivityCategoryProviderContext, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderContext, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPCustomProperties, AXPEndpoint, AXPExceptionState, AXPExpression, AXPFlowchart, AXPGetWorkflowDefinitionRequest, AXPGetWorkflowDefinitionResponse, AXPGetWorkflowExecutionStateRequest, AXPInputValue, AXPMetadata, AXPOutputValue, AXPPosition, AXPResumeWorkflowExecutionRequest, AXPResumeWorkflowExecutionResponse, AXPStartWorkflowExecutionRequest, AXPStartWorkflowExecutionResponse, AXPStoredWorkflowDefinition, AXPVariableDefinition, AXPVariableModel, AXPVersionedEntity, AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionPreloader, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityCategory, ActivityCategoryDescriptor, ActivityDescriptor, ActivityPropertyWidget, IActivity, InputDescriptor, OutputDescriptor, WorkflowExecutionResult };
+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 };
+export type { AXPActivity$1 as AXPActivity, AXPActivityCategoryProvider, AXPActivityCategoryProviderContext, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderContext, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPCustomProperties, AXPEndpoint, AXPExceptionState, AXPExpression, AXPFlowchart, AXPGetWorkflowDefinitionRequest, AXPGetWorkflowDefinitionResponse, AXPGetWorkflowExecutionStateRequest, AXPInputValue, AXPMetadata, AXPOutputValue, AXPPosition, AXPResumeWorkflowExecutionRequest, AXPResumeWorkflowExecutionResponse, AXPStartWorkflowExecutionRequest, AXPStartWorkflowExecutionResponse, AXPStoredWorkflowDefinition, AXPVariableDefinition, AXPVariableModel, AXPVersionedEntity, AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionPreloader, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityCategoryDescriptor, ActivityPropertyWidget, InputDescriptor, OutputDescriptor, WorkflowExecutionResult };