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

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 { AXPCommand } from '@acorex/platform/runtime';
+import { AXPValidationRules } from '@acorex/platform/core';
+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,1984 @@ 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 };
+/**
+ * Base entity with versioning support.
+ */
+interface AXPVersionedEntity {
+    version: number;
+    isLatest: boolean;
+    isPublished: boolean;
+}
+/**
+ * Workflow definition stored in database.
+ * This is the stored format that matches Elsa backend structure.
+ */
+interface AXPStoredWorkflowDefinition extends AXPVersionedEntity {
+    /**
+     * Unique ID of this workflow definition version.
+     */
+    id: string;
+    /**
+     * Logical definition ID (same across all versions).
+     */
+    definitionId: string;
+    /**
+     * Tenant ID (nullable).
+     */
+    tenantId?: string | null;
+    /**
+     * Human-readable name.
+     */
+    name?: string | null;
+    /**
+     * Description of what the workflow does.
+     */
+    description?: string | null;
+    /**
+     * Creation timestamp (ISO date-time).
+     */
+    createdAt: string;
+    /**
+     * Version of the tool that produced this definition (e.g. "3.2.0.0").
+     */
+    toolVersion?: string | null;
+    /**
+     * Materializer name for deserialization.
+     */
+    materializerName?: string;
+    /**
+     * JSON data (for simple workflows).
+     */
+    stringData?: string;
+    /**
+     * Binary data (for complex workflows).
+     */
+    binaryData?: Uint8Array;
+}
+/**
+ * Variable definition.
+ * Matches VariableDefinition from workflow definition schema.
+ */
+interface AXPVariableDefinition {
+    /**
+     * Variable ID.
+     */
+    id?: string;
+    /**
+     * Variable name.
+     */
+    name: string;
+    /**
+     * Type name (e.g., "String", "Int32", "Boolean").
+     */
+    typeName: string;
+    /**
+     * Whether this is an array type.
+     */
+    isArray?: boolean;
+    /**
+     * Variable value (as string expression or literal).
+     */
+    value?: string | null;
+    /**
+     * Storage driver type name (for custom storage).
+     */
+    storageDriverTypeName?: string | null;
+}
+/**
+ * Workflow input definition.
+ * Matches WorkflowInputDefinition from workflow definition schema.
+ */
+interface AXPWorkflowInputDefinition {
+    /**
+     * Input type (e.g., "String", "Int32", "Object").
+     */
+    type: string;
+    /**
+     * Input name.
+     */
+    name: string;
+    /**
+     * Display name.
+     */
+    displayName?: string;
+    /**
+     * Description.
+     */
+    description?: string;
+    /**
+     * Category for grouping.
+     */
+    category?: string;
+    /**
+     * UI hint (widget type).
+     */
+    uiHint?: string;
+    /**
+     * Storage driver type (for custom storage).
+     */
+    storageDriverType?: string | null;
+}
+/**
+ * Workflow output definition.
+ * Matches WorkflowOutputDefinition from workflow definition schema.
+ */
+interface AXPWorkflowOutputDefinition {
+    /**
+     * Output type (e.g., "String", "Int32", "Object").
+     */
+    type: string;
+    /**
+     * Output name.
+     */
+    name: string;
+    /**
+     * Display name.
+     */
+    displayName?: string;
+    /**
+     * Description.
+     */
+    description?: string;
+    /**
+     * Category for grouping.
+     */
+    category?: string;
+}
+/**
+ * Expression.
+ * Used for dynamic values in activities.
+ */
+interface AXPExpression {
+    /**
+     * Expression type (e.g., "Literal", "JavaScript", "Liquid").
+     */
+    type: string;
+    /**
+     * Expression value.
+     */
+    value?: any;
+}
+/**
+ * Input value wrapper.
+ * Wraps an expression with type information.
+ */
+interface AXPInputValue {
+    /**
+     * Type name.
+     */
+    typeName: string;
+    /**
+     * Expression (or null).
+     */
+    expression?: AXPExpression | null;
+}
+/**
+ * Output value wrapper.
+ * References memory location.
+ */
+interface AXPOutputValue {
+    /**
+     * Type name.
+     */
+    typeName: string;
+    /**
+     * Memory reference (or null).
+     */
+    memoryReference?: {
+        id: string;
+    } | null;
+}
+/**
+ * Position (for visual layout).
+ */
+interface AXPPosition {
+    x: number;
+    y: number;
+}
+/**
+ * Endpoint (connection point).
+ */
+interface AXPEndpoint {
+    /**
+     * Activity ID.
+     */
+    activity: string;
+    /**
+     * Port name (nullable).
+     */
+    port?: string | null;
+}
+/**
+ * Connection between activities.
+ */
+interface AXPConnection {
+    /**
+     * Source endpoint.
+     */
+    source: AXPEndpoint;
+    /**
+     * Target endpoint.
+     */
+    target: AXPEndpoint;
+    /**
+     * Connection vertices (for curved paths).
+     */
+    vertices?: AXPPosition[];
+}
+/**
+ * Variable model (for flowchart variables).
+ */
+interface AXPVariableModel {
+    id: string;
+    name: string;
+    typeName: string;
+    value?: string | null;
+    storageDriverTypeName?: string | null;
+}
+/**
+ * Metadata (designer annotations).
+ */
+interface AXPMetadata {
+    [key: string]: any;
+}
+/**
+ * Custom properties (free-form bag).
+ */
+interface AXPCustomProperties {
+    /**
+     * Connections that reference non-existent activities.
+     */
+    notFoundConnections?: AXPConnection[];
+    /**
+     * Additional custom properties.
+     */
+    [key: string]: any;
+}
+/**
+ * Base activity (workflow definition format).
+ * Matches Activity from workflow definition schema.
+ * Note: This is the workflow definition format, not the frontend Activity class.
+ */
+interface AXPActivity {
+    /**
+     * Activity ID.
+     */
+    id: string;
+    /**
+     * Node ID (for visual designer).
+     */
+    nodeId: string;
+    /**
+     * Activity name.
+     */
+    name?: string | null;
+    /**
+     * Activity type (e.g., "Elsa.WriteLine", "Elsa.If").
+     */
+    type: string;
+    /**
+     * Activity version.
+     */
+    version: number;
+    /**
+     * Execution mode for this activity instance.
+     * Determines where this activity should be executed:
+     * - 'frontend': Execute in browser (UI activities like dialogs, toasts, navigation)
+     * - '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.
+     * This allows per-instance override of the default execution mode.
+     *
+     * @example
+     * ```json
+     * {
+     *   "id": "show-dialog",
+     *   "type": "Elsa.ShowDialog",
+     *   "executionMode": "frontend"
+     * }
+     * ```
+     */
+    executionMode?: 'frontend' | 'backend' | 'both';
+    /**
+     * Custom properties.
+     */
+    customProperties?: AXPCustomProperties;
+    /**
+     * Metadata (designer annotations).
+     */
+    metadata?: AXPMetadata;
+    /**
+     * Additional type-specific properties.
+     */
+    [key: string]: any;
+}
+/**
+ * Flowchart activity (workflow definition format).
+ * Matches Flowchart from workflow definition schema.
+ * This is the root activity that contains all other activities.
+ */
+interface AXPFlowchart extends AXPActivity {
+    /**
+     * Type must be "Elsa.Flowchart" (for Elsa backend compatibility).
+     */
+    type: "Elsa.Flowchart";
+    /**
+     * Activities in this flowchart.
+     */
+    activities: AXPActivity[];
+    /**
+     * Variables in this flowchart.
+     */
+    variables?: AXPVariableModel[];
+    /**
+     * Connections between activities.
+     */
+    connections: AXPConnection[];
+}
+/**
+ * Complete workflow definition (v3.0.0 format).
+ * This matches the Elsa Workflow Definition schema for backend compatibility.
+ * All workflow definitions use this format.
+ */
+interface AXPWorkflowDefinition {
+    /**
+     * Schema reference.
+     */
+    $schema?: string;
+    /**
+     * Unique ID of this workflow definition version.
+     */
+    id: string;
+    /**
+     * Logical definition ID (same across all versions).
+     */
+    definitionId: string;
+    /**
+     * Tenant ID (nullable).
+     */
+    tenantId?: string | null;
+    /**
+     * Human-readable name.
+     */
+    name?: string | null;
+    /**
+     * Description.
+     */
+    description?: string | null;
+    /**
+     * Creation timestamp (ISO date-time).
+     */
+    createdAt: string;
+    /**
+     * Version number (minimum 1).
+     */
+    version: number;
+    /**
+     * Tool version (e.g., "3.2.0.0").
+     */
+    toolVersion?: string | null;
+    /**
+     * Workflow variables.
+     */
+    variables?: AXPVariableDefinition[];
+    /**
+     * Workflow inputs.
+     */
+    inputs?: AXPWorkflowInputDefinition[];
+    /**
+     * Workflow outputs.
+     */
+    outputs?: AXPWorkflowOutputDefinition[];
+    /**
+     * Workflow outcomes.
+     */
+    outcomes?: string[];
+    /**
+     * Custom properties.
+     */
+    customProperties?: AXPCustomProperties;
+    /**
+     * Whether workflow is readonly.
+     */
+    isReadonly: boolean;
+    /**
+     * Whether workflow is system workflow.
+     */
+    isSystem: boolean;
+    /**
+     * Whether this is the latest version.
+     */
+    isLatest: boolean;
+    /**
+     * Whether workflow is published.
+     */
+    isPublished: boolean;
+    /**
+     * Workflow options.
+     */
+    options?: AXPWorkflowOptions;
+    /**
+     * @deprecated Use options.usableAsActivity instead.
+     */
+    usableAsActivity?: boolean | null;
+    /**
+     * Root activity (Flowchart).
+     */
+    root: AXPFlowchart;
+}
+/**
+ * Workflow configuration options.
+ */
+interface AXPWorkflowOptions {
+    /**
+     * Activation strategy type.
+     */
+    activationStrategyType?: string | null;
+    /**
+     * Whether workflow can be used as an activity.
+     */
+    usableAsActivity?: boolean | null;
+    /**
+     * Auto-update consuming workflows.
+     */
+    autoUpdateConsumingWorkflows?: boolean;
+    /**
+     * Activity category (if usable as activity).
+     */
+    activityCategory?: string | null;
+    /**
+     * Incident strategy type.
+     */
+    incidentStrategyType?: string | null;
+    /**
+     * Commit strategy name.
+     */
+    commitStrategyName?: string | null;
+}
+
+/**
+ * Workflow status.
+ */
+type AXPWorkflowStatus = 'Running' | 'Finished';
+/**
+ * Workflow sub-status.
+ */
+type AXPWorkflowSubStatus = 'Pending' | 'Executing' | 'Suspended' | 'Finished' | 'Cancelled' | 'Faulted';
+/**
+ * Activity status.
+ */
+type AXPActivityStatus = 'Running' | 'Completed' | 'Canceled' | 'Faulted';
+/**
+ * Exception state.
+ */
+interface AXPExceptionState {
+    /**
+     * Exception type name.
+     */
+    type: string;
+    /**
+     * Exception message.
+     */
+    message: string;
+    /**
+     * Stack trace (nullable).
+     */
+    stackTrace?: string | null;
+    /**
+     * Inner exception (nullable).
+     */
+    innerException?: AXPExceptionState | null;
+}
+/**
+ * Activity incident.
+ */
+interface AXPActivityIncident {
+    /**
+     * Activity ID that caused the incident.
+     */
+    activityId: string;
+    /**
+     * Activity node ID.
+     */
+    activityNodeId: string;
+    /**
+     * Activity type.
+     */
+    activityType: string;
+    /**
+     * Incident message.
+     */
+    message: string;
+    /**
+     * Exception (nullable).
+     */
+    exception?: AXPExceptionState | null;
+    /**
+     * Timestamp (ISO date-time).
+     */
+    timestamp: string;
+}
+/**
+ * Workflow fault state.
+ */
+interface AXPWorkflowFaultState {
+    /**
+     * Exception (nullable).
+     */
+    exception?: AXPExceptionState | null;
+    /**
+     * Fault message.
+     */
+    message: string;
+    /**
+     * Faulted activity ID (nullable).
+     */
+    faultedActivityId?: string | null;
+}
+/**
+ * Bookmark.
+ */
+interface AXPBookmark {
+    /**
+     * Bookmark ID.
+     */
+    id: string;
+    /**
+     * Bookmark name.
+     */
+    name: string;
+    /**
+     * Bookmark hash.
+     */
+    hash: string;
+    /**
+     * Bookmark payload (nullable).
+     */
+    payload?: any | null;
+    /**
+     * Activity node ID.
+     */
+    activityNodeId: string;
+    /**
+     * Activity instance ID.
+     */
+    activityInstanceId: string;
+    /**
+     * Auto burn flag.
+     */
+    autoBurn?: boolean;
+    /**
+     * Callback method name (nullable).
+     */
+    callbackMethodName?: string | null;
+    /**
+     * Metadata (nullable).
+     */
+    metadata?: Record<string, string> | null;
+}
+/**
+ * Completion callback state.
+ */
+interface AXPCompletionCallbackState {
+    /**
+     * Owner activity instance ID.
+     */
+    ownerInstanceId: string;
+    /**
+     * Child activity node ID.
+     */
+    childNodeId: string;
+    /**
+     * Method name (nullable).
+     */
+    methodName?: string | null;
+}
+/**
+ * Variable (for activity context).
+ */
+interface AXPActivityVariable {
+    /**
+     * Variable ID.
+     */
+    id: string;
+    /**
+     * Variable name.
+     */
+    name: string;
+    /**
+     * Type name.
+     */
+    typeName: string;
+    /**
+     * Is array flag.
+     */
+    isArray?: boolean;
+    /**
+     * Variable value (nullable).
+     */
+    value?: any | null;
+    /**
+     * Storage driver type name (nullable).
+     */
+    storageDriverTypeName?: string | null;
+}
+/**
+ * Activity execution context state.
+ */
+interface AXPActivityExecutionContextState {
+    /**
+     * Context ID (activity instance ID).
+     */
+    id: string;
+    /**
+     * Parent context ID (nullable).
+     */
+    parentContextId?: string | null;
+    /**
+     * Scheduled activity node ID.
+     */
+    scheduledActivityNodeId: string;
+    /**
+     * Owner activity node ID (nullable).
+     */
+    ownerActivityNodeId?: string | null;
+    /**
+     * Properties bag.
+     */
+    properties: Record<string, any>;
+    /**
+     * Activity state (evaluated properties) (nullable).
+     */
+    activityState?: Record<string, any> | null;
+    /**
+     * Dynamic variables.
+     */
+    dynamicVariables: AXPActivityVariable[];
+    /**
+     * Activity status.
+     */
+    status: AXPActivityStatus;
+    /**
+     * Is executing flag.
+     */
+    isExecuting: boolean;
+    /**
+     * Fault count.
+     */
+    faultCount: number;
+    /**
+     * Started at timestamp (ISO date-time).
+     */
+    startedAt: string;
+    /**
+     * Completed at timestamp (ISO date-time, nullable).
+     */
+    completedAt?: string | null;
+    /**
+     * Tag (nullable).
+     */
+    tag?: any | null;
+}
+/**
+ * Workflow state (internal execution state).
+ */
+interface AXPWorkflowState {
+    /**
+     * State ID.
+     */
+    id: string;
+    /**
+     * Workflow definition ID.
+     */
+    definitionId: string;
+    /**
+     * Workflow definition version.
+     */
+    definitionVersion: number;
+    /**
+     * Correlation ID (nullable).
+     */
+    correlationId?: string | null;
+    /**
+     * Workflow status.
+     */
+    status: AXPWorkflowStatus;
+    /**
+     * Workflow sub-status.
+     */
+    subStatus: AXPWorkflowSubStatus;
+    /**
+     * Bookmarks.
+     */
+    bookmarks: AXPBookmark[];
+    /**
+     * Incidents.
+     */
+    incidents: AXPActivityIncident[];
+    /**
+     * Fault (nullable).
+     */
+    fault?: AXPWorkflowFaultState | null;
+    /**
+     * Completion callbacks.
+     */
+    completionCallbacks: AXPCompletionCallbackState[];
+    /**
+     * Activity execution contexts.
+     */
+    activityExecutionContexts: AXPActivityExecutionContextState[];
+    /**
+     * Input data.
+     */
+    input: Record<string, any>;
+    /**
+     * Output data.
+     */
+    output: Record<string, any>;
+    /**
+     * Properties bag.
+     */
+    properties: Record<string, any>;
+    /**
+     * Created at timestamp (ISO date-time).
+     */
+    createdAt: string;
+    /**
+     * Updated at timestamp (ISO date-time).
+     */
+    updatedAt: string;
+    /**
+     * Finished at timestamp (ISO date-time, nullable).
+     */
+    finishedAt?: string | null;
+}
+/**
+ * Workflow instance (stored in database).
+ * This matches the Elsa Workflow Instance schema for backend compatibility.
+ */
+interface AXPWorkflowInstance {
+    /**
+     * Schema reference.
+     */
+    $schema?: string;
+    /**
+     * Unique instance ID.
+     */
+    id: string;
+    /**
+     * Workflow definition ID.
+     */
+    definitionId: string;
+    /**
+     * Workflow definition version ID.
+     */
+    definitionVersionId: string;
+    /**
+     * Workflow definition version number.
+     */
+    version: number;
+    /**
+     * Parent workflow instance ID (nullable, for child workflows).
+     */
+    parentWorkflowInstanceId?: string | null;
+    /**
+     * Workflow state (internal execution state).
+     */
+    workflowState: AXPWorkflowState;
+    /**
+     * Workflow status.
+     */
+    status: AXPWorkflowStatus;
+    /**
+     * Workflow sub-status.
+     */
+    subStatus: AXPWorkflowSubStatus;
+    /**
+     * Correlation ID (nullable).
+     */
+    correlationId?: string | null;
+    /**
+     * Instance name (nullable).
+     */
+    name?: string | null;
+    /**
+     * Incident count.
+     */
+    incidentCount: number;
+    /**
+     * Created at timestamp (ISO date-time).
+     */
+    createdAt: string;
+    /**
+     * Updated at timestamp (ISO date-time).
+     */
+    updatedAt: string;
+    /**
+     * Finished at timestamp (ISO date-time, nullable).
+     */
+    finishedAt?: string | null;
+}
+
+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[];
+}
+
+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 resume a suspended workflow.
+ */
+interface AXPResumeWorkflowExecutionRequest {
+    /**
+     * Execution ID.
+     */
+    executionId: string;
+    /**
+     * Step ID that was waiting for user input.
+     */
+    stepId: string;
+    /**
+     * Secure task token issued with the pending task.
+     * Backend validates and resolves the step using this token.
+     */
+    taskToken: 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 get workflow definition.
+ */
+interface AXPGetWorkflowDefinitionRequest {
+    /**
+     * Workflow ID or definition ID.
+     */
+    workflowId: string;
+}
+/**
+ * Response with workflow definition.
+ */
+interface AXPGetWorkflowDefinitionResponse {
+    /**
+     * Workflow definition.
+     */
+    workflow: AXPWorkflowDefinition;
+}
+/**
+ * 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;
+}
+
+/**
+ * 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, taskToken?: string): Promise<WorkflowExecutionResult>;
+    /**
+     * Get workflow execution state (from cache or backend).
+     */
+    getWorkflowState(executionId: string): Promise<AXPWorkflowExecutionState | null>;
+    /**
+     * 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>;
+    /**
+     * 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',
+     *   taskToken: 'sec-task-token',
+     *   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>;
+    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 { 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, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityCategory, ActivityCategoryDescriptor, ActivityDescriptor, ActivityPropertyWidget, IActivity, InputDescriptor, OutputDescriptor, WorkflowExecutionResult };