@acorex/platform 21.0.0-next.2 → 21.0.0-next.5

package/workflow/index.d.ts

@@ -2,12 +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 * as _acorex_platform_core from '@acorex/platform/core';
-import { AXPExecuteCommandResult, 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';
+import { AXPCommand, AXPExecuteCommandResultPromise } from '@acorex/platform/runtime';
+import { AXPCategoryEntity, AXPValidationRules } from '@acorex/platform/core';
+import { AXPWidgetTypesMap } from '@acorex/platform/layout/widget-core';
 
 declare class AXPWorkflowError extends Error {
     inner: Error | null;
@@ -117,7 +114,6 @@ interface AXPWorkflowModuleConfigs {
     };
 }
 declare class AXPWorkflowModule {
-    private _commandSetup;
     static forRoot(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
     static forChild(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
     /**
@@ -407,7 +403,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 +431,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 +461,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 +469,7 @@ interface AXPFlowchart extends AXPActivity {
     /**
      * Activities in this flowchart.
      */
-    activities: AXPActivity[];
+    activities: AXPActivity$1[];
     /**
      * Variables in this flowchart.
      */
@@ -1090,73 +1086,44 @@ interface AXPWorkflowInstance {
     finishedAt?: string | null;
 }
 
+/**
+ * Activity Category - Extends AXPCategoryEntity for consistency and performance
+ *
+ * Inherited properties from AXPCategoryEntity:
+ * - id: string                   - Unique identifier
+ * - title: string                - Display name
+ * - description?: string         - Category description
+ * - parentId?: string            - Parent category ID
+ * - childrenCount: number        - Direct child categories count (enables lazy loading)
+ * - itemsCount?: number          - Direct activities count
+ * - totalChildren?: number       - Total nested categories (optional, for analytics)
+ * - totalItems?: number          - Total activities in tree (optional, for analytics)
+ */
+interface AXPActivityCategory extends AXPCategoryEntity {
+}
 interface ActivityPropertyWidget {
     type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
     options?: Record<string, any>;
 }
 /**
- * Simple activity interface - just a command with outcomes.
- * All activities are AXPCommand for unified execution through Command Bus.
+ * Activity Definition - Metadata for UI and tooling.
+ * Contains all metadata needed for displaying activities in toolbox and designer.
+ * The `name` property is used as the command key for execution.
  */
-interface IActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
-    output: TOutput;
-    outcomes: Record<string, any>;
-}> {
+interface AXPActivityDefinition {
     /**
-     * Activity type name.
-     * Example: "WriteLine", "ShowDialog", "CreateUserCommand"
-     */
-    type: string;
-    /**
-     * Display name for UI.
+     * Activity name - used as command key for execution.
+     * This is the unique identifier for the activity.
      */
-    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 {
+    name: string;
     /**
-     * Activity type name.
+     * Activity type (e.g., "workflow-activity:check-permission").
      */
     type: string;
     /**
      * Display name for UI.
      */
-    displayName: string;
+    title?: string;
     /**
      * Description of what the activity does.
      */
@@ -1164,7 +1131,7 @@ interface ActivityDescriptor {
     /**
      * Category for grouping in toolbox.
      */
-    category: string;
+    category?: string;
     /**
      * Icon name or class.
      */
@@ -1181,11 +1148,11 @@ interface ActivityDescriptor {
     /**
      * Input descriptors.
      */
-    inputs: InputDescriptor[];
+    inputs?: InputDescriptor[];
     /**
      * Output descriptors.
      */
-    outputs: OutputDescriptor[];
+    outputs?: OutputDescriptor[];
     /**
      * Static outcomes (exit points).
      * Example: ['Done', 'Success', 'Failed']
@@ -1202,6 +1169,25 @@ interface ActivityDescriptor {
      */
     isContainer?: boolean;
 }
+/**
+ * Activity - Command with specific TResult structure.
+ * Extends AXPCommand with a fixed TResult that includes output and outcomes.
+ * No additional properties beyond AXPCommand - pure command interface.
+ */
+interface AXPActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
+    output: TOutput;
+    outcomes: Record<string, any>;
+}> {
+    /**
+     * Execute the activity as a command.
+     * @param input - Activity input data
+     * @returns Promise with output and outcomes
+     */
+    execute(input: TInput): AXPExecuteCommandResultPromise<{
+        output: TOutput;
+        outcomes: Record<string, any>;
+    }>;
+}
 /**
  * Input property descriptor.
  * Similar to AXPEntityProperty structure.
@@ -1231,158 +1217,166 @@ interface OutputDescriptor {
         dataType: string;
     };
 }
+
+type AXPActivityProviderToken = AXPActivityProvider | Promise<AXPActivityProvider>;
+declare const AXP_ACTIVITY_PROVIDER: InjectionToken<AXPActivityProviderToken[]>;
+interface AXPActivityProvider {
+    /**
+     * Get list of activity definitions for a category.
+     * @param categoryId - Category ID to filter activities
+     * @returns Promise of activity definitions array
+     */
+    getList(categoryId: string): Promise<AXPActivityDefinition[]>;
+    /**
+     * Get activity definition by name (unique identifier).
+     * The name is used as the command key for execution.
+     * @param name - Activity name (unique identifier and command key)
+     * @returns Promise of activity definition or undefined if not found
+     */
+    getById(name: string): Promise<AXPActivityDefinition | undefined>;
+}
+type AXPActivityCategoryProviderToken = AXPActivityCategoryProvider | Promise<AXPActivityCategoryProvider>;
+declare const AXP_ACTIVITY_CATEGORY_PROVIDER: InjectionToken<AXPActivityCategoryProviderToken[]>;
+interface AXPActivityCategoryProvider {
+    getList(parentId?: string): Promise<AXPActivityCategory[]>;
+    getById(id: string): Promise<AXPActivityCategory | undefined>;
+}
+
 /**
- * Activity registry for registering and creating activities.
- */
-declare class ActivityRegistry {
-    private registry;
-    private descriptors;
+ * Optimized Activity Definition Service
+ *
+ * Manages activity definitions (metadata) for UI and tooling.
+ * Similar to AXPReportDefinitionService - only handles metadata, not execution.
+ *
+ * Performance optimizations:
+ * 1. Uses childrenCount to determine if category has children (no query needed)
+ * 2. Uses itemsCount to determine if category has activities (no query needed)
+ * 3. Aggressive caching prevents duplicate API calls
+ * 4. Single pending request per resource prevents race conditions
+ * 5. Lazy loading - only loads data when needed
+ */
+declare class AXPActivityDefinitionService {
+    private readonly categoryProviders;
+    private readonly activityProviders;
+    /** Cache for categories by id - O(1) lookup */
+    private categoriesById;
+    /** Cache for categories by parentId - O(1) lookup */
+    private categoriesByParentId;
+    /** Cache for activity definitions by categoryId - O(1) lookup */
+    private activitiesByCategory;
+    /** Cache for individual activity definitions by name - O(1) lookup */
+    private activitiesByName;
+    /** Track which provider index owns each category (by category ID) */
+    private categoryOwnership;
+    /** Pending API requests to prevent duplicate calls */
+    private pendingCategoriesRequests;
+    private pendingActivitiesRequests;
+    private pendingActivityRequests;
+    /**
+     * Get categories by parentId with aggressive caching
+     *
+     * Optimization: Returns cached result immediately if available,
+     * preventing unnecessary API calls during navigation
+     *
+     * @param parentId - Parent category ID (undefined = root categories)
+     * @returns Array of categories with count metadata (childrenCount, itemsCount)
+     */
+    getCategories(parentId?: string): Promise<AXPActivityCategory[]>;
     /**
-     * Register an activity type.
+     * Get single category by ID with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval, falls back to
+     * searching cache, then providers if not found
      */
-    register(type: string, factory: () => IActivity, descriptor: ActivityDescriptor): void;
+    getCategoryById(categoryId: string): Promise<AXPActivityCategory | undefined>;
     /**
-     * Create an activity instance.
+     * Get category path from root to specified category
+     *
+     * Optimization: Builds path using cached categories only
      */
-    create(type: string): IActivity;
+    getCategoriesPathById(categoryId: string): Promise<AXPActivityCategory[]>;
     /**
-     * Get activity descriptor.
+     * Get activity definitions for a category with smart caching
+     *
+     * Optimization: Checks itemsCount before querying
+     * - If itemsCount = 0, returns empty array (no API call)
+     * - If itemsCount > 0, loads and caches activity definitions
+     * - Returns cached result on subsequent calls
+     *
+     * @param categoryId - Category ID to get activity definitions from
+     * @returns Array of activity definitions
      */
-    getDescriptor(type: string): ActivityDescriptor | undefined;
+    getActivitiesByCategoryId(categoryId: string): Promise<AXPActivityDefinition[]>;
     /**
-     * Get all registered types.
+     * Get single activity definition by name with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval
+     *
+     * @param name - Activity name (unique identifier and command key)
+     * @returns Activity definition or undefined if not found
      */
-    getTypes(): string[];
+    getActivityByName(name: string): Promise<AXPActivityDefinition | undefined>;
     /**
-     * Get all descriptors.
+     * Get category ID containing a specific activity definition
+     *
+     * Optimization: Searches cache first, loads on-demand if needed
      */
-    getAllDescriptors(): ActivityDescriptor[];
+    getCategoryIdByActivityName(activityName: string): Promise<string | undefined>;
     /**
-     * Get descriptors by category.
+     * Get category path for an activity
      */
-    getDescriptorsByCategory(category: string): ActivityDescriptor[];
-}
-
-interface ActivityCategoryDescriptor {
-    name: string;
-    displayName: string;
-    description?: string;
-    icon?: string;
-    color?: string;
-    order?: number;
-    isVisible?: boolean;
-    tags?: string[];
-}
-interface AXPActivityCategoryProviderContext {
-    registerCategories(categories: ActivityCategoryDescriptor[]): void;
-}
-interface AXPActivityCategoryProvider {
-    provide(context: AXPActivityCategoryProviderContext): Promise<void> | void;
-}
-/**
- * Injection token for activity category providers.
- */
-declare const AXP_ACTIVITY_CATEGORY_PROVIDER: InjectionToken<AXPActivityCategoryProvider[]>;
-declare class AXPActivityCategoryProviderService {
-    private parent?;
-    private providers;
-    private categories;
-    private isInitialized;
-    constructor(parent?: AXPActivityCategoryProviderService | undefined, providers?: AXPActivityCategoryProvider[]);
-    private initialize;
-    getAllCategories(): ActivityCategoryDescriptor[];
-    getCategory(name: string): ActivityCategoryDescriptor | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityCategoryProviderService, [{ optional: true; skipSelf: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityCategoryProviderService>;
-}
-
-/**
- * Context for registering activities in a provider.
- */
-interface AXPActivityProviderContext {
+    getCategoriesPathByActivityName(activityName: string): Promise<AXPActivityCategory[]>;
     /**
-     * Register an activity with its descriptor.
+     * Load categories from providers and cache results
+     *
+     * Optimization: Tracks provider ownership to avoid unnecessary API calls
+     * - For root (parentId = undefined): Query ALL providers
+     * - For children: Only query the provider that owns the parent
      */
-    registerActivity(config: {
-        key: string;
-        descriptor: ActivityDescriptor;
-    }): void;
-}
-/**
- * Interface for activity providers.
- * Modules implement this to register their activities.
- */
-interface AXPActivityProvider {
+    private loadCategoriesFromProviders;
     /**
-     * Provide activities to the system.
+     * Get the provider index that owns a specific category
+     *
+     * @returns Array with provider index, or null if ownership unknown (query all)
      */
-    provide(context: AXPActivityProviderContext): Promise<void> | void;
-}
-/**
- * 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;
-    private initialized;
-    private readonly commandService;
-    private readonly commandRegistry;
+    private getProviderIndexForCategory;
     /**
-     * Register an activity provider.
+     * Load activity definitions from providers and cache results
+     *
+     * Optimization: Only queries the provider that owns the category
+     * Uses provider INDEX to match category provider with activity provider
      */
-    registerProvider(provider: AXPActivityProvider): void;
+    private loadActivitiesFromProviders;
     /**
-     * Register a category provider.
+     * Load single activity definition from providers and cache result
      */
-    registerCategoryProvider(provider: AXPActivityCategoryProvider): void;
+    private loadActivityFromProviders;
     /**
-     * Initialize all providers.
+     * Breadth-first search through category hierarchy
      */
-    initialize(): Promise<void>;
+    private searchCategoryInHierarchy;
     /**
-     * Get activity descriptor by key.
+     * Check if category has children (uses cached count)
      */
-    getDescriptor(key: string): ActivityDescriptor | undefined;
+    categoryHasChildren(categoryId: string): boolean;
     /**
-     * Get all activity descriptors.
+     * Check if category has activities (uses cached count)
      */
-    getAllDescriptors(): ActivityDescriptor[];
+    categoryHasActivities(categoryId: string): boolean;
     /**
-     * Get descriptors by category.
+     * Clear all caches
      */
-    getDescriptorsByCategory(category: string): ActivityDescriptor[];
+    clearAllCache(): void;
     /**
-     * Get all categories.
+     * Clear categories cache only
      */
-    getCategories(): ActivityCategory[];
+    clearCategoriesCache(): void;
     /**
-     * Create an activity instance by key using AXPCommandService.
+     * Clear activities cache only
      */
-    createActivity(key: string): Promise<IActivity | null>;
-    private initializeProvider;
-    private initializeCategoryProvider;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityProviderService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityProviderService>;
+    clearActivitiesCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityDefinitionService>;
 }
 
 /**
@@ -1810,634 +1804,5 @@ declare abstract class AXPWorkflowExecutionService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowExecutionService>;
 }
 
-/**
- * WriteLine Activity - Simple console logging activity.
- *
- * Usage:
- * ```typescript
- * const activity = new WriteLine();
- * await activity.execute({ text: 'Hello World' });
- * ```
- */
-declare class WriteLine extends Activity<{
-    text?: string;
-}, void> {
-    constructor();
-    execute(input: {
-        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>;
-    }>>;
-}
-
-/**
- * Show Confirm Dialog Activity - Displays confirmation dialog to user.
- *
- * Has two outcomes:
- * - 'Confirmed': User clicked confirm/yes
- * - 'Cancelled': User clicked cancel/no
- *
- * Usage:
- * ```typescript
- * const dialog = new ShowConfirmDialog();
- * await dialog.execute({
- *   title: 'Confirm Delete',
- *   message: 'Are you sure?',
- *   color: 'danger'
- * });
- * ```
- */
-declare class ShowConfirmDialog extends Activity<{
-    title?: string;
-    message?: string;
-    color?: AXStyleColorType;
-    defaultAction?: 'confirm' | 'cancel';
-    align?: 'horizontal' | 'vertical';
-    backdrop?: boolean;
-}, {
-    result: boolean;
-    action: string;
-}> {
-    private readonly dialogService;
-    private readonly translationService;
-    constructor();
-    execute(input: {
-        title?: string;
-        message?: string;
-        color?: AXStyleColorType;
-        defaultAction?: 'confirm' | 'cancel';
-        align?: 'horizontal' | 'vertical';
-        backdrop?: boolean;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: {
-            result: boolean;
-            action: string;
-        };
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Show Alert Dialog Activity - Displays alert dialog to user.
- *
- * Has one outcome:
- * - 'Done': User clicked OK
- *
- * Usage:
- * ```typescript
- * const dialog = new ShowAlertDialog();
- * await dialog.execute({
- *   title: 'Alert',
- *   message: 'This is an alert',
- *   color: 'info'
- * });
- * ```
- */
-declare class ShowAlertDialog extends Activity<{
-    title?: string;
-    message?: string;
-    color?: AXStyleColorType;
-}, {
-    result: boolean;
-    action: string;
-}> {
-    private readonly dialogService;
-    private readonly translationService;
-    constructor();
-    execute(input: {
-        title?: string;
-        message?: string;
-        color?: AXStyleColorType;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: {
-            result: boolean;
-            action: string;
-        };
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Show Dialog Layout Builder Activity - Displays dialog using Layout Builder.
- *
- * This activity allows you to create custom dialogs using the Layout Builder API.
- * It accepts JSON-serializable content (AXPWidgetNode) and actions configuration.
- *
- * The content can be created using Layout Builder and then converted to JSON:
- * ```typescript
- * const builder = layoutBuilderService.create();
- * builder.flex(flex => {
- *   flex.setDirection('column')
- *     .formField('First Name', field => {
- *       field.path('firstName');
- *       field.textBox({ placeholder: 'Enter first name' });
- *     });
- * });
- * const contentNode = builder.build();
- * ```
- *
- * Usage in Workflow:
- * ```typescript
- * const dialog = new ShowDialogLayoutBuilder();
- * await dialog.execute({
- *   title: 'User Information',
- *   size: 'md',
- *   context: { firstName: '', lastName: '' },
- *   content: {
- *     type: 'flex-layout',
- *     mode: 'edit',
- *     options: {
- *       flexDirection: 'column',
- *       gap: '16px'
- *     },
- *     children: [
- *       {
- *         type: 'form-field',
- *         mode: 'edit',
- *         options: {
- *           label: 'First Name',
- *           showLabel: true
- *         },
- *         children: [{
- *           type: 'text-editor',
- *           path: 'firstName',
- *           options: {
- *             placeholder: 'Enter first name'
- *           }
- *         }]
- *       }
- *     ]
- *   },
- *   actions: {
- *     cancel: '@general:actions.cancel.title',
- *     submit: '@general:actions.submit.title',
- *     custom: [{
- *       title: 'Save Draft',
- *       icon: 'fa-save',
- *       color: 'secondary',
- *       command: { name: 'save-draft' }
- *     }]
- *   }
- * });
- * ```
- *
- * Usage in JSON Workflow Definition:
- * ```json
- * {
- *   "type": "ShowDialogLayoutBuilder",
- *   "properties": {
- *     "title": "User Information",
- *     "size": "md",
- *     "context": { "firstName": "", "lastName": "" },
- *     "content": {
- *       "type": "flex-layout",
- *       "mode": "edit",
- *       "options": {
- *         "flexDirection": "column",
- *         "gap": "16px"
- *       },
- *       "children": [
- *         {
- *           "type": "form-field",
- *           "mode": "edit",
- *           "options": {
- *             "label": "First Name",
- *             "showLabel": true
- *           },
- *           "children": [{
- *             "type": "text-editor",
- *             "path": "firstName",
- *             "options": {
- *               "placeholder": "Enter first name"
- *             }
- *           }]
- *         }
- *       ]
- *     },
- *     "actions": {
- *       "cancel": "@general:actions.cancel.title",
- *       "submit": "@general:actions.submit.title"
- *     }
- *   }
- * }
- * ```
- */
-declare class ShowDialogLayoutBuilder extends Activity<{
-    /**
-     * Dialog title
-     */
-    title?: string;
-    /**
-     * Dialog size
-     */
-    size?: AXPopupSizeType;
-    /**
-     * Initial dialog context/data
-     */
-    context?: Record<string, any>;
-    /**
-     * Show close button
-     */
-    closeButton?: boolean;
-    /**
-     * Dialog message (optional, shown above content)
-     */
-    message?: string;
-    /**
-     * Dialog content as AXPWidgetNode (JSON-serializable)
-     * This can be created using Layout Builder and then converted to JSON.
-     */
-    content?: AXPWidgetNode;
-    /**
-     * Dialog actions configuration (JSON-serializable)
-     */
-    actions?: {
-        /**
-         * Cancel button text (optional)
-         */
-        cancel?: string;
-        /**
-         * Submit button text (optional)
-         */
-        submit?: string;
-        /**
-         * Custom actions array (optional)
-         */
-        custom?: AXPActionMenuItem[];
-    };
-}, {
-    /**
-     * Dialog context/data after user interaction
-     */
-    context: Record<string, any>;
-    /**
-     * Action that user clicked (e.g., 'submit', 'cancel', or custom action name)
-     */
-    action: string;
-    /**
-     * Whether user cancelled the dialog
-     */
-    cancelled: boolean;
-    /**
-     * Whether user confirmed/submitted the dialog
-     */
-    confirmed: boolean;
-}> {
-    private readonly layoutBuilder;
-    constructor();
-    execute(input: {
-        title?: string;
-        size?: AXPopupSizeType;
-        context?: Record<string, any>;
-        closeButton?: boolean;
-        message?: string;
-        content?: AXPWidgetNode;
-        actions?: {
-            cancel?: string;
-            submit?: string;
-            custom?: AXPActionMenuItem[];
-        };
-    }): Promise<AXPExecuteCommandResult<{
-        output: {
-            context: Record<string, any>;
-            action: string;
-            cancelled: boolean;
-            confirmed: boolean;
-        };
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Show Toast Activity - Displays toast notification to user.
- *
- * Usage:
- * ```typescript
- * const toast = new ShowToast();
- * await toast.execute({
- *   color: 'success',
- *   title: 'Success',
- *   message: 'Operation completed successfully!'
- * });
- * ```
- */
-declare class ShowToast extends Activity<{
-    color?: AXStyleColorType;
-    title?: string;
-    message?: string;
-    duration?: number;
-}, void> {
-    private readonly toastService;
-    private readonly translationService;
-    constructor();
-    execute(input: {
-        color?: AXStyleColorType;
-        title?: string;
-        message?: string;
-        duration?: number;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Navigate Activity - Navigates to different pages/routes.
- *
- * Usage:
- * ```typescript
- * const navigate = new Navigate();
- * await navigate.execute({
- *   mode: 'route',
- *   route: '/users',
- *   params: { id: '123' }
- * });
- * ```
- */
-declare class Navigate extends Activity<{
-    mode?: 'route' | 'entity-details' | 'entity-list' | 'external';
-    route?: string;
-    params?: Record<string, any>;
-    queryParams?: Record<string, any>;
-    entity?: string;
-    entityId?: string;
-    url?: string;
-}, void> {
-    private readonly router;
-    constructor();
-    execute(input: {
-        mode?: 'route' | 'entity-details' | 'entity-list' | 'external';
-        route?: string;
-        params?: Record<string, any>;
-        queryParams?: Record<string, any>;
-        entity?: string;
-        entityId?: string;
-        url?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Set Variable Activity - Sets a variable value in workflow context.
- *
- * Usage:
- * ```typescript
- * const setVar = new SetVariable();
- * await setVar.execute({
- *   variableName: 'userId',
- *   value: '12345'
- * });
- * ```
- */
-declare class SetVariable extends Activity<{
-    variableName: string;
-    value: any;
-}, void> {
-    constructor();
-    execute(input: {
-        variableName: string;
-        value: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Dispatch Event Activity - Dispatches an event to the system.
- *
- * Usage:
- * ```typescript
- * const dispatch = new DispatchEvent();
- * await dispatch.execute({
- *   eventName: 'user-created',
- *   eventData: { userId: '123', name: 'John' }
- * });
- * ```
- */
-declare class DispatchEvent extends Activity<{
-    eventName: string;
-    eventData?: any;
-}, void> {
-    constructor();
-    execute(input: {
-        eventName: string;
-        eventData?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * If Activity - Conditional execution based on a condition.
- *
- * 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];
- * ```
- */
-declare class While extends Activity<{
-    condition: string | boolean;
-    activities?: IActivity[];
-    maxIterations?: number;
-}, any> {
-    constructor();
-    execute(input: {
-        condition: string | boolean;
-        activities?: IActivity[];
-        maxIterations?: number;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-    private evaluateCondition;
-}
-
-/**
- * ForEach Activity - Iterates over a collection of items.
- *
- * Usage:
- * ```typescript
- * const forEach = new ForEach();
- * await forEach.execute({
- *   items: ['item1', 'item2', 'item3'],
- *   activities: [processItemActivity]
- * });
- * ```
- */
-declare class ForEach extends Activity<{
-    items: any[];
-    activities?: IActivity[];
-    itemVariableName?: string;
-    indexVariableName?: string;
-}, any> {
-    constructor();
-    execute(input: {
-        items: any[];
-        activities?: IActivity[];
-        itemVariableName?: string;
-        indexVariableName?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Execute Command Activity - Executes a command through Command Bus.
- *
- * Usage:
- * ```typescript
- * const executeCmd = new ExecuteCommand();
- * await executeCmd.execute({
- *   commandKey: 'UserManagement.CreateUser',
- *   input: { name: 'John', email: 'john@example.com' }
- * });
- * ```
- */
-declare class ExecuteCommand extends Activity<{
-    commandKey: string;
-    input?: any;
-}, any> {
-    private readonly commandService;
-    constructor();
-    execute(input: {
-        commandKey: string;
-        input?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Execute Query Activity - Executes a query through Query Bus.
- *
- * Usage:
- * ```typescript
- * const executeQuery = new ExecuteQuery();
- * await executeQuery.execute({
- *   queryKey: 'UserManagement.GetUsers',
- *   input: { page: 1, pageSize: 10 }
- * });
- * ```
- */
-declare class ExecuteQuery extends Activity<{
-    queryKey: string;
-    input?: any;
-}, any> {
-    private readonly queryService;
-    constructor();
-    execute(input: {
-        queryKey: string;
-        input?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Start Activity - Marks the start point of a workflow.
- *
- * This is a visual marker activity that doesn't perform any actual work.
- * It's used in workflow designers to clearly indicate where a workflow begins.
- *
- * Usage:
- * ```typescript
- * const start = new StartActivity();
- * await start.execute({});
- * ```
- */
-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>;
-    }>>;
-}
-
-/**
- * End Activity - Marks the end point of a workflow.
- *
- * This is a visual marker activity that terminates the workflow execution.
- * When this activity is reached, the workflow completes successfully.
- *
- * Usage:
- * ```typescript
- * const end = new EndActivity();
- * await end.execute({});
- * ```
- */
-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>;
-    }>>;
-}
-
-/**
- * Command setups for all built-in workflow activities.
- * Registers activities as AXPCommand instances.
- */
-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 { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, WorkflowCoordinator, createWorkFlowEvent, ofType };
+export type { AXPActivity, AXPActivityCategory, AXPActivityCategoryProvider, AXPActivityCategoryProviderToken, AXPActivityDefinition, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderToken, 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, AXPActivity$1 as AXPWorkflowActivity, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionPreloader, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityPropertyWidget, InputDescriptor, OutputDescriptor, WorkflowExecutionResult };