@acorex/platform 20.6.0-next.0 → 20.6.0-next.2

package/workflow/index.d.ts

@@ -1,7 +1,11 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
-import { Type, ModuleWithProviders, Injector } from '@angular/core';
+import { Type, ModuleWithProviders, Injector, InjectionToken } from '@angular/core';
+import { AXPValidationRules } from '@acorex/platform/core';
+import { AXPCommand } from '@acorex/platform/runtime';
+import { AXPWidgetTypesMap } from '@acorex/platform/layout/widget-core';
+import { AXStyleColorType } from '@acorex/cdk/common';
 
 declare class AXPWorkflowError extends Error {
     inner: Error | null;
@@ -111,6 +115,7 @@ interface AXPWorkflowModuleConfigs {
     };
 }
 declare class AXPWorkflowModule {
+    private _commandSetup;
     static forRoot(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
     static forChild(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
     /**
@@ -144,5 +149,1533 @@ declare class AXPWorkflowService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowService>;
 }
 
-export { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, createWorkFlowEvent, ofType };
-export type { AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowEvent, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowStep };
+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.
+ */
+interface IActivity<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<{
+        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<{
+        output: TOutput;
+        outcomes: Record<string, any>;
+    }>;
+    /**
+     * Helper method that returns Done outcome by default.
+     */
+    protected createResult(output: TOutput, outcome?: string): {
+        output: TOutput;
+        outcomes: Record<string, any>;
+    };
+}
+/**
+ * Activity descriptor - metadata about an activity type.
+ */
+interface ActivityDescriptor {
+    /**
+     * Activity type name.
+     */
+    type: string;
+    /**
+     * Display name for UI.
+     */
+    displayName: string;
+    /**
+     * Description of what the activity does.
+     */
+    description?: string;
+    /**
+     * Category for grouping in toolbox.
+     */
+    category: string;
+    /**
+     * Icon name or class.
+     */
+    icon?: string;
+    /**
+     * Where this activity should be executed.
+     * - 'frontend': Execute in browser (UI activities, console, events)
+     * - 'backend': Execute in backend (business logic, API calls)
+     * - 'both': Execute in both frontend and backend (hybrid activities)
+     *
+     * Default: 'frontend'
+     */
+    executionMode?: 'frontend' | 'backend' | 'both';
+    /**
+     * Input descriptors.
+     */
+    inputs: InputDescriptor[];
+    /**
+     * Output descriptors.
+     */
+    outputs: OutputDescriptor[];
+    /**
+     * Static outcomes (exit points).
+     * Example: ['Done', 'Success', 'Failed']
+     */
+    outcomes?: string[];
+    /**
+     * Whether this activity is browsable in the toolbox.
+     * Default: true
+     */
+    isBrowsable?: boolean;
+    /**
+     * Whether this activity is a container (can have children).
+     * Default: false
+     */
+    isContainer?: boolean;
+}
+/**
+ * Input property descriptor.
+ * Similar to AXPEntityProperty structure.
+ */
+interface InputDescriptor {
+    name: string;
+    title: string;
+    description?: string;
+    schema: {
+        dataType: string;
+        nullable?: boolean;
+        readonly?: boolean;
+        hidden?: boolean | string;
+        defaultValue?: any | string | ((context: any | null) => any);
+        interface?: ActivityPropertyWidget;
+    };
+    validations?: AXPValidationRules;
+}
+/**
+ * Output property descriptor.
+ */
+interface OutputDescriptor {
+    name: string;
+    title: string;
+    description?: string;
+    schema: {
+        dataType: string;
+    };
+}
+/**
+ * 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[];
+}
+
+/**
+ * Base entity with versioning support.
+ */
+interface VersionedEntity {
+    version: number;
+    isLatest: boolean;
+    isPublished: boolean;
+}
+/**
+ * Simple workflow definition stored in database.
+ */
+interface WorkflowDefinition extends VersionedEntity {
+    /**
+     * Logical definition ID (same across all versions).
+     */
+    definitionId: string;
+    /**
+     * Human-readable name.
+     */
+    name?: string;
+    /**
+     * Description of what the workflow does.
+     */
+    description?: string;
+    /**
+     * Materializer name for deserialization.
+     */
+    materializerName: string;
+    /**
+     * JSON data (for simple workflows).
+     */
+    stringData?: string;
+    /**
+     * Binary data (for complex workflows).
+     */
+    binaryData?: Uint8Array;
+}
+/**
+ * Simple variable definition.
+ */
+interface Variable {
+    id: string;
+    name: string;
+    typeName: string;
+    value?: any;
+}
+/**
+ * Simple input definition.
+ * Similar to AXPEntityProperty structure.
+ */
+interface InputDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    schema: {
+        dataType: string;
+        nullable?: boolean;
+        readonly?: boolean;
+        hidden?: boolean | string;
+        defaultValue?: any | string | ((context: any | null) => any);
+        interface?: ActivityPropertyWidget;
+    };
+    validations?: AXPValidationRules;
+}
+/**
+ * Simple output definition.
+ */
+interface OutputDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    schema: {
+        dataType: string;
+    };
+}
+/**
+ * Common workflow properties.
+ */
+interface WorkflowCommon {
+    options: WorkflowOptions;
+    variables: Variable[];
+    inputs: InputDefinition[];
+    outputs: OutputDefinition[];
+    outcomes: string[];
+    customProperties: Record<string, any>;
+    isReadonly: boolean;
+    isSystem: boolean;
+}
+/**
+ * Workflow configuration options.
+ */
+interface WorkflowOptions {
+    usableAsActivity: boolean;
+    autoUpdateConsumingWorkflows: boolean;
+    activationStrategyType?: string;
+}
+
+/**
+ * Simple workflow definition - just a tree of activities.
+ */
+interface AXPWorkflowEngine {
+    /**
+     * Workflow ID.
+     */
+    id: string;
+    /**
+     * Workflow name.
+     */
+    name: string;
+    /**
+     * Workflow description.
+     */
+    description?: string;
+    /**
+     * Workflow version.
+     */
+    version: number;
+    /**
+     * Root activity to execute.
+     */
+    root: IActivity;
+    /**
+     * All activities in this workflow (flat list for easy access).
+     */
+    activities: IActivity[];
+}
+/**
+ * Simple workflow step - for backward compatibility with old system.
+ */
+interface AXPWorkflowEngineStep {
+    /**
+     * Step ID.
+     */
+    id: string;
+    /**
+     * Activity type to execute.
+     */
+    type: string;
+    /**
+     * Activity name.
+     */
+    name?: string;
+    /**
+     * Input properties for the activity.
+     */
+    properties?: Record<string, any>;
+    /**
+     * Next steps based on outcomes.
+     */
+    nextSteps?: {
+        outcome: string;
+        stepId: string;
+    }[];
+}
+/**
+ * Simple workflow definition for backward compatibility.
+ */
+interface AXPSimpleWorkflowEngine {
+    /**
+     * Workflow ID.
+     */
+    id: string;
+    /**
+     * Workflow name.
+     */
+    name: string;
+    /**
+     * Start step ID.
+     */
+    startStepId: string;
+    /**
+     * All steps in this workflow.
+     */
+    steps: Record<string, AXPWorkflowEngineStep>;
+}
+
+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 {
+    /**
+     * Register an activity with its descriptor.
+     */
+    registerActivity(config: {
+        key: string;
+        descriptor: ActivityDescriptor;
+    }): void;
+}
+/**
+ * Interface for activity providers.
+ * Modules implement this to register their activities.
+ */
+interface AXPActivityProvider {
+    /**
+     * Provide activities to the system.
+     */
+    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;
+    /**
+     * Register an activity provider.
+     */
+    registerProvider(provider: AXPActivityProvider): void;
+    /**
+     * Register a category provider.
+     */
+    registerCategoryProvider(provider: AXPActivityCategoryProvider): void;
+    /**
+     * Initialize all providers.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get activity descriptor by key.
+     */
+    getDescriptor(key: string): ActivityDescriptor | undefined;
+    /**
+     * Get all activity descriptors.
+     */
+    getAllDescriptors(): ActivityDescriptor[];
+    /**
+     * Get descriptors by category.
+     */
+    getDescriptorsByCategory(category: string): ActivityDescriptor[];
+    /**
+     * Get all categories.
+     */
+    getCategories(): ActivityCategory[];
+    /**
+     * Create an activity instance by key using AXPCommandService.
+     */
+    createActivity(key: string): Promise<IActivity | null>;
+    private initializeProvider;
+    private initializeCategoryProvider;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityProviderService>;
+}
+
+/**
+ * Types and interfaces for Workflow Execution Service.
+ */
+
+/**
+ * Represents a workflow task that needs to be executed.
+ * Inspired by Temporal's Activity Tasks and Camunda's External Tasks.
+ */
+interface AXPWorkflowTask {
+    /**
+     * Unique token for this task (used for completion/security).
+     */
+    taskToken: string;
+    /**
+     * Activity ID from workflow definition.
+     */
+    activityId: string;
+    /**
+     * Activity type (e.g., 'workflow-activity:show-toast').
+     */
+    activityType: string;
+    /**
+     * Human-readable activity name.
+     */
+    activityName?: string;
+    /**
+     * Where this task should be executed.
+     * - 'frontend': Execute in browser (UI activities, console, events)
+     * - 'backend': Execute in backend (business logic, API calls)
+     * - 'both': Execute in both frontend and backend (hybrid activities)
+     */
+    executionMode: 'frontend' | 'backend' | 'both';
+    /**
+     * Input data for the activity (for frontend activities).
+     */
+    input?: Record<string, any>;
+    /**
+     * Configuration for the activity (for frontend activities).
+     */
+    config?: Record<string, any>;
+}
+/**
+ * Request to start a workflow execution.
+ */
+interface AXPStartWorkflowExecutionRequest {
+    /**
+     * Workflow ID to execute.
+     */
+    workflowId: string;
+    /**
+     * Initial input data for workflow.
+     */
+    input: Record<string, any>;
+}
+/**
+ * Response after starting workflow execution.
+ */
+interface AXPStartWorkflowExecutionResponse {
+    /**
+     * Unique execution ID for this workflow run.
+     */
+    executionId: string;
+    /**
+     * Current workflow state.
+     */
+    state: AXPWorkflowExecutionState;
+    /**
+     * First task to execute (determined by backend).
+     * Client should execute this task based on executionMode.
+     */
+    pendingTask?: AXPWorkflowTask | null;
+}
+/**
+ * Request to execute a backend activity.
+ */
+interface AXPExecuteBackendActivityRequest {
+    /**
+     * Workflow ID.
+     */
+    workflowId: string;
+    /**
+     * Execution ID.
+     */
+    executionId: string;
+    /**
+     * Activity type (e.g., 'workflow-activity:execute-command').
+     */
+    activityType: string;
+    /**
+     * Activity ID from workflow definition.
+     */
+    activityId: string;
+    /**
+     * Activity properties (input data).
+     */
+    properties: Record<string, any>;
+    /**
+     * Current workflow state (optional, for context).
+     */
+    workflowState?: Partial<AXPWorkflowExecutionState>;
+}
+/**
+ * Response after executing backend activity.
+ */
+interface AXPExecuteBackendActivityResponse {
+    /**
+     * Activity execution output.
+     */
+    output: any;
+    /**
+     * Activity execution outcomes.
+     */
+    outcomes: Record<string, any>;
+    /**
+     * Next task to execute (if any).
+     */
+    nextTask?: AXPWorkflowTask | null;
+    /**
+     * Updated workflow state.
+     */
+    state: AXPWorkflowExecutionState;
+}
+/**
+ * Request to resume a suspended workflow.
+ */
+interface AXPResumeWorkflowExecutionRequest {
+    /**
+     * Execution ID.
+     */
+    executionId: string;
+    /**
+     * Step ID that was waiting for user input.
+     */
+    stepId: string;
+    /**
+     * User action outcome (e.g., 'Confirmed', 'Cancelled').
+     */
+    outcome: string;
+    /**
+     * Optional user input data.
+     */
+    userInput?: any;
+}
+/**
+ * Response after resuming workflow.
+ */
+interface AXPResumeWorkflowExecutionResponse {
+    /**
+     * Activity execution output.
+     */
+    output: any;
+    /**
+     * Activity execution outcomes.
+     */
+    outcomes: Record<string, any>;
+    /**
+     * Next task to execute (if any).
+     */
+    nextTask?: AXPWorkflowTask | null;
+    /**
+     * Updated workflow state.
+     */
+    state: AXPWorkflowExecutionState;
+}
+/**
+ * Request to get workflow execution state.
+ */
+interface AXPGetWorkflowExecutionStateRequest {
+    /**
+     * Execution ID.
+     */
+    executionId: string;
+}
+/**
+ * Request to execute current step from execution state.
+ */
+interface AXPExecuteCurrentStepRequest {
+    /**
+     * Execution ID.
+     */
+    executionId: string;
+}
+/**
+ * Response after executing current step.
+ */
+interface AXPExecuteCurrentStepResponse {
+    /**
+     * Step execution output.
+     */
+    output: any;
+    /**
+     * Step execution outcomes.
+     */
+    outcomes: Record<string, any>;
+    /**
+     * Next task to execute (if any, determined by backend from outcomeConnections).
+     */
+    nextTask?: AXPWorkflowTask | null;
+    /**
+     * Updated workflow state.
+     */
+    state: AXPWorkflowExecutionState;
+}
+/**
+ * Request to get workflow definition.
+ */
+interface AXPGetWorkflowDefinitionRequest {
+    /**
+     * Workflow ID or definition ID.
+     */
+    workflowId: string;
+}
+/**
+ * Response with workflow definition.
+ */
+interface AXPGetWorkflowDefinitionResponse {
+    /**
+     * Workflow definition (executable format).
+     */
+    workflow: AXPWorkflowEngine;
+}
+/**
+ * Workflow execution state (managed by backend, cached in client).
+ */
+interface AXPWorkflowExecutionState {
+    /**
+     * Unique execution ID.
+     */
+    executionId: string;
+    /**
+     * Workflow ID.
+     */
+    workflowId: string;
+    /**
+     * Current execution status.
+     */
+    status: 'running' | 'completed' | 'suspended' | 'error';
+    /**
+     * Current step ID (if suspended or running).
+     */
+    currentStepId?: string;
+    /**
+     * Workflow variables (state).
+     */
+    variables: Record<string, any>;
+    /**
+     * Initial input data.
+     */
+    input: Record<string, any>;
+    /**
+     * Final output data (if completed).
+     */
+    output?: Record<string, any>;
+    /**
+     * Last update timestamp.
+     */
+    lastUpdated: Date;
+}
+/**
+ * Request to complete a task.
+ */
+interface AXPCompleteTaskRequest {
+    /**
+     * Task token from the pending task.
+     */
+    taskToken: string;
+    /**
+     * Task execution result.
+     */
+    result?: any;
+    /**
+     * Error message if task failed.
+     */
+    error?: string;
+}
+/**
+ * Response after completing a task.
+ */
+interface AXPCompleteTaskResponse {
+    /**
+     * Updated workflow state.
+     */
+    state: AXPWorkflowExecutionState;
+    /**
+     * Next task to execute (if any).
+     */
+    nextTask?: AXPWorkflowTask | null;
+}
+
+/**
+ * Workflow execution result.
+ */
+interface WorkflowExecutionResult {
+    success: boolean;
+    output?: any;
+    error?: string;
+    nextTask?: AXPWorkflowTask | null;
+    executionId?: string;
+    state?: AXPWorkflowExecutionState;
+}
+/**
+ * Production Workflow Coordinator.
+ *
+ * Separates frontend/backend execution:
+ * - Frontend activities: Execute with AXPCommand in browser
+ * - Backend activities: Execute via API calls to backend
+ * - State caching: Caches workflow state in client for performance
+ *
+ * ✅ Suitable for production use.
+ */
+declare class WorkflowCoordinator {
+    private readonly workflowExecutionService;
+    private readonly commandService;
+    /**
+     * Cache workflow states in memory for quick access.
+     * Key: executionId
+     * Value: AXPWorkflowExecutionState
+     */
+    private stateCache;
+    /**
+     * Start workflow execution in backend.
+     *
+     * Backend decides what to do: returns pendingTask or indicates completion.
+     * Frontend only calls API - no business logic here.
+     *
+     * @param workflowId - Workflow ID
+     * @param input - Initial input data
+     * @returns Execution result with pendingTask (if any)
+     *
+     * @example
+     * ```typescript
+     * const result = await coordinator.startWorkflow('my-workflow', { userId: '123' });
+     *
+     * if (result.pendingTask) {
+     *   // Execute task if frontend, or wait for backend to complete
+     *   if (result.pendingTask.executionMode === 'frontend') {
+     *     await coordinator.executeTask(result.pendingTask);
+     *     await coordinator.completeTask(result.executionId, result.pendingTask, outcome, output);
+     *   }
+     * }
+     * ```
+     */
+    startWorkflow(workflowId: string, input?: Record<string, any>): Promise<WorkflowExecutionResult>;
+    /**
+     * Execute a frontend task using AXPCommand.
+     *
+     * Only executes if task.executionMode is 'frontend' or 'both'.
+     * Backend tasks are handled automatically by backend.
+     *
+     * @param task - Task to execute
+     * @returns Execution result with output and outcome
+     */
+    executeTask(task: AXPWorkflowTask): Promise<{
+        output: any;
+        outcome: string;
+    }>;
+    /**
+     * Complete a task and get next task from backend.
+     *
+     * Sends task result to backend API.
+     * Backend decides: next task, fail, or complete workflow.
+     *
+     * @param executionId - Execution ID
+     * @param task - Completed task
+     * @param outcome - Task outcome (e.g., 'Done', 'Confirmed', 'Cancelled')
+     * @param output - Task output/result
+     * @returns Next task from backend (if any)
+     */
+    completeTask(executionId: string, task: AXPWorkflowTask, outcome: string, output?: any): Promise<WorkflowExecutionResult>;
+    /**
+     * Execute workflow by ID (backward compatibility).
+     *
+     * @deprecated Use startWorkflow + executeTask + completeTask pattern instead.
+     * This method is kept for backward compatibility but will be removed.
+     */
+    executeWorkflowById(workflowId: string, input?: Record<string, any>): Promise<WorkflowExecutionResult>;
+    /**
+     * Resume a suspended workflow (e.g., after user interaction).
+     *
+     * Backend determines nextStep based on outcome and outcomeConnections.
+     * Client only provides executionId, stepId, outcome, and optional userInput.
+     *
+     * @param executionId - Workflow execution ID
+     * @param stepId - Step ID that was waiting for user input
+     * @param outcome - User action outcome (e.g., 'Confirmed', 'Cancelled', 'Submitted')
+     * @param userInput - Optional user input data
+     */
+    resumeWorkflow(executionId: string, stepId: string, outcome: string, userInput?: any): Promise<WorkflowExecutionResult>;
+    /**
+     * Get workflow execution state (from cache or backend).
+     */
+    getWorkflowState(executionId: string): Promise<AXPWorkflowExecutionState | null>;
+    /**
+     * Start step-based execution (only current step, not full workflow).
+     *
+     * Use this when you only need to execute one step at a time.
+     * Perfect for form-based workflows where user interacts with forms.
+     *
+     * @param workflowId - Workflow ID
+     * @param stepId - Initial step ID to execute
+     * @param input - Initial input data
+     * @returns Execution info with executionId and initial state
+     *
+     * @example
+     * ```typescript
+     * // Start login form step
+     * const execution = await coordinator.startStepExecution(
+     *   'login-workflow',
+     *   'login-form-step',
+     *   {}
+     * );
+     *
+     * // Save executionId for resume after refresh
+     * localStorage.setItem('execution-id', execution.executionId);
+     * ```
+     */
+    startStepExecution(workflowId: string, stepId: string, input?: Record<string, any>): Promise<{
+        executionId: string;
+        state: AXPWorkflowExecutionState;
+    }>;
+    /**
+     * Get next task from backend after backend task completion.
+     *
+     * Use this when backend task completes - backend will return next task.
+     * For frontend tasks, use executeTask + completeTask instead.
+     *
+     * @param executionId - Execution ID
+     * @returns Next task from backend (if any)
+     */
+    getNextTask(executionId: string): Promise<WorkflowExecutionResult>;
+    /**
+     * Execute a frontend activity using CommandBus.
+     *
+     * Frontend activities are executed in the browser using AXPCommandService.
+     * Activities can also be executed in both frontend and backend (hybrid mode).
+     *
+     * @param task - Frontend task to execute
+     * @returns Execution result with output and outcome
+     */
+    private executeFrontendActivity;
+    /**
+     * Start workflow execution in backend.
+     * Backend returns executionId, initial state, and first task to execute.
+     */
+    private startWorkflowExecution;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowCoordinator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkflowCoordinator>;
+}
+
+/**
+ * Abstract service for workflow execution operations.
+ *
+ * This service handles communication with backend for workflow execution.
+ *
+ * Implementation should be provided in connectivity layer:
+ * - Mock implementation: @acorex/connectivity/mock
+ * - API implementation: @acorex/connectivity/api
+ *
+ * @example
+ * ```typescript
+ * // In connectivity/mock
+ * @Injectable()
+ * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
+ *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
+ *     // Mock implementation
+ *   }
+ * }
+ *
+ * // In connectivity/api
+ * @Injectable()
+ * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
+ *   constructor(private http: HttpClient) {}
+ *
+ *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
+ *     return firstValueFrom(
+ *       this.http.post<AXPStartWorkflowExecutionResponse>(
+ *         `${this.config.baseUrl}/api/workflows/${request.workflowId}/start`,
+ *         { input: request.input }
+ *       )
+ *     );
+ *   }
+ * }
+ * ```
+ */
+declare abstract class AXPWorkflowExecutionService {
+    /**
+     * Start a new workflow execution.
+     *
+     * Creates a new workflow execution instance in backend and returns execution ID.
+     *
+     * @param request - Start execution request
+     * @returns Execution response with executionId and initial state
+     *
+     * @example
+     * ```typescript
+     * const response = await workflowExecutionService.startExecution({
+     *   workflowId: 'my-workflow',
+     *   input: { userId: '123', action: 'create' }
+     * });
+     *
+     * console.log('Execution ID:', response.executionId);
+     * console.log('Initial State:', response.state);
+     * ```
+     */
+    abstract startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse>;
+    /**
+     * Execute a backend activity.
+     *
+     * Executes an activity that should run in backend (e.g., execute-command, execute-query, set-variable).
+     *
+     * @param request - Backend activity execution request
+     * @returns Activity execution response with output and updated state
+     *
+     * @example
+     * ```typescript
+     * const response = await workflowExecutionService.executeBackendActivity({
+     *   workflowId: 'my-workflow',
+     *   executionId: 'exec-123',
+     *   activityType: 'workflow-activity:execute-command',
+     *   activityId: 'cmd-1',
+     *   properties: {
+     *     commandKey: 'Entity:Create',
+     *     input: { entity: 'User', data: {...} }
+     *   },
+     *   workflowState: { variables: {...} }
+     * });
+     *
+     * console.log('Output:', response.output);
+     * console.log('Updated State:', response.state);
+     * ```
+     */
+    abstract executeBackendActivity(request: AXPExecuteBackendActivityRequest): Promise<AXPExecuteBackendActivityResponse>;
+    /**
+     * Resume a suspended workflow execution.
+     *
+     * Resumes workflow execution after user interaction (e.g., after show-dialog).
+     *
+     * @param request - Resume execution request
+     * @returns Resume response with next step and updated state
+     *
+     * @example
+     * ```typescript
+     * const response = await workflowExecutionService.resumeExecution({
+     *   executionId: 'exec-123',
+     *   stepId: 'step-dialog-1',
+     *   outcome: 'Confirmed',
+     *   userInput: { confirmed: true }
+     * });
+     *
+     * console.log('Next Step:', response.nextStep);
+     * console.log('Updated State:', response.state);
+     * ```
+     */
+    abstract resumeExecution(request: AXPResumeWorkflowExecutionRequest): Promise<AXPResumeWorkflowExecutionResponse>;
+    /**
+     * Get current workflow execution state.
+     *
+     * Retrieves current state of a workflow execution from backend.
+     *
+     * @param request - Get state request
+     * @returns Current workflow execution state
+     *
+     * @example
+     * ```typescript
+     * const state = await workflowExecutionService.getExecutionState({
+     *   executionId: 'exec-123'
+     * });
+     *
+     * console.log('Status:', state.status);
+     * console.log('Variables:', state.variables);
+     * ```
+     */
+    abstract getExecutionState(request: AXPGetWorkflowExecutionStateRequest): Promise<AXPWorkflowExecutionState>;
+    /**
+     * Get workflow definition by ID.
+     *
+     * Retrieves workflow definition from backend.
+     *
+     * @param request - Get workflow definition request
+     * @returns Workflow definition in executable format
+     *
+     * @example
+     * ```typescript
+     * const response = await workflowExecutionService.getWorkflowDefinition({
+     *   workflowId: 'my-workflow'
+     * });
+     *
+     * console.log('Workflow:', response.workflow);
+     * ```
+     */
+    abstract getWorkflowDefinition(request: AXPGetWorkflowDefinitionRequest): Promise<AXPGetWorkflowDefinitionResponse>;
+    /**
+     * Execute current step from execution state.
+     *
+     * Backend handles everything:
+     * - Gets execution state
+     * - Gets workflow definition
+     * - Finds current step
+     * - Executes step (or returns step info for frontend execution)
+     * - Determines next step based on outcomeConnections
+     *
+     * @param request - Execute current step request
+     * @returns Step execution response with output, outcomes, and next step
+     *
+     * @example
+     * ```typescript
+     * const response = await workflowExecutionService.executeCurrentStep({
+     *   executionId: 'exec-123'
+     * });
+     *
+     * console.log('Output:', response.output);
+     * console.log('Next Step:', response.nextStep);
+     * ```
+     */
+    abstract executeCurrentStep(request: AXPExecuteCurrentStepRequest): Promise<AXPExecuteCurrentStepResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowExecutionService, never>;
+    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<{
+        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<{
+        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<{
+        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<{
+        output: {
+            result: boolean;
+            action: string;
+        };
+        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<{
+        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<{
+        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<{
+        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<{
+        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<{
+        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<{
+        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<{
+        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<{
+        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<{
+        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<{
+        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<{
+        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, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
+export type { AXPActivityCategoryProvider, AXPActivityCategoryProviderContext, AXPActivityProvider, AXPActivityProviderContext, AXPCompleteTaskRequest, AXPCompleteTaskResponse, AXPExecuteBackendActivityRequest, AXPExecuteBackendActivityResponse, AXPExecuteCurrentStepRequest, AXPExecuteCurrentStepResponse, AXPGetWorkflowDefinitionRequest, AXPGetWorkflowDefinitionResponse, AXPGetWorkflowExecutionStateRequest, AXPResumeWorkflowExecutionRequest, AXPResumeWorkflowExecutionResponse, AXPSimpleWorkflowEngine, AXPStartWorkflowExecutionRequest, AXPStartWorkflowExecutionResponse, AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowEngine, AXPWorkflowEngineStep, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowStep, AXPWorkflowTask, ActivityCategory, ActivityCategoryDescriptor, ActivityDescriptor, ActivityPropertyWidget, IActivity, InputDefinition, InputDescriptor, OutputDefinition, OutputDescriptor, Variable, VersionedEntity, WorkflowCommon, WorkflowDefinition, WorkflowExecutionResult, WorkflowOptions };