@acorex/platform 20.6.0-next.1 → 20.6.0-next.3

package/workflow/index.d.ts

@@ -2,8 +2,8 @@ import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
 import { Type, ModuleWithProviders, Injector, InjectionToken } from '@angular/core';
-import { AXPValidationRules } from '@acorex/platform/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';
 
@@ -149,230 +149,943 @@ declare class AXPWorkflowService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowService>;
 }
 
-interface ActivityPropertyWidget {
-    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
-    options?: Record<string, any>;
+/**
+ * Base entity with versioning support.
+ */
+interface AXPVersionedEntity {
+    version: number;
+    isLatest: boolean;
+    isPublished: boolean;
 }
 /**
- * Simple activity interface - just a command with outcomes.
- * All activities are AXPCommand for unified execution through Command Bus.
+ * Workflow definition stored in database.
+ * This is the stored format that matches Elsa backend structure.
  */
-interface IActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
-    output: TOutput;
-    outcomes: Record<string, any>;
-}> {
+interface AXPStoredWorkflowDefinition extends AXPVersionedEntity {
     /**
-     * Activity type name.
-     * Example: "WriteLine", "ShowDialog", "CreateUserCommand"
+     * Unique ID of this workflow definition version.
      */
-    type: string;
+    id: string;
     /**
-     * Display name for UI.
+     * Logical definition ID (same across all versions).
      */
-    name?: string;
+    definitionId: string;
     /**
-     * Execute the activity as a command.
-     * @param input - Activity input data
-     * @returns Promise with output and outcomes
+     * Tenant ID (nullable).
      */
-    execute(input: TInput): Promise<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>;
+    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;
 }
 /**
- * Base abstract class for activities.
- * Extend this to create custom activities.
+ * Variable definition.
+ * Matches VariableDefinition from workflow definition schema.
  */
-declare abstract class Activity<TInput = any, TOutput = any> implements IActivity<TInput, TOutput> {
+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;
-    name?: string;
-    constructor(type: string, name?: string);
     /**
-     * Execute the activity as a command.
-     * Override this method in subclasses to implement activity logic.
+     * Input name.
      */
-    abstract execute(input: TInput): Promise<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>;
+    name: string;
     /**
-     * Helper method that returns Done outcome by default.
+     * Display name.
      */
-    protected createResult(output: TOutput, outcome?: string): {
-        output: TOutput;
-        outcomes: Record<string, any>;
-    };
+    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;
 }
 /**
- * Activity descriptor - metadata about an activity type.
+ * Workflow output definition.
+ * Matches WorkflowOutputDefinition from workflow definition schema.
  */
-interface ActivityDescriptor {
+interface AXPWorkflowOutputDefinition {
     /**
-     * Activity type name.
+     * Output type (e.g., "String", "Int32", "Object").
      */
     type: string;
     /**
-     * Display name for UI.
+     * Output name.
      */
-    displayName: string;
+    name: string;
     /**
-     * Description of what the activity does.
+     * Display name.
+     */
+    displayName?: string;
+    /**
+     * Description.
      */
     description?: string;
     /**
-     * Category for grouping in toolbox.
+     * Category for grouping.
      */
-    category: string;
+    category?: string;
+}
+/**
+ * Expression.
+ * Used for dynamic values in activities.
+ */
+interface AXPExpression {
     /**
-     * Icon name or class.
+     * Expression type (e.g., "Literal", "JavaScript", "Liquid").
      */
-    icon?: string;
+    type: 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'
+     * Expression value.
      */
-    executionMode?: 'frontend' | 'backend' | 'both';
+    value?: any;
+}
+/**
+ * Input value wrapper.
+ * Wraps an expression with type information.
+ */
+interface AXPInputValue {
     /**
-     * Input descriptors.
+     * Type name.
      */
-    inputs: InputDescriptor[];
+    typeName: string;
     /**
-     * Output descriptors.
+     * Expression (or null).
      */
-    outputs: OutputDescriptor[];
+    expression?: AXPExpression | null;
+}
+/**
+ * Output value wrapper.
+ * References memory location.
+ */
+interface AXPOutputValue {
     /**
-     * Static outcomes (exit points).
-     * Example: ['Done', 'Success', 'Failed']
+     * Type name.
      */
-    outcomes?: string[];
+    typeName: string;
     /**
-     * Whether this activity is browsable in the toolbox.
-     * Default: true
+     * Memory reference (or null).
      */
-    isBrowsable?: boolean;
+    memoryReference?: {
+        id: string;
+    } | null;
+}
+/**
+ * Position (for visual layout).
+ */
+interface AXPPosition {
+    x: number;
+    y: number;
+}
+/**
+ * Endpoint (connection point).
+ */
+interface AXPEndpoint {
     /**
-     * Whether this activity is a container (can have children).
-     * Default: false
+     * Activity ID.
      */
-    isContainer?: boolean;
+    activity: string;
+    /**
+     * Port name (nullable).
+     */
+    port?: string | null;
 }
 /**
- * Input property descriptor.
- * Similar to AXPEntityProperty structure.
+ * Connection between activities.
  */
-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;
+interface AXPConnection {
+    /**
+     * Source endpoint.
+     */
+    source: AXPEndpoint;
+    /**
+     * Target endpoint.
+     */
+    target: AXPEndpoint;
+    /**
+     * Connection vertices (for curved paths).
+     */
+    vertices?: AXPPosition[];
 }
 /**
- * Output property descriptor.
+ * Variable model (for flowchart variables).
  */
-interface OutputDescriptor {
+interface AXPVariableModel {
+    id: string;
     name: string;
-    title: string;
-    description?: string;
-    schema: {
-        dataType: string;
-    };
+    typeName: string;
+    value?: string | null;
+    storageDriverTypeName?: string | null;
 }
 /**
- * Activity registry for registering and creating activities.
+ * Metadata (designer annotations).
  */
-declare class ActivityRegistry {
-    private registry;
-    private descriptors;
+interface AXPMetadata {
+    [key: string]: any;
+}
+/**
+ * Custom properties (free-form bag).
+ */
+interface AXPCustomProperties {
     /**
-     * Register an activity type.
+     * Connections that reference non-existent activities.
      */
-    register(type: string, factory: () => IActivity, descriptor: ActivityDescriptor): void;
+    notFoundConnections?: AXPConnection[];
     /**
-     * Create an activity instance.
+     * Additional custom properties.
      */
-    create(type: string): IActivity;
+    [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 {
     /**
-     * Get activity descriptor.
+     * Activity ID.
      */
-    getDescriptor(type: string): ActivityDescriptor | undefined;
+    id: string;
     /**
-     * Get all registered types.
+     * Node ID (for visual designer).
      */
-    getTypes(): string[];
+    nodeId: string;
     /**
-     * Get all descriptors.
+     * Activity name.
      */
-    getAllDescriptors(): ActivityDescriptor[];
+    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;
     /**
-     * Get descriptors by category.
+     * Icon name or class.
      */
-    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 {
+    icon?: string;
     /**
-     * Logical definition ID (same across all versions).
+     * 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'
      */
-    definitionId: string;
+    executionMode?: 'frontend' | 'backend' | 'both';
     /**
-     * Human-readable name.
+     * Input descriptors.
      */
-    name?: string;
+    inputs: InputDescriptor[];
     /**
-     * Description of what the workflow does.
+     * Output descriptors.
      */
-    description?: string;
+    outputs: OutputDescriptor[];
     /**
-     * Materializer name for deserialization.
+     * Static outcomes (exit points).
+     * Example: ['Done', 'Success', 'Failed']
      */
-    materializerName: string;
+    outcomes?: string[];
     /**
-     * JSON data (for simple workflows).
+     * Whether this activity is browsable in the toolbox.
+     * Default: true
      */
-    stringData?: string;
+    isBrowsable?: boolean;
     /**
-     * Binary data (for complex workflows).
+     * Whether this activity is a container (can have children).
+     * Default: false
      */
-    binaryData?: Uint8Array;
-}
-/**
- * Simple variable definition.
- */
-interface Variable {
-    id: string;
-    name: string;
-    typeName: string;
-    value?: any;
+    isContainer?: boolean;
 }
 /**
- * Simple input definition.
+ * Input property descriptor.
  * Similar to AXPEntityProperty structure.
  */
-interface InputDefinition {
+interface InputDescriptor {
     name: string;
     title: string;
     description?: string;
@@ -387,9 +1100,9 @@ interface InputDefinition {
     validations?: AXPValidationRules;
 }
 /**
- * Simple output definition.
+ * Output property descriptor.
  */
-interface OutputDefinition {
+interface OutputDescriptor {
     name: string;
     title: string;
     description?: string;
@@ -398,104 +1111,35 @@ interface OutputDefinition {
     };
 }
 /**
- * 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.
+ * Activity registry for registering and creating activities.
  */
-interface AXPWorkflowEngineStep {
-    /**
-     * Step ID.
-     */
-    id: string;
-    /**
-     * Activity type to execute.
-     */
-    type: string;
-    /**
-     * Activity name.
-     */
-    name?: string;
+declare class ActivityRegistry {
+    private registry;
+    private descriptors;
     /**
-     * Input properties for the activity.
+     * Register an activity type.
      */
-    properties?: Record<string, any>;
+    register(type: string, factory: () => IActivity, descriptor: ActivityDescriptor): void;
     /**
-     * Next steps based on outcomes.
+     * Create an activity instance.
      */
-    nextSteps?: {
-        outcome: string;
-        stepId: string;
-    }[];
-}
-/**
- * Simple workflow definition for backward compatibility.
- */
-interface AXPSimpleWorkflowEngine {
+    create(type: string): IActivity;
     /**
-     * Workflow ID.
+     * Get activity descriptor.
      */
-    id: string;
+    getDescriptor(type: string): ActivityDescriptor | undefined;
     /**
-     * Workflow name.
+     * Get all registered types.
      */
-    name: string;
+    getTypes(): string[];
     /**
-     * Start step ID.
+     * Get all descriptors.
      */
-    startStepId: string;
+    getAllDescriptors(): ActivityDescriptor[];
     /**
-     * All steps in this workflow.
+     * Get descriptors by category.
      */
-    steps: Record<string, AXPWorkflowEngineStep>;
+    getDescriptorsByCategory(category: string): ActivityDescriptor[];
 }
 
 interface ActivityCategoryDescriptor {
@@ -692,56 +1336,6 @@ interface AXPStartWorkflowExecutionResponse {
      */
     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.
  */
@@ -754,6 +1348,11 @@ interface AXPResumeWorkflowExecutionRequest {
      * 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').
      */
@@ -793,36 +1392,6 @@ interface AXPGetWorkflowExecutionStateRequest {
      */
     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.
  */
@@ -837,9 +1406,9 @@ interface AXPGetWorkflowDefinitionRequest {
  */
 interface AXPGetWorkflowDefinitionResponse {
     /**
-     * Workflow definition (executable format).
+     * Workflow definition.
      */
-    workflow: AXPWorkflowEngine;
+    workflow: AXPWorkflowDefinition;
 }
 /**
  * Workflow execution state (managed by backend, cached in client).
@@ -878,36 +1447,6 @@ interface AXPWorkflowExecutionState {
      */
     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.
@@ -1007,49 +1546,11 @@ declare class WorkflowCoordinator {
      * @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>;
+    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>;
-    /**
-     * 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.
      *
@@ -1125,33 +1626,6 @@ declare abstract class AXPWorkflowExecutionService {
      * ```
      */
     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.
      *
@@ -1165,6 +1639,7 @@ declare abstract class AXPWorkflowExecutionService {
      * const response = await workflowExecutionService.resumeExecution({
      *   executionId: 'exec-123',
      *   stepId: 'step-dialog-1',
+     *   taskToken: 'sec-task-token',
      *   outcome: 'Confirmed',
      *   userInput: { confirmed: true }
      * });
@@ -1211,30 +1686,6 @@ declare abstract class AXPWorkflowExecutionService {
      * ```
      */
     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>;
 }
@@ -1678,4 +2129,4 @@ declare class EndActivity extends Activity<Record<string, never>, void> {
 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 };
+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 };