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

package/workflow/index.d.ts

@@ -1,1808 +0,0 @@
-import * as rxjs from 'rxjs';
-import { Observable } from 'rxjs';
-import * as i0 from '@angular/core';
-import { Type, ModuleWithProviders, Injector, InjectionToken } from '@angular/core';
-import { AXPCommand, AXPExecuteCommandResultPromise } from '@acorex/platform/runtime';
-import { AXPCategoryEntity, AXPValidationRules } from '@acorex/platform/core';
-import { AXPWidgetTypesMap } from '@acorex/platform/layout/widget-core';
-
-declare class AXPWorkflowError extends Error {
-    inner: Error | null;
-    constructor(message: string, inner?: Error | null);
-}
-
-interface AXPWorkflow {
-    steps: {
-        [stepName: string]: AXPWorkflowStep;
-    };
-    startStepId: string;
-}
-declare class AXPWorkflowContext {
-    constructor(initialData?: any);
-    private variables;
-    private stepOutputs;
-    setVariable(key: string, value: any): void;
-    setVariables(context?: any): void;
-    getVariable<T = any>(key?: string | null): T;
-    setOutput(key: string, output: any): void;
-    setOutputs(values: Map<string, any>): void;
-    getOutput<T = any>(key: string): T;
-}
-type AXPWorkflowActionInput = any;
-type AXPWorkflowConditionType = 'AND' | 'OR' | 'SINGLE';
-interface AXPWorkflowCondition {
-    type: AXPWorkflowConditionType;
-    conditions?: AXPWorkflowCondition[];
-    expression?: string;
-}
-interface AXPWorkflowNextStep {
-    conditions: AXPWorkflowCondition[];
-    nextStepId: string;
-}
-interface AXPWorkflowStep {
-    id?: string;
-    action: AXPWorkflowAction | string;
-    input?: AXPWorkflowActionInput;
-    nextSteps?: AXPWorkflowNextStep[];
-    conditions?: AXPWorkflowCondition[];
-}
-declare abstract class AXPWorkflowAction {
-    private eventService;
-    protected dispatch(event: AXPWorkflowEvent): void;
-    abstract execute(context: AXPWorkflowContext): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowAction, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowAction>;
-}
-declare abstract class AXPWorkflowFunction {
-    abstract execute(...args: any[]): Promise<any> | any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowFunction, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowFunction>;
-}
-interface AXPWorkflowEvent<T = any> {
-    type: string;
-    payload?: T;
-}
-declare function createWorkFlowEvent<T>(type: string): {
-    (payload: T): {
-        type: string;
-        payload: T;
-    };
-    type: string;
-};
-declare function ofType<T extends {
-    type: string;
-}>(...allowedTypes: Array<{
-    type: string;
-}>): rxjs.MonoTypeOperatorFunction<T>;
-
-declare class AXPWorkflowEventService {
-    private eventSubject;
-    dispatch(event: AXPWorkflowEvent): void;
-    get events$(): Observable<AXPWorkflowEvent>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowEventService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowEventService>;
-}
-
-declare class AXPWorkflowRegistryService {
-    private functionsMap;
-    private actionsMap;
-    private workflowsMap;
-    registerWorkflow(name: string, workflow: AXPWorkflow): void;
-    getWorkflow(name: string): AXPWorkflow | undefined;
-    registerAction(name: string, action: Type<AXPWorkflowAction>): void;
-    getAction(name: string): Type<AXPWorkflowAction> | undefined;
-    registerFunction(name: string, func: Type<AXPWorkflowFunction>): void;
-    getFunction(name: string): Type<AXPWorkflowFunction> | undefined;
-    getFunctionNames(): string[];
-    getStep(workflowName: string, stepName: string): AXPWorkflowStep | undefined;
-    updateStepInWorkflow(workflowName: string, stepName: string, step: AXPWorkflowStep): void;
-    addStepToWorkflow(workflowName: string, stepName: string, step: AXPWorkflowStep): void;
-    addAfterStep(workflowId: string, stepId: string, newStepId: string, newStepAction: string, conditionExpression: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowRegistryService>;
-}
-
-interface AXPWorkflowModuleConfigs {
-    functions?: {
-        [name: string]: Type<AXPWorkflowFunction>;
-    };
-    actions?: {
-        [name: string]: Type<AXPWorkflowAction>;
-    };
-    workflows?: {
-        [name: string]: AXPWorkflow;
-    };
-}
-declare class AXPWorkflowModule {
-    static forRoot(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
-    static forChild(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
-    /**
-     * @ignore
-     */
-    constructor(instances: any[]);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowModule, [{ optional: true; }]>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPWorkflowModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXPWorkflowModule>;
-}
-
-declare class AXPWorkflowService {
-    private registryService;
-    private injector;
-    private eventService;
-    get events$(): Observable<AXPWorkflowEvent>;
-    constructor(registryService: AXPWorkflowRegistryService, injector: Injector);
-    exists(name: string): boolean;
-    execute(workflow: AXPWorkflow | string, initialContext?: AXPWorkflowContext | any | null): Promise<AXPWorkflowContext>;
-    private processData;
-    private getActionInstance;
-    private getWorkflowInstance;
-    private determineNextStep;
-    private evaluateCondition;
-    private evaluateSingleCondition;
-    private evaluateExpression;
-    private processInputs;
-    private createFunctionScope;
-    private getFunctionInstance;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowService>;
-}
-
-/**
- * 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;
-    /**
-     * Unique workflow name (same across all versions).
-     * This is the primary identifier (replaces definitionId).
-     */
-    name: string;
-    /**
-     * Tenant ID (nullable).
-     */
-    tenantId?: 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$1 {
-    /**
-     * Activity ID.
-     */
-    id: string;
-    /**
-     * Node ID (for visual designer).
-     */
-    nodeId: string;
-    /**
-     * Activity name.
-     */
-    name?: string | null;
-    /**
-     * Activity type (e.g., "workflow-activity:write-line", "workflow-activity: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 AXPActivity's executionMode.
-     * This allows per-instance override of the default execution mode.
-     *
-     * @example
-     * ```json
-     * {
-     *   "id": "show-dialog",
-     *   "type": "workflow-activity:show-dialog",
-     *   "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).
- * This is the root activity that contains all other activities.
- */
-interface AXPFlowchart extends AXPActivity$1 {
-    /**
-     * Type must be "workflow-activity:flowchart".
-     */
-    type: "workflow-activity:flowchart";
-    /**
-     * Activities in this flowchart.
-     */
-    activities: AXPActivity$1[];
-    /**
-     * Variables in this flowchart.
-     */
-    variables?: AXPVariableModel[];
-    /**
-     * Connections between activities.
-     */
-    connections: AXPConnection[];
-}
-/**
- * Simplified workflow definition for JSON files.
- * This is what developers write - system fields are added automatically.
- */
-interface AXPWorkflowDefinitionJson {
-    /**
-     * Unique workflow name (used as key/identifier).
-     * This is the only required field for identification.
-     * Similar to entity system where 'name' is the unique key.
-     */
-    name: string;
-    /**
-     * Display title (human-readable name shown in UI).
-     * Similar to entity system where 'title' is the display name.
-     */
-    title?: string | null;
-    /**
-     * Description.
-     */
-    description?: string | null;
-    /**
-     * Workflow variables.
-     */
-    variables?: AXPVariableDefinition[];
-    /**
-     * Workflow inputs.
-     */
-    inputs?: AXPWorkflowInputDefinition[];
-    /**
-     * Workflow outputs.
-     */
-    outputs?: AXPWorkflowOutputDefinition[];
-    /**
-     * Workflow outcomes.
-     */
-    outcomes?: string[];
-    /**
-     * Custom properties.
-     */
-    customProperties?: AXPCustomProperties;
-    /**
-     * Workflow options.
-     */
-    options?: AXPWorkflowOptions;
-    /**
-     * Root activity (Flowchart).
-     */
-    root: AXPFlowchart;
-}
-/**
- * Complete workflow definition (v3.0.0 format).
- * This is the core workflow definition without system fields.
- * System fields ($schema, tenantId, createdAt, toolVersion, isPublished, id, version, isLatest, isReadonly, isSystem)
- * are managed by the entity system and stored in entity model.
- */
-interface AXPWorkflowDefinition {
-    /**
-     * Unique workflow name (used as key/identifier, same across all versions).
-     * This is the primary identifier for the workflow.
-     */
-    name: string;
-    /**
-     * Display title (human-readable name shown in UI).
-     */
-    title?: string | null;
-    /**
-     * Description.
-     */
-    description?: string | null;
-    /**
-     * Workflow variables.
-     */
-    variables?: AXPVariableDefinition[];
-    /**
-     * Workflow inputs.
-     */
-    inputs?: AXPWorkflowInputDefinition[];
-    /**
-     * Workflow outputs.
-     */
-    outputs?: AXPWorkflowOutputDefinition[];
-    /**
-     * Workflow outcomes.
-     */
-    outcomes?: string[];
-    /**
-     * Custom properties.
-     */
-    customProperties?: AXPCustomProperties;
-    /**
-     * 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 definition loader interface.
- * Implement this to provide workflow definitions from various sources (JSON files, database, etc.).
- */
-interface AXPWorkflowDefinitionLoader {
-    /**
-     * Get workflow definition by name (unique key).
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
-    /**
-     * Get all available workflow names.
-     * Used for preloading and discovery.
-     * @returns Array of workflow names
-     */
-    getAllNames?(): Promise<string[]>;
-}
-/**
- * Workflow definition preloader interface.
- * Implement this to provide a list of workflow definitions that should be preloaded.
- */
-interface AXPWorkflowDefinitionPreloader {
-    /**
-     * Get list of workflow definition IDs to preload.
-     * @returns Array of definition IDs
-     */
-    preload(): string[];
-}
-/**
- * Injection token for workflow definition loaders.
- * Multiple loaders can be provided (multi: true).
- */
-declare const AXP_WORKFLOW_DEFINITION_LOADER: InjectionToken<AXPWorkflowDefinitionLoader>;
-/**
- * Resolver service for workflow definitions.
- * Aggregates all registered loaders and resolves workflow definitions.
- */
-declare class AXPWorkflowDefinitionResolver {
-    private loaders;
-    /**
-     * Get workflow definition by name (unique key).
-     * Tries all registered loaders until one returns a definition.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
-    /**
-     * Get all available workflow names from all loaders.
-     * @returns Array of unique workflow names
-     */
-    getAllNames(): Promise<string[]>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowDefinitionResolver, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionResolver>;
-}
-
-/**
- * Registry service for workflow definitions.
- * Caches loaded definitions and provides change notifications.
- */
-declare class AXPWorkflowDefinitionRegistryService {
-    private resolver;
-    private cache;
-    private onChanged;
-    /**
-     * Observable for workflow definition changes.
-     */
-    get onChanged$(): rxjs.Observable<{
-        name: string;
-        action: "registered" | "updated" | "removed";
-    }>;
-    /**
-     * Get workflow definition by name (unique key).
-     * Uses cache if available, otherwise loads from resolver.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
-    /**
-     * Register a workflow definition in the cache.
-     * @param definition - The workflow definition to register
-     */
-    register(definition: AXPWorkflowDefinition): void;
-    /**
-     * Update a workflow definition in the cache.
-     * @param definition - The updated workflow definition
-     */
-    update(definition: AXPWorkflowDefinition): void;
-    /**
-     * Remove a workflow definition from the cache.
-     * @param name - The workflow name to remove
-     */
-    remove(name: string): void;
-    /**
-     * Clear all cached workflow definitions.
-     */
-    clear(): void;
-    /**
-     * Check if a workflow definition is cached.
-     * @param definitionId - The workflow definition ID
-     * @returns True if cached, false otherwise
-     */
-    has(definitionId: string): boolean;
-    /**
-     * Get all cached workflow definition IDs.
-     * @returns Array of definition IDs (only those that have been loaded)
-     */
-    getAllIds(): string[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowDefinitionRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionRegistryService>;
-}
-
-/**
- * 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;
-}
-
-/**
- * Activity Category - Extends AXPCategoryEntity for consistency and performance
- *
- * Inherited properties from AXPCategoryEntity:
- * - id: string                   - Unique identifier
- * - title: string                - Display name
- * - description?: string         - Category description
- * - parentId?: string            - Parent category ID
- * - childrenCount: number        - Direct child categories count (enables lazy loading)
- * - itemsCount?: number          - Direct activities count
- * - totalChildren?: number       - Total nested categories (optional, for analytics)
- * - totalItems?: number          - Total activities in tree (optional, for analytics)
- */
-interface AXPActivityCategory extends AXPCategoryEntity {
-}
-interface ActivityPropertyWidget {
-    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
-    options?: Record<string, any>;
-}
-/**
- * Activity Definition - Metadata for UI and tooling.
- * Contains all metadata needed for displaying activities in toolbox and designer.
- * The `name` property is used as the command key for execution.
- */
-interface AXPActivityDefinition {
-    /**
-     * Activity name - used as command key for execution.
-     * This is the unique identifier for the activity.
-     */
-    name: string;
-    /**
-     * Activity type (e.g., "workflow-activity:check-permission").
-     */
-    type: string;
-    /**
-     * Display name for UI.
-     */
-    title?: 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;
-}
-/**
- * Activity - Command with specific TResult structure.
- * Extends AXPCommand with a fixed TResult that includes output and outcomes.
- * No additional properties beyond AXPCommand - pure command interface.
- */
-interface AXPActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
-    output: TOutput;
-    outcomes: Record<string, any>;
-}> {
-    /**
-     * Execute the activity as a command.
-     * @param input - Activity input data
-     * @returns Promise with output and outcomes
-     */
-    execute(input: TInput): AXPExecuteCommandResultPromise<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>;
-}
-/**
- * Input property descriptor.
- * Similar to AXPEntityProperty structure.
- */
-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;
-    };
-}
-
-type AXPActivityProviderToken = AXPActivityProvider | Promise<AXPActivityProvider>;
-declare const AXP_ACTIVITY_PROVIDER: InjectionToken<AXPActivityProviderToken[]>;
-interface AXPActivityProvider {
-    /**
-     * Get list of activity definitions for a category.
-     * @param categoryId - Category ID to filter activities
-     * @returns Promise of activity definitions array
-     */
-    getList(categoryId: string): Promise<AXPActivityDefinition[]>;
-    /**
-     * Get activity definition by name (unique identifier).
-     * The name is used as the command key for execution.
-     * @param name - Activity name (unique identifier and command key)
-     * @returns Promise of activity definition or undefined if not found
-     */
-    getById(name: string): Promise<AXPActivityDefinition | undefined>;
-}
-type AXPActivityCategoryProviderToken = AXPActivityCategoryProvider | Promise<AXPActivityCategoryProvider>;
-declare const AXP_ACTIVITY_CATEGORY_PROVIDER: InjectionToken<AXPActivityCategoryProviderToken[]>;
-interface AXPActivityCategoryProvider {
-    getList(parentId?: string): Promise<AXPActivityCategory[]>;
-    getById(id: string): Promise<AXPActivityCategory | undefined>;
-}
-
-/**
- * Optimized Activity Definition Service
- *
- * Manages activity definitions (metadata) for UI and tooling.
- * Similar to AXPReportDefinitionService - only handles metadata, not execution.
- *
- * Performance optimizations:
- * 1. Uses childrenCount to determine if category has children (no query needed)
- * 2. Uses itemsCount to determine if category has activities (no query needed)
- * 3. Aggressive caching prevents duplicate API calls
- * 4. Single pending request per resource prevents race conditions
- * 5. Lazy loading - only loads data when needed
- */
-declare class AXPActivityDefinitionService {
-    private readonly categoryProviders;
-    private readonly activityProviders;
-    /** Cache for categories by id - O(1) lookup */
-    private categoriesById;
-    /** Cache for categories by parentId - O(1) lookup */
-    private categoriesByParentId;
-    /** Cache for activity definitions by categoryId - O(1) lookup */
-    private activitiesByCategory;
-    /** Cache for individual activity definitions by name - O(1) lookup */
-    private activitiesByName;
-    /** Track which provider index owns each category (by category ID) */
-    private categoryOwnership;
-    /** Pending API requests to prevent duplicate calls */
-    private pendingCategoriesRequests;
-    private pendingActivitiesRequests;
-    private pendingActivityRequests;
-    /**
-     * Get categories by parentId with aggressive caching
-     *
-     * Optimization: Returns cached result immediately if available,
-     * preventing unnecessary API calls during navigation
-     *
-     * @param parentId - Parent category ID (undefined = root categories)
-     * @returns Array of categories with count metadata (childrenCount, itemsCount)
-     */
-    getCategories(parentId?: string): Promise<AXPActivityCategory[]>;
-    /**
-     * Get single category by ID with O(1) lookup
-     *
-     * Optimization: Uses Map for instant retrieval, falls back to
-     * searching cache, then providers if not found
-     */
-    getCategoryById(categoryId: string): Promise<AXPActivityCategory | undefined>;
-    /**
-     * Get category path from root to specified category
-     *
-     * Optimization: Builds path using cached categories only
-     */
-    getCategoriesPathById(categoryId: string): Promise<AXPActivityCategory[]>;
-    /**
-     * Get activity definitions for a category with smart caching
-     *
-     * Optimization: Checks itemsCount before querying
-     * - If itemsCount = 0, returns empty array (no API call)
-     * - If itemsCount > 0, loads and caches activity definitions
-     * - Returns cached result on subsequent calls
-     *
-     * @param categoryId - Category ID to get activity definitions from
-     * @returns Array of activity definitions
-     */
-    getActivitiesByCategoryId(categoryId: string): Promise<AXPActivityDefinition[]>;
-    /**
-     * Get single activity definition by name with O(1) lookup
-     *
-     * Optimization: Uses Map for instant retrieval
-     *
-     * @param name - Activity name (unique identifier and command key)
-     * @returns Activity definition or undefined if not found
-     */
-    getActivityByName(name: string): Promise<AXPActivityDefinition | undefined>;
-    /**
-     * Get category ID containing a specific activity definition
-     *
-     * Optimization: Searches cache first, loads on-demand if needed
-     */
-    getCategoryIdByActivityName(activityName: string): Promise<string | undefined>;
-    /**
-     * Get category path for an activity
-     */
-    getCategoriesPathByActivityName(activityName: string): Promise<AXPActivityCategory[]>;
-    /**
-     * Load categories from providers and cache results
-     *
-     * Optimization: Tracks provider ownership to avoid unnecessary API calls
-     * - For root (parentId = undefined): Query ALL providers
-     * - For children: Only query the provider that owns the parent
-     */
-    private loadCategoriesFromProviders;
-    /**
-     * Get the provider index that owns a specific category
-     *
-     * @returns Array with provider index, or null if ownership unknown (query all)
-     */
-    private getProviderIndexForCategory;
-    /**
-     * Load activity definitions from providers and cache results
-     *
-     * Optimization: Only queries the provider that owns the category
-     * Uses provider INDEX to match category provider with activity provider
-     */
-    private loadActivitiesFromProviders;
-    /**
-     * Load single activity definition from providers and cache result
-     */
-    private loadActivityFromProviders;
-    /**
-     * Breadth-first search through category hierarchy
-     */
-    private searchCategoryInHierarchy;
-    /**
-     * Check if category has children (uses cached count)
-     */
-    categoryHasChildren(categoryId: string): boolean;
-    /**
-     * Check if category has activities (uses cached count)
-     */
-    categoryHasActivities(categoryId: string): boolean;
-    /**
-     * Clear all caches
-     */
-    clearAllCache(): void;
-    /**
-     * Clear categories cache only
-     */
-    clearCategoriesCache(): void;
-    /**
-     * Clear activities cache only
-     */
-    clearActivitiesCache(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityDefinitionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityDefinitionService>;
-}
-
-/**
- * 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
- *
- */
-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>;
-}
-
-export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, WorkflowCoordinator, createWorkFlowEvent, ofType };
-export type { AXPActivity, AXPActivityCategory, AXPActivityCategoryProvider, AXPActivityCategoryProviderToken, AXPActivityDefinition, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderToken, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPCustomProperties, AXPEndpoint, AXPExceptionState, AXPExpression, AXPFlowchart, AXPGetWorkflowDefinitionRequest, AXPGetWorkflowDefinitionResponse, AXPGetWorkflowExecutionStateRequest, AXPInputValue, AXPMetadata, AXPOutputValue, AXPPosition, AXPResumeWorkflowExecutionRequest, AXPResumeWorkflowExecutionResponse, AXPStartWorkflowExecutionRequest, AXPStartWorkflowExecutionResponse, AXPStoredWorkflowDefinition, AXPVariableDefinition, AXPVariableModel, AXPVersionedEntity, AXPWorkflow, AXPWorkflowActionInput, AXPActivity$1 as AXPWorkflowActivity, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionPreloader, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityPropertyWidget, InputDescriptor, OutputDescriptor, WorkflowExecutionResult };