@acorex/platform 21.0.0-next.1 → 21.0.0-next.10

package/workflow/index.d.ts

@@ -2,12 +2,9 @@ import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
 import { Type, ModuleWithProviders, Injector, InjectionToken } from '@angular/core';
-import { AXPCommand } from '@acorex/platform/runtime';
-import * as _acorex_platform_core from '@acorex/platform/core';
-import { AXPExecuteCommandResult, AXPValidationRules, AXPActionMenuItem } from '@acorex/platform/core';
-import { AXPWidgetTypesMap, AXPWidgetNode } from '@acorex/platform/layout/widget-core';
-import { AXStyleColorType } from '@acorex/cdk/common';
-import { AXPopupSizeType } from '@acorex/components/popup';
+import { AXPValidationRules, AXPEntityOp, AXPCategoryEntity, AXPExpressionEvaluatorScope } from '@acorex/platform/core';
+import { AXPWidgetTypesMap } from '@acorex/platform/layout/widget-core';
+import { AXPCommand, AXPExecuteCommandResultPromise } from '@acorex/platform/runtime';
 
 declare class AXPWorkflowError extends Error {
     inner: Error | null;
@@ -117,7 +114,6 @@ interface AXPWorkflowModuleConfigs {
     };
 }
 declare class AXPWorkflowModule {
-    private _commandSetup;
     static forRoot(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
     static forChild(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
     /**
@@ -151,2293 +147,1588 @@ declare class AXPWorkflowService {
     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 {
+interface AXPWorkflowDefinition {
+    schemaVersion: "acorex-platform-workflow/v1";
+    name: string;
+    title?: string | null;
+    description?: string | null;
+    variables?: AXPVariableDefinition[];
+    inputs?: AXPWorkflowInputDescriptor[];
+    outputs?: AXPWorkflowOutputDescriptor[];
+    graph: AXPWorkflowGraph;
+    customProperties?: Record<string, any>;
+    /** engine specific (Elsa, ...) */
+    extensions?: AXPWorkflowExtensions;
     /**
-     * Unique ID of this workflow definition version.
+     * Workflow bindings configuration.
+     * Defines which entities and events should trigger this workflow.
      */
+    bindings?: AXPWorkflowBinding[];
+}
+interface AXPWorkflowGraph {
+    startActivityId: string;
+    activities: AXPWorkflowActivityInstance[];
+    connections: AXPConnection[];
+    /** purely designer */
+    designer?: {
+        nodes?: Record<string, {
+            x: number;
+            y: number;
+            nodeId?: string;
+        }>;
+        edges?: Array<{
+            from: string;
+            to: string;
+            vertices?: Array<{
+                x: number;
+                y: number;
+            }>;
+        }>;
+    };
+}
+interface AXPWorkflowActivityInstance {
     id: string;
+    nodeId?: string;
     /**
-     * Unique workflow name (same across all versions).
-     * This is the primary identifier (replaces definitionId).
+     * Activity name - references AXPActivityDefinition.name
+     * Used to lookup activity definition for metadata (executionMode, title, etc.)
      */
     name: string;
     /**
-     * Tenant ID (nullable).
+     * Input values for this activity instance.
+     * Key-value pairs where keys match input descriptor names from AXPActivityDefinition.inputs
+     * Example: { "message": "Hello", "duration": 5000 }
      */
-    tenantId?: string | null;
+    inputs?: Record<string, any>;
+    metadata?: Record<string, any>;
+    customProperties?: Record<string, any>;
+    /** engine-specific override */
+    extensions?: Record<string, any>;
+}
+interface AXPConnection {
+    source: {
+        activtyName: string;
+        port?: string | null;
+    };
+    target: {
+        activtyName: string;
+        port?: string | null;
+    };
+    vertices?: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+interface AXPVariableDefinition {
+    name: string;
+    type: string;
+    isArray?: boolean;
+    value?: any;
+    storageDriverType?: string | null;
+}
+interface AXPWorkflowPropertyWidget {
+    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
+    options?: Record<string, any>;
+}
+interface AXPWorkflowInputDescriptor {
+    name: string;
+    title: string;
+    description?: string;
+    schema: {
+        dataType: string;
+        isArray?: boolean;
+        nullable?: boolean;
+        readonly?: boolean;
+        hidden?: boolean | string;
+        defaultValue?: any | string | ((context: any | null) => any);
+        interface: AXPWorkflowPropertyWidget;
+    };
+    validations?: AXPValidationRules;
+}
+interface AXPWorkflowOutputDescriptor {
+    name: string;
+    title: string;
+    description?: string;
     /**
-     * Description of what the workflow does.
-     */
-    description?: string | null;
+    * Optional: where this output comes from in your context/memory.
+    * Example: "$.result.orderId" or "vars.orderId"
+    */
+    path?: string;
+    metadata?: Record<string, any>;
+    schema: {
+        isArray?: boolean;
+        dataType: string;
+    };
+}
+/**
+ * Engine-specific extension bag for a workflow.
+ * Keep ALL engine-only fields here (Elsa, StepFunctions adapter, etc).
+ */
+interface AXPWorkflowExtensions {
     /**
-     * Creation timestamp (ISO date-time).
+     * Elsa-specific extensions (optional).
      */
-    createdAt: string;
+    elsa?: AXPElsaWorkflowExtensions;
     /**
-     * Version of the tool that produced this definition (e.g. "3.2.0.0").
+     * Other engines (future-proof).
+     * Example: stepFunctions, logicApps, temporal, ...
      */
-    toolVersion?: string | null;
+    [engine: string]: any;
+}
+/**
+ * Elsa-only fields (Optional).
+ * Put strategy/tool/schema/raw payload here to keep Core model global.
+ */
+interface AXPElsaWorkflowExtensions {
     /**
-     * Materializer name for deserialization.
+     * Elsa schema URL (if you want to round-trip exact docs).
+     * Example: "https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json"
      */
+    schema?: string;
+    toolVersion?: string;
     materializerName?: string;
     /**
-     * JSON data (for simple workflows).
+     * Elsa strategy/options (engine-level concerns).
      */
-    stringData?: string;
+    options?: {
+        activationStrategyType?: string | null;
+        incidentStrategyType?: string | null;
+        commitStrategyName?: string | null;
+        autoUpdateConsumingWorkflows?: boolean;
+        usableAsActivity?: boolean | null;
+        activityCategory?: string | null;
+    };
     /**
-     * Binary data (for complex workflows).
+     * If you want lossless Elsa round-trip, keep the raw Elsa definition here.
      */
-    binaryData?: Uint8Array;
+    rawDefinition?: any;
 }
 /**
- * Variable definition.
- * Matches VariableDefinition from workflow definition schema.
+ * Workflow binding configuration.
+ * Defines which entities and events should trigger a workflow.
  */
-interface AXPVariableDefinition {
-    /**
-     * Variable ID.
-     */
-    id?: string;
+interface AXPWorkflowBinding {
     /**
-     * Variable name.
-     */
-    name: string;
-    /**
-     * Type name (e.g., "String", "Int32", "Boolean").
+     * Entity types this workflow applies to (e.g., ['ContentManagement.Promotion', 'ContentManagement.Article'])
+     * Empty array means applies to all entities with workflow plugin enabled.
      */
-    typeName: string;
+    entityTypes: string[];
     /**
-     * Whether this is an array type.
+     * Event types that trigger this workflow (e.g., ['create', 'update'])
+     * Uses AXPEntityOp directly (create, update, delete, etc.)
      */
-    isArray?: boolean;
+    eventTypes: AXPEntityOp[];
     /**
-     * Variable value (as string expression or literal).
+     * Whether this binding is enabled
      */
-    value?: string | null;
+    enabled: boolean;
     /**
-     * Storage driver type name (for custom storage).
+     * Optional conditions for when to trigger (future enhancement)
      */
-    storageDriverTypeName?: string | null;
+    conditions?: any;
 }
+
+/**
+ * Workflow status.
+ */
+type AXPWorkflowStatus = 'Running' | 'Finished';
+/**
+ * Workflow sub-status.
+ */
+type AXPWorkflowSubStatus = 'Pending' | 'Executing' | 'Suspended' | 'Finished' | 'Cancelled' | 'Faulted';
 /**
- * Workflow input definition.
- * Matches WorkflowInputDefinition from workflow definition schema.
+ * Activity status.
+ */
+type AXPActivityStatus = 'Running' | 'Completed' | 'Canceled' | 'Faulted';
+/**
+ * Exception state.
  */
-interface AXPWorkflowInputDefinition {
+interface AXPExceptionState {
     /**
-     * Input type (e.g., "String", "Int32", "Object").
+     * Exception type name.
      */
     type: string;
     /**
-     * Input name.
-     */
-    name: string;
-    /**
-     * Display name.
-     */
-    displayName?: string;
-    /**
-     * Description.
-     */
-    description?: string;
-    /**
-     * Category for grouping.
+     * Exception message.
      */
-    category?: string;
+    message: string;
     /**
-     * UI hint (widget type).
+     * Stack trace (nullable).
      */
-    uiHint?: string;
+    stackTrace?: string | null;
     /**
-     * Storage driver type (for custom storage).
+     * Inner exception (nullable).
      */
-    storageDriverType?: string | null;
+    innerException?: AXPExceptionState | null;
 }
 /**
- * Workflow output definition.
- * Matches WorkflowOutputDefinition from workflow definition schema.
+ * Activity incident.
  */
-interface AXPWorkflowOutputDefinition {
-    /**
-     * Output type (e.g., "String", "Int32", "Object").
-     */
-    type: string;
+interface AXPActivityIncident {
     /**
-     * Output name.
+     * Activity ID that caused the incident.
      */
-    name: string;
+    activityId: string;
     /**
-     * Display name.
+     * Activity node ID.
      */
-    displayName?: string;
+    activityNodeId: string;
     /**
-     * Description.
+     * Activity type.
      */
-    description?: string;
+    activityType: string;
     /**
-     * Category for grouping.
+     * Incident message.
      */
-    category?: string;
-}
-/**
- * Expression.
- * Used for dynamic values in activities.
- */
-interface AXPExpression {
+    message: string;
     /**
-     * Expression type (e.g., "Literal", "JavaScript", "Liquid").
+     * Exception (nullable).
      */
-    type: string;
+    exception?: AXPExceptionState | null;
     /**
-     * Expression value.
+     * Timestamp (ISO date-time).
      */
-    value?: any;
+    timestamp: string;
 }
 /**
- * Input value wrapper.
- * Wraps an expression with type information.
+ * Workflow fault state.
  */
-interface AXPInputValue {
+interface AXPWorkflowFaultState {
     /**
-     * Type name.
+     * Exception (nullable).
      */
-    typeName: string;
+    exception?: AXPExceptionState | null;
+    /**
+     * Fault message.
+     */
+    message: string;
     /**
-     * Expression (or null).
+     * Faulted activity ID (nullable).
      */
-    expression?: AXPExpression | null;
+    faultedActivityId?: string | null;
 }
 /**
- * Output value wrapper.
- * References memory location.
+ * Bookmark.
  */
-interface AXPOutputValue {
+interface AXPBookmark {
     /**
-     * Type name.
+     * Bookmark ID.
      */
-    typeName: string;
+    id: string;
     /**
-     * Memory reference (or null).
+     * Bookmark name.
      */
-    memoryReference?: {
-        id: string;
-    } | null;
-}
-/**
- * Position (for visual layout).
- */
-interface AXPPosition {
-    x: number;
-    y: number;
-}
-/**
- * Endpoint (connection point).
- */
-interface AXPEndpoint {
+    name: string;
     /**
-     * Activity ID.
+     * Bookmark hash.
      */
-    activity: string;
+    hash: string;
     /**
-     * Port name (nullable).
+     * Bookmark payload (nullable).
      */
-    port?: string | null;
-}
-/**
- * Connection between activities.
- */
-interface AXPConnection {
+    payload?: any | null;
     /**
-     * Source endpoint.
+     * Activity node ID.
      */
-    source: AXPEndpoint;
+    activityNodeId: string;
     /**
-     * Target endpoint.
+     * Activity instance ID.
      */
-    target: AXPEndpoint;
+    activityInstanceId: string;
     /**
-     * Connection vertices (for curved paths).
+     * Auto burn flag.
      */
-    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 {
+    autoBurn?: boolean;
     /**
-     * Connections that reference non-existent activities.
+     * Callback method name (nullable).
      */
-    notFoundConnections?: AXPConnection[];
+    callbackMethodName?: string | null;
     /**
-     * Additional custom properties.
+     * Metadata (nullable).
      */
-    [key: string]: any;
+    metadata?: Record<string, string> | null;
 }
 /**
- * Base activity (workflow definition format).
- * Matches Activity from workflow definition schema.
- * Note: This is the workflow definition format, not the frontend Activity class.
+ * Completion callback state.
  */
-interface AXPActivity {
+interface AXPCompletionCallbackState {
     /**
-     * Activity ID.
+     * Owner activity instance ID.
      */
-    id: string;
+    ownerInstanceId: string;
     /**
-     * Node ID (for visual designer).
+     * Child activity node ID.
      */
-    nodeId: string;
+    childNodeId: string;
     /**
-     * Activity name.
+     * Method name (nullable).
      */
-    name?: string | null;
+    methodName?: string | null;
+}
+/**
+ * Variable (for activity context).
+ */
+interface AXPActivityVariable {
     /**
-     * Activity type (e.g., "workflow-activity:write-line", "workflow-activity:if").
+     * Variable ID.
      */
-    type: string;
+    id: string;
     /**
-     * Activity version.
+     * Variable name.
      */
-    version: number;
+    name: string;
     /**
-     * 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": "workflow-activity:show-dialog",
-     *   "executionMode": "frontend"
-     * }
-     * ```
+     * Type name.
      */
-    executionMode?: 'frontend' | 'backend' | 'both';
+    typeName: string;
     /**
-     * Custom properties.
+     * Is array flag.
      */
-    customProperties?: AXPCustomProperties;
+    isArray?: boolean;
     /**
-     * Metadata (designer annotations).
+     * Variable value (nullable).
      */
-    metadata?: AXPMetadata;
+    value?: any | null;
     /**
-     * Additional type-specific properties.
+     * Storage driver type name (nullable).
      */
-    [key: string]: any;
+    storageDriverTypeName?: string | null;
 }
 /**
- * Flowchart activity (workflow definition format).
- * This is the root activity that contains all other activities.
+ * Activity execution context state.
  */
-interface AXPFlowchart extends AXPActivity {
+interface AXPActivityExecutionContextState {
     /**
-     * Type must be "workflow-activity:flowchart".
+     * Context ID (activity instance ID).
      */
-    type: "workflow-activity:flowchart";
+    id: string;
     /**
-     * Activities in this flowchart.
+     * Parent context ID (nullable).
      */
-    activities: AXPActivity[];
+    parentContextId?: string | null;
     /**
-     * Variables in this flowchart.
+     * Scheduled activity node ID.
      */
-    variables?: AXPVariableModel[];
+    scheduledActivityNodeId: string;
     /**
-     * Connections between activities.
+     * Owner activity node ID (nullable).
      */
-    connections: AXPConnection[];
-}
-/**
- * Simplified workflow definition for JSON files.
- * This is what developers write - system fields are added automatically.
- */
-interface AXPWorkflowDefinitionJson {
+    ownerActivityNodeId?: string | null;
     /**
-     * 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.
+     * Properties bag.
      */
-    name: string;
+    properties: Record<string, any>;
     /**
-     * Display title (human-readable name shown in UI).
-     * Similar to entity system where 'title' is the display name.
+     * Activity state (evaluated properties) (nullable).
      */
-    title?: string | null;
+    activityState?: Record<string, any> | null;
     /**
-     * Description.
+     * Dynamic variables.
      */
-    description?: string | null;
+    dynamicVariables: AXPActivityVariable[];
     /**
-     * Workflow variables.
+     * Activity status.
      */
-    variables?: AXPVariableDefinition[];
+    status: AXPActivityStatus;
     /**
-     * Workflow inputs.
+     * Is executing flag.
      */
-    inputs?: AXPWorkflowInputDefinition[];
+    isExecuting: boolean;
     /**
-     * Workflow outputs.
+     * Fault count.
      */
-    outputs?: AXPWorkflowOutputDefinition[];
+    faultCount: number;
     /**
-     * Workflow outcomes.
+     * Started at timestamp (ISO date-time).
      */
-    outcomes?: string[];
+    startedAt: string;
     /**
-     * Custom properties.
+     * Completed at timestamp (ISO date-time, nullable).
      */
-    customProperties?: AXPCustomProperties;
+    completedAt?: string | null;
     /**
-     * Workflow options.
-     */
-    options?: AXPWorkflowOptions;
-    /**
-     * Root activity (Flowchart).
+     * Tag (nullable).
      */
-    root: AXPFlowchart;
+    tag?: any | null;
 }
 /**
- * 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.
+ * Workflow state (internal execution state).
  */
-interface AXPWorkflowDefinition {
+interface AXPWorkflowState {
     /**
-     * Unique workflow name (used as key/identifier, same across all versions).
-     * This is the primary identifier for the workflow.
+     * State ID.
      */
-    name: string;
+    id: string;
     /**
-     * Display title (human-readable name shown in UI).
+     * Workflow definition ID.
      */
-    title?: string | null;
+    definitionId: string;
     /**
-     * Description.
+     * Workflow definition version.
      */
-    description?: string | null;
+    definitionVersion: number;
     /**
-     * Workflow variables.
+     * Correlation ID (nullable).
      */
-    variables?: AXPVariableDefinition[];
+    correlationId?: string | null;
     /**
-     * Workflow inputs.
+     * Workflow status.
      */
-    inputs?: AXPWorkflowInputDefinition[];
+    status: AXPWorkflowStatus;
     /**
-     * Workflow outputs.
+     * Workflow sub-status.
      */
-    outputs?: AXPWorkflowOutputDefinition[];
+    subStatus: AXPWorkflowSubStatus;
     /**
-     * Workflow outcomes.
+     * Bookmarks.
      */
-    outcomes?: string[];
+    bookmarks: AXPBookmark[];
     /**
-     * Custom properties.
+     * Incidents.
      */
-    customProperties?: AXPCustomProperties;
+    incidents: AXPActivityIncident[];
     /**
-     * Workflow options.
+     * Fault (nullable).
      */
-    options?: AXPWorkflowOptions;
+    fault?: AXPWorkflowFaultState | null;
     /**
-     * @deprecated Use options.usableAsActivity instead.
+     * Completion callbacks.
      */
-    usableAsActivity?: boolean | null;
+    completionCallbacks: AXPCompletionCallbackState[];
     /**
-     * Root activity (Flowchart).
+     * Activity execution contexts.
      */
-    root: AXPFlowchart;
-}
-/**
- * Workflow configuration options.
- */
-interface AXPWorkflowOptions {
+    activityExecutionContexts: AXPActivityExecutionContextState[];
     /**
-     * Activation strategy type.
+     * Input data.
      */
-    activationStrategyType?: string | null;
+    input: Record<string, any>;
     /**
-     * Whether workflow can be used as an activity.
+     * Output data.
      */
-    usableAsActivity?: boolean | null;
+    output: Record<string, any>;
     /**
-     * Auto-update consuming workflows.
+     * Properties bag.
      */
-    autoUpdateConsumingWorkflows?: boolean;
+    properties: Record<string, any>;
     /**
-     * Activity category (if usable as activity).
+     * Created at timestamp (ISO date-time).
      */
-    activityCategory?: string | null;
+    createdAt: string;
     /**
-     * Incident strategy type.
+     * Updated at timestamp (ISO date-time).
      */
-    incidentStrategyType?: string | null;
+    updatedAt: string;
     /**
-     * Commit strategy name.
+     * Finished at timestamp (ISO date-time, nullable).
      */
-    commitStrategyName?: string | null;
+    finishedAt?: string | null;
 }
-
 /**
- * Workflow definition loader interface.
- * Implement this to provide workflow definitions from various sources (JSON files, database, etc.).
+ * Workflow instance (stored in database).
+ * This matches the Elsa Workflow Instance schema for backend compatibility.
  */
-interface AXPWorkflowDefinitionLoader {
+interface AXPWorkflowInstance {
     /**
-     * Get workflow definition by name (unique key).
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
+     * Schema reference.
      */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
+    $schema?: string;
     /**
-     * Get all available workflow names.
-     * Used for preloading and discovery.
-     * @returns Array of workflow names
+     * Unique instance ID.
      */
-    getAllNames?(): Promise<string[]>;
-}
-/**
- * Workflow definition preloader interface.
- * Implement this to provide a list of workflow definitions that should be preloaded.
- */
-interface AXPWorkflowDefinitionPreloader {
+    id: string;
     /**
-     * Get list of workflow definition IDs to preload.
-     * @returns Array of definition IDs
+     * Workflow definition ID.
      */
-    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;
+    definitionId: string;
     /**
-     * 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
+     * Workflow definition version ID.
      */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
+    definitionVersionId: string;
     /**
-     * Get all available workflow names from all loaders.
-     * @returns Array of unique workflow names
+     * Workflow definition version number.
      */
-    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;
+    version: number;
     /**
-     * Observable for workflow definition changes.
+     * Parent workflow instance ID (nullable, for child workflows).
      */
-    get onChanged$(): rxjs.Observable<{
-        name: string;
-        action: "registered" | "updated" | "removed";
-    }>;
+    parentWorkflowInstanceId?: string | null;
+    /**
+     * Workflow state (internal execution state).
+     */
+    workflowState: AXPWorkflowState;
+    /**
+     * Workflow status.
+     */
+    status: AXPWorkflowStatus;
     /**
-     * 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
+     * Workflow sub-status.
      */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
+    subStatus: AXPWorkflowSubStatus;
     /**
-     * Register a workflow definition in the cache.
-     * @param definition - The workflow definition to register
+     * Correlation ID (nullable).
      */
-    register(definition: AXPWorkflowDefinition): void;
+    correlationId?: string | null;
     /**
-     * Update a workflow definition in the cache.
-     * @param definition - The updated workflow definition
+     * Instance name (nullable).
      */
-    update(definition: AXPWorkflowDefinition): void;
+    name?: string | null;
     /**
-     * Remove a workflow definition from the cache.
-     * @param name - The workflow name to remove
+     * Incident count.
      */
-    remove(name: string): void;
+    incidentCount: number;
     /**
-     * Clear all cached workflow definitions.
+     * Created at timestamp (ISO date-time).
      */
-    clear(): void;
+    createdAt: string;
     /**
-     * Check if a workflow definition is cached.
-     * @param definitionId - The workflow definition ID
-     * @returns True if cached, false otherwise
+     * Updated at timestamp (ISO date-time).
      */
-    has(definitionId: string): boolean;
+    updatedAt: string;
     /**
-     * Get all cached workflow definition IDs.
-     * @returns Array of definition IDs (only those that have been loaded)
+     * Finished at timestamp (ISO date-time, nullable).
      */
-    getAllIds(): string[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowDefinitionRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionRegistryService>;
+    finishedAt?: string | null;
 }
 
 /**
- * Workflow status.
- */
-type AXPWorkflowStatus = 'Running' | 'Finished';
-/**
- * Workflow sub-status.
- */
-type AXPWorkflowSubStatus = 'Pending' | 'Executing' | 'Suspended' | 'Finished' | 'Cancelled' | 'Faulted';
-/**
- * Activity status.
+ * 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)
  */
-type AXPActivityStatus = 'Running' | 'Completed' | 'Canceled' | 'Faulted';
+interface AXPActivityCategory extends AXPCategoryEntity {
+}
 /**
- * Exception state.
+ * 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 AXPExceptionState {
+interface AXPActivityDefinition {
     /**
-     * Exception type name.
+     * 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;
     /**
-     * Exception message.
+     * Display name for UI.
      */
-    message: string;
+    title?: string;
     /**
-     * Stack trace (nullable).
+     * Description of what the activity does.
      */
-    stackTrace?: string | null;
+    description?: string;
     /**
-     * Inner exception (nullable).
+     * Category for grouping in toolbox.
      */
-    innerException?: AXPExceptionState | null;
-}
-/**
- * Activity incident.
- */
-interface AXPActivityIncident {
+    category?: string;
     /**
-     * Activity ID that caused the incident.
+     * Icon name or class.
      */
-    activityId: string;
+    icon?: string;
     /**
-     * Activity node ID.
+     * 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'
      */
-    activityNodeId: string;
+    executionMode?: 'frontend' | 'backend' | 'both';
     /**
-     * Activity type.
+     * Input descriptors.
      */
-    activityType: string;
+    inputs?: AXPWorkflowInputDescriptor[];
     /**
-     * Incident message.
+     * Output descriptors.
      */
-    message: string;
+    outputs?: AXPWorkflowOutputDescriptor[];
     /**
-     * Exception (nullable).
+     * Static outcomes (exit points).
+     * Example: ['Done', 'Success', 'Failed']
      */
-    exception?: AXPExceptionState | null;
+    outcomes?: string[];
     /**
-     * Timestamp (ISO date-time).
+     * Whether this activity is browsable in the toolbox.
+     * Default: true
      */
-    timestamp: string;
+    isBrowsable?: boolean;
+    /**
+     * Whether this activity is a container (can have children).
+     * Default: false
+     */
+    isContainer?: boolean;
 }
 /**
- * Workflow fault state.
+ * 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 AXPWorkflowFaultState {
+interface AXPActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
+    output: TOutput;
+    outcomes: Record<string, any>;
+}> {
     /**
-     * Exception (nullable).
+     * Execute the activity as a command.
+     * @param input - Activity input data
+     * @returns Promise with output and outcomes
      */
-    exception?: AXPExceptionState | null;
+    execute(input: TInput): AXPExecuteCommandResultPromise<{
+        output: TOutput;
+        outcomes: Record<string, any>;
+    }>;
+}
+
+type AXPActivityProviderToken = AXPActivityProvider | Promise<AXPActivityProvider>;
+declare const AXP_ACTIVITY_PROVIDER: InjectionToken<AXPActivityProviderToken[]>;
+interface AXPActivityProvider {
     /**
-     * Fault message.
+     * Get list of activity definitions for a category.
+     * @param categoryId - Category ID to filter activities
+     * @returns Promise of activity definitions array
      */
-    message: string;
+    getList(categoryId: string): Promise<AXPActivityDefinition[]>;
     /**
-     * Faulted activity ID (nullable).
+     * 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
      */
-    faultedActivityId?: string | null;
+    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>;
 }
+
 /**
- * Bookmark.
- */
-interface AXPBookmark {
-    /**
-     * Bookmark ID.
+ * 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)
      */
-    id: string;
+    getCategories(parentId?: string): Promise<AXPActivityCategory[]>;
     /**
-     * Bookmark name.
+     * 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
      */
-    name: string;
+    getCategoryById(categoryId: string): Promise<AXPActivityCategory | undefined>;
     /**
-     * Bookmark hash.
+     * Get category path from root to specified category
+     *
+     * Optimization: Builds path using cached categories only
      */
-    hash: string;
+    getCategoriesPathById(categoryId: string): Promise<AXPActivityCategory[]>;
     /**
-     * Bookmark payload (nullable).
+     * 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
      */
-    payload?: any | null;
+    getActivitiesByCategoryId(categoryId: string): Promise<AXPActivityDefinition[]>;
     /**
-     * Activity node ID.
+     * 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
      */
-    activityNodeId: string;
+    getActivityByName(name: string): Promise<AXPActivityDefinition | undefined>;
     /**
-     * Activity instance ID.
+     * Get category ID containing a specific activity definition
+     *
+     * Optimization: Searches cache first, loads on-demand if needed
      */
-    activityInstanceId: string;
+    getCategoryIdByActivityName(activityName: string): Promise<string | undefined>;
     /**
-     * Auto burn flag.
+     * Get category path for an activity
      */
-    autoBurn?: boolean;
+    getCategoriesPathByActivityName(activityName: string): Promise<AXPActivityCategory[]>;
     /**
-     * Callback method name (nullable).
+     * 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
      */
-    callbackMethodName?: string | null;
+    private loadCategoriesFromProviders;
     /**
-     * Metadata (nullable).
+     * Get the provider index that owns a specific category
+     *
+     * @returns Array with provider index, or null if ownership unknown (query all)
      */
-    metadata?: Record<string, string> | null;
-}
-/**
- * Completion callback state.
- */
-interface AXPCompletionCallbackState {
+    private getProviderIndexForCategory;
     /**
-     * Owner activity instance ID.
+     * 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
      */
-    ownerInstanceId: string;
+    private loadActivitiesFromProviders;
     /**
-     * Child activity node ID.
+     * Load single activity definition from providers and cache result
      */
-    childNodeId: string;
+    private loadActivityFromProviders;
     /**
-     * Method name (nullable).
+     * Breadth-first search through category hierarchy
      */
-    methodName?: string | null;
-}
-/**
- * Variable (for activity context).
- */
-interface AXPActivityVariable {
+    private searchCategoryInHierarchy;
     /**
-     * Variable ID.
+     * Check if category has children (uses cached count)
      */
-    id: string;
+    categoryHasChildren(categoryId: string): boolean;
     /**
-     * Variable name.
+     * Check if category has activities (uses cached count)
      */
-    name: string;
+    categoryHasActivities(categoryId: string): boolean;
     /**
-     * Type name.
+     * Clear all caches
      */
-    typeName: string;
+    clearAllCache(): void;
     /**
-     * Is array flag.
+     * Clear categories cache only
      */
-    isArray?: boolean;
+    clearCategoriesCache(): void;
     /**
-     * Variable value (nullable).
+     * Clear activities cache only
      */
-    value?: any | null;
-    /**
-     * Storage driver type name (nullable).
-     */
-    storageDriverTypeName?: string | null;
+    clearActivitiesCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityDefinitionService>;
 }
+
 /**
- * Activity execution context state.
+ * Represents a workflow task that needs to be executed.
+ * Inspired by Temporal's Activity Tasks and Camunda's External Tasks.
  */
-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;
+interface AXPWorkflowTask {
     /**
-     * Dynamic variables.
+     * Unique token for this task (used for completion/security).
      */
-    dynamicVariables: AXPActivityVariable[];
+    taskToken: string;
     /**
-     * Activity status.
+     * Activity ID from workflow definition.
      */
-    status: AXPActivityStatus;
+    activityId: string;
     /**
-     * Is executing flag.
+     * Activity type (e.g., 'workflow-activity:show-toast').
      */
-    isExecuting: boolean;
+    activityType: string;
     /**
-     * Fault count.
+     * Human-readable activity name.
      */
-    faultCount: number;
+    activityName?: string;
     /**
-     * Started at timestamp (ISO date-time).
+     * 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)
      */
-    startedAt: string;
+    executionMode: 'frontend' | 'backend' | 'both';
     /**
-     * Completed at timestamp (ISO date-time, nullable).
+     * Input data for the activity (for frontend activities).
      */
-    completedAt?: string | null;
+    input?: Record<string, any>;
     /**
-     * Tag (nullable).
+     * Configuration for the activity (for frontend activities).
      */
-    tag?: any | null;
+    config?: Record<string, any>;
 }
 /**
- * Workflow state (internal execution state).
+ * Request to start a workflow instance.
  */
-interface AXPWorkflowState {
-    /**
-     * State ID.
-     */
-    id: string;
-    /**
-     * Workflow definition ID.
-     */
-    definitionId: string;
-    /**
-     * Workflow definition version.
-     */
-    definitionVersion: number;
-    /**
-     * Correlation ID (nullable).
-     */
-    correlationId?: string | null;
+interface AXPStartWorkflowRequest {
     /**
-     * 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.
+     * Workflow ID to execute.
      */
-    activityExecutionContexts: AXPActivityExecutionContextState[];
+    workflowId: string;
     /**
-     * Input data.
+     * Initial input data for workflow.
      */
     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.
+ * Response after starting workflow instance.
  */
-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;
+interface AXPStartWorkflowResponse {
     /**
-     * Correlation ID (nullable).
+     * Unique instance ID for this workflow run.
      */
-    correlationId?: string | null;
+    instanceId: string;
     /**
-     * Instance name (nullable).
-     */
-    name?: string | null;
-    /**
-     * Incident count.
-     */
-    incidentCount: number;
-    /**
-     * Created at timestamp (ISO date-time).
-     */
-    createdAt: string;
-    /**
-     * Updated at timestamp (ISO date-time).
+     * Current workflow state.
      */
-    updatedAt: string;
+    state: AXPWorkflowInstanceState;
     /**
-     * Finished at timestamp (ISO date-time, nullable).
+     * First task to execute (determined by backend).
+     * Client should execute this task based on executionMode.
      */
-    finishedAt?: string | null;
-}
-
-interface ActivityPropertyWidget {
-    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
-    options?: Record<string, any>;
+    pendingTask?: AXPWorkflowTask | null;
 }
 /**
- * Simple activity interface - just a command with outcomes.
- * All activities are AXPCommand for unified execution through Command Bus.
+ * Request to resume a suspended workflow.
  */
-interface IActivity<TInput = any, TOutput = any> extends AXPCommand<TInput, {
-    output: TOutput;
-    outcomes: Record<string, any>;
-}> {
+interface AXPResumeWorkflowRequest {
     /**
-     * Activity type name.
-     * Example: "WriteLine", "ShowDialog", "CreateUserCommand"
+     * Instance ID.
      */
-    type: string;
+    instanceId: string;
     /**
-     * Display name for UI.
+     * Step ID that was waiting for user input.
      */
-    name?: string;
+    stepId: string;
     /**
-     * Execute the activity as a command.
-     * @param input - Activity input data
-     * @returns Promise with output and outcomes
+     * Secure task token issued with the pending task.
+     * Backend validates and resolves the step using this token.
      */
-    execute(input: TInput): Promise<AXPExecuteCommandResult<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>>;
-}
-/**
- * Base abstract class for activities.
- * Extend this to create custom activities.
- */
-declare abstract class Activity<TInput = any, TOutput = any> implements IActivity<TInput, TOutput> {
-    type: string;
-    name?: string;
-    constructor(type: string, name?: string);
+    taskToken: string;
     /**
-     * Execute the activity as a command.
-     * Override this method in subclasses to implement activity logic.
+     * User action outcome (e.g., 'Confirmed', 'Cancelled').
      */
-    abstract execute(input: TInput): Promise<AXPExecuteCommandResult<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>>;
+    outcome: string;
     /**
-     * Helper method that returns Done outcome by default.
+     * Optional user input data.
      */
-    protected createResult(output: TOutput, outcome?: string): AXPExecuteCommandResult<{
-        output: TOutput;
-        outcomes: Record<string, any>;
-    }>;
+    userInput?: any;
 }
 /**
- * Activity descriptor - metadata about an activity type.
+ * Response after resuming workflow.
  */
-interface ActivityDescriptor {
-    /**
-     * Activity type name.
-     */
-    type: string;
-    /**
-     * Display name for UI.
-     */
-    displayName: string;
-    /**
-     * Description of what the activity does.
-     */
-    description?: string;
-    /**
-     * Category for grouping in toolbox.
-     */
-    category: string;
-    /**
-     * Icon name or class.
-     */
-    icon?: string;
-    /**
-     * Where this activity should be executed.
-     * - 'frontend': Execute in browser (UI activities, console, events)
-     * - 'backend': Execute in backend (business logic, API calls)
-     * - 'both': Execute in both frontend and backend (hybrid activities)
-     *
-     * Default: 'frontend'
-     */
-    executionMode?: 'frontend' | 'backend' | 'both';
+interface AXPResumeWorkflowResponse {
     /**
-     * Input descriptors.
-     */
-    inputs: InputDescriptor[];
-    /**
-     * Output descriptors.
+     * Activity execution output.
      */
-    outputs: OutputDescriptor[];
+    output: any;
     /**
-     * Static outcomes (exit points).
-     * Example: ['Done', 'Success', 'Failed']
+     * Activity execution outcomes.
      */
-    outcomes?: string[];
+    outcomes: Record<string, any>;
     /**
-     * Whether this activity is browsable in the toolbox.
-     * Default: true
+     * Next task to execute (if any).
      */
-    isBrowsable?: boolean;
+    nextTask?: AXPWorkflowTask | null;
     /**
-     * Whether this activity is a container (can have children).
-     * Default: false
+     * Updated workflow state.
      */
-    isContainer?: boolean;
-}
-/**
- * Input property descriptor.
- * Similar to AXPEntityProperty structure.
- */
-interface InputDescriptor {
-    name: string;
-    title: string;
-    description?: string;
-    schema: {
-        dataType: string;
-        nullable?: boolean;
-        readonly?: boolean;
-        hidden?: boolean | string;
-        defaultValue?: any | string | ((context: any | null) => any);
-        interface?: ActivityPropertyWidget;
-    };
-    validations?: AXPValidationRules;
+    state: AXPWorkflowInstanceState;
 }
 /**
- * Output property descriptor.
+ * Request to get workflow instance state.
  */
-interface OutputDescriptor {
-    name: string;
-    title: string;
-    description?: string;
-    schema: {
-        dataType: string;
-    };
+interface AXPGetWorkflowStateRequest {
+    /**
+     * Instance ID.
+     */
+    instanceId: string;
 }
 /**
- * Activity registry for registering and creating activities.
+ * Workflow instance state (managed by backend, cached in client).
  */
-declare class ActivityRegistry {
-    private registry;
-    private descriptors;
+interface AXPWorkflowInstanceState {
     /**
-     * Register an activity type.
+     * Unique instance ID.
      */
-    register(type: string, factory: () => IActivity, descriptor: ActivityDescriptor): void;
+    instanceId: string;
     /**
-     * Create an activity instance.
+     * Workflow ID.
      */
-    create(type: string): IActivity;
+    workflowId: string;
     /**
-     * Get activity descriptor.
+     * Current instance status.
      */
-    getDescriptor(type: string): ActivityDescriptor | undefined;
+    status: 'running' | 'completed' | 'suspended' | 'error';
     /**
-     * Get all registered types.
+     * Current step ID (if suspended or running).
      */
-    getTypes(): string[];
+    currentStepId?: string;
     /**
-     * Get all descriptors.
+     * Workflow variables (state).
      */
-    getAllDescriptors(): ActivityDescriptor[];
+    variables: Record<string, any>;
     /**
-     * Get descriptors by category.
+     * Initial input data.
      */
-    getDescriptorsByCategory(category: string): ActivityDescriptor[];
-}
-
-interface ActivityCategoryDescriptor {
-    name: string;
-    displayName: string;
-    description?: string;
-    icon?: string;
-    color?: string;
-    order?: number;
-    isVisible?: boolean;
-    tags?: string[];
-}
-interface AXPActivityCategoryProviderContext {
-    registerCategories(categories: ActivityCategoryDescriptor[]): void;
-}
-interface AXPActivityCategoryProvider {
-    provide(context: AXPActivityCategoryProviderContext): Promise<void> | void;
-}
-/**
- * Injection token for activity category providers.
- */
-declare const AXP_ACTIVITY_CATEGORY_PROVIDER: InjectionToken<AXPActivityCategoryProvider[]>;
-declare class AXPActivityCategoryProviderService {
-    private parent?;
-    private providers;
-    private categories;
-    private isInitialized;
-    constructor(parent?: AXPActivityCategoryProviderService | undefined, providers?: AXPActivityCategoryProvider[]);
-    private initialize;
-    getAllCategories(): ActivityCategoryDescriptor[];
-    getCategory(name: string): ActivityCategoryDescriptor | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityCategoryProviderService, [{ optional: true; skipSelf: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityCategoryProviderService>;
-}
-
-/**
- * Context for registering activities in a provider.
- */
-interface AXPActivityProviderContext {
+    input: Record<string, any>;
     /**
-     * Register an activity with its descriptor.
+     * Final output data (if completed).
      */
-    registerActivity(config: {
-        key: string;
-        descriptor: ActivityDescriptor;
-    }): void;
-}
-/**
- * Interface for activity providers.
- * Modules implement this to register their activities.
- */
-interface AXPActivityProvider {
+    output?: Record<string, any>;
     /**
-     * Provide activities to the system.
+     * Last update timestamp.
      */
-    provide(context: AXPActivityProviderContext): Promise<void> | void;
-}
-/**
- * Injection token for activity providers.
- */
-declare const AXP_ACTIVITY_PROVIDER: InjectionToken<AXPActivityProvider[]>;
-/**
- * Category definition for activity categorization.
- */
-interface ActivityCategory {
-    name: string;
-    displayName: string;
-    description?: string;
-    icon?: string;
-    color?: string;
-    order?: number;
-    isVisible?: boolean;
-    tags?: string[];
+    lastUpdated: Date;
 }
+
 /**
- * Activity Provider Service.
- * Collects all activity providers and manages activity registration.
+ * Interface for workflow engine operations.
  */
-declare class AXPActivityProviderService {
-    private activityDescriptors;
-    private categories;
-    private providers;
-    private categoryProviders;
-    private initialized;
-    private readonly commandService;
-    private readonly commandRegistry;
-    /**
-     * Register an activity provider.
-     */
-    registerProvider(provider: AXPActivityProvider): void;
+interface AXPWorkflowEngine {
     /**
-     * Register a category provider.
-     */
-    registerCategoryProvider(provider: AXPActivityCategoryProvider): void;
-    /**
-     * Initialize all providers.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get activity descriptor by key.
-     */
-    getDescriptor(key: string): ActivityDescriptor | undefined;
-    /**
-     * Get all activity descriptors.
-     */
-    getAllDescriptors(): ActivityDescriptor[];
-    /**
-     * Get descriptors by category.
+     * Start a new workflow instance.
+     *
+     * Creates a new workflow instance in backend and returns instance ID.
+     *
+     * @param request - Start workflow request
+     * @returns Response with instanceId and initial state
+     *
      */
-    getDescriptorsByCategory(category: string): ActivityDescriptor[];
+    start(request: AXPStartWorkflowRequest): Promise<AXPStartWorkflowResponse>;
     /**
-     * Get all categories.
+     * Resume a suspended workflow instance.
+     *
+     * Resumes workflow instance after user interaction (e.g., after show-dialog).
+     *
+     * @param request - Resume workflow request
+     * @returns Resume response with next step and updated state
+     *
      */
-    getCategories(): ActivityCategory[];
+    resume(request: AXPResumeWorkflowRequest): Promise<AXPResumeWorkflowResponse>;
     /**
-     * Create an activity instance by key using AXPCommandService.
+     * Get current workflow instance state.
+     *
+     * Retrieves current state of a workflow instance from backend.
+     *
+     * @param request - Get state request
+     * @returns Current workflow instance state
+     *
      */
-    createActivity(key: string): Promise<IActivity | null>;
-    private initializeProvider;
-    private initializeCategoryProvider;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityProviderService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityProviderService>;
+    getState(request: AXPGetWorkflowStateRequest): Promise<AXPWorkflowInstanceState>;
 }
-
 /**
- * Types and interfaces for Workflow Execution Service.
+ * Injection token for workflow engine.
+ * Default implementation is AXPWorkflowLocalEngine.
  */
+declare const AXP_WORKFLOW_ENGINE: InjectionToken<AXPWorkflowEngine>;
 
 /**
- * Represents a workflow task that needs to be executed.
- * Inspired by Temporal's Activity Tasks and Camunda's External Tasks.
+ * Result of executing a workflow activity.
  */
-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;
+interface ActivityExecutionResult {
     /**
-     * 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).
+     * Activity execution output.
      */
-    input?: Record<string, any>;
+    output: any;
     /**
-     * Configuration for the activity (for frontend activities).
+     * Activity execution outcome (e.g., 'Done', 'Confirmed', 'Cancelled', 'Failed').
      */
-    config?: Record<string, any>;
+    outcome: string;
 }
 /**
- * Request to start a workflow execution.
+ * Activity Executor Service
+ *
+ * Service for executing workflow activities via CommandBus.
+ * Automatically evaluates expressions in activity inputs before execution.
+ *
+ * @example
+ * ```typescript
+ * const executor = inject(ActivityExecutor);
+ *
+ * // Execute activity with task and workflow state (expressions will be evaluated)
+ * const result = await executor.execute(task, workflowState, activityOutputs);
+ * ```
  */
-interface AXPStartWorkflowExecutionRequest {
-    /**
-     * Workflow ID to execute.
-     */
-    workflowId: string;
+declare class ActivityExecutor {
+    private readonly commandService;
+    private readonly expressionEvaluator;
+    private readonly expressionScopeService;
     /**
-     * Initial input data for workflow.
+     * Execute a workflow activity with expression evaluation.
+     *
+     * Evaluates expressions in activity inputs using workflow state,
+     * then executes the activity via CommandBus.
+     *
+     * @param task - Workflow task containing activity information
+     * @param workflowState - Current workflow instance state (for expression evaluation)
+     * @param activityOutputs - Map of previous activity outputs (for expression evaluation)
+     * @returns Execution result with output and outcome
      */
-    input: Record<string, any>;
+    execute(task: AXPWorkflowTask, workflowState?: AXPWorkflowInstanceState, activityOutputs?: Map<string, any> | Record<string, any>): Promise<ActivityExecutionResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityExecutor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActivityExecutor>;
 }
+
 /**
- * Response after starting workflow execution.
+ * Result of starting a workflow.
  */
-interface AXPStartWorkflowExecutionResponse {
+interface WorkflowStartResult {
     /**
-     * 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.
+     * Whether the operation succeeded.
      */
-    pendingTask?: AXPWorkflowTask | null;
-}
-/**
- * Request to resume a suspended workflow.
- */
-interface AXPResumeWorkflowExecutionRequest {
+    success: boolean;
     /**
-     * Execution ID.
+     * Workflow instance ID.
      */
-    executionId: string;
+    instanceId?: string;
     /**
-     * Step ID that was waiting for user input.
+     * Initial workflow state.
      */
-    stepId: string;
+    state?: AXPWorkflowInstanceState;
     /**
-     * Secure task token issued with the pending task.
-     * Backend validates and resolves the step using this token.
+     * First task to execute (if any).
      */
-    taskToken: string;
+    nextTask?: AXPWorkflowTask | null;
     /**
-     * User action outcome (e.g., 'Confirmed', 'Cancelled').
+     * Workflow output (if completed immediately).
      */
-    outcome: string;
+    output?: any;
     /**
-     * Optional user input data.
+     * Error message (if failed).
      */
-    userInput?: any;
+    error?: string;
 }
 /**
- * Response after resuming workflow.
+ * Result of completing a task.
  */
-interface AXPResumeWorkflowExecutionResponse {
+interface WorkflowCompleteResult {
     /**
-     * Activity execution output.
+     * Whether the operation succeeded.
      */
-    output: any;
-    /**
-     * Activity execution outcomes.
-     */
-    outcomes: Record<string, any>;
+    success: boolean;
     /**
-     * Next task to execute (if any).
+     * Workflow instance ID.
      */
-    nextTask?: AXPWorkflowTask | null;
+    instanceId: string;
     /**
      * Updated workflow state.
      */
-    state: AXPWorkflowExecutionState;
-}
-/**
- * Request to get workflow execution state.
- */
-interface AXPGetWorkflowExecutionStateRequest {
+    state?: AXPWorkflowInstanceState;
     /**
-     * Execution ID.
+     * Next task to execute (if any).
      */
-    executionId: string;
-}
-/**
- * Request to get workflow definition.
- */
-interface AXPGetWorkflowDefinitionRequest {
+    nextTask?: AXPWorkflowTask | null;
     /**
-     * Workflow ID or definition ID.
+     * Workflow output (if completed).
      */
-    workflowId: string;
-}
-/**
- * Response with workflow definition.
- */
-interface AXPGetWorkflowDefinitionResponse {
+    output?: any;
     /**
-     * Workflow definition.
+     * Error message (if failed).
      */
-    workflow: AXPWorkflowDefinition;
+    error?: string;
 }
 /**
- * Workflow execution state (managed by backend, cached in client).
+ * Result of resuming a workflow.
  */
-interface AXPWorkflowExecutionState {
+interface WorkflowResumeResult {
     /**
-     * Unique execution ID.
-     */
-    executionId: string;
-    /**
-     * Workflow ID.
+     * Whether the operation succeeded.
      */
-    workflowId: string;
-    /**
-     * Current execution status.
-     */
-    status: 'running' | 'completed' | 'suspended' | 'error';
-    /**
-     * Current step ID (if suspended or running).
-     */
-    currentStepId?: string;
+    success: boolean;
     /**
-     * Workflow variables (state).
+     * Workflow instance ID.
      */
-    variables: Record<string, any>;
+    instanceId: string;
     /**
-     * Initial input data.
+     * Updated workflow state.
      */
-    input: Record<string, any>;
+    state?: AXPWorkflowInstanceState;
     /**
-     * Final output data (if completed).
+     * Next task to execute (if any).
      */
-    output?: Record<string, any>;
+    nextTask?: AXPWorkflowTask | null;
     /**
-     * Last update timestamp.
+     * Workflow output (if completed).
      */
-    lastUpdated: Date;
-}
-
-/**
- * Workflow execution result.
- */
-interface WorkflowExecutionResult {
-    success: boolean;
     output?: any;
+    /**
+     * Error message (if failed).
+     */
     error?: string;
-    nextTask?: AXPWorkflowTask | null;
-    executionId?: string;
-    state?: AXPWorkflowExecutionState;
 }
 /**
- * Production Workflow Coordinator.
+ * Workflow Manager - Facade for workflow lifecycle orchestration.
  *
- * 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
+ * This service is the ONLY interface the frontend uses to interact with workflows.
+ * It follows Clean Architecture principles and does NOT contain execution or business logic.
  *
+ * Responsibilities:
+ * - Orchestrate workflow lifecycle (start, execute, complete, resume)
+ * - Delegate execution to ActivityExecutor
+ * - Cache workflow state in memory
+ * - Expose a stable API for UI
+ *
+ * Rules:
+ * - No HTTP calls (delegates to AXPWorkflowEngine)
+ * - No CommandBus / Command execution (delegates to ActivityExecutor)
+ * - No workflow branching logic (backend decides)
+ * - No business validation (backend validates)
+ * - No backend assumptions (uses abstract runtime service)
  */
-declare class WorkflowCoordinator {
-    private readonly workflowExecutionService;
-    private readonly commandService;
+declare class AXPWorkflowManager {
+    private readonly workflowEngine;
+    private readonly activityExecutor;
     /**
      * Cache workflow states in memory for quick access.
-     * Key: executionId
-     * Value: AXPWorkflowExecutionState
+     * Key: instanceId
+     * Value: AXPWorkflowInstanceState
      */
     private stateCache;
     /**
-     * Start workflow execution in backend.
+     * Cache TTL in milliseconds (5 minutes).
+     */
+    private readonly CACHE_TTL;
+    /**
+     * Start a new workflow instance.
      *
+     * Creates a new workflow instance in backend and returns instance ID.
      * 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)
+     * @param workflowId - Workflow ID to start
+     * @param input - Initial input data (optional)
+     * @returns Start result with instanceId, state, and nextTask
      *
      * @example
      * ```typescript
-     * const result = await coordinator.startWorkflow('my-workflow', { userId: '123' });
+     * const result = await workflowManager.start('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);
+     * if (result.success && result.nextTask) {
+     *   // Execute task if frontend
+     *   if (result.nextTask.executionMode === 'frontend') {
+     *     const execResult = await workflowManager.execute(result.nextTask);
+     *     await workflowManager.complete(result.instanceId!, result.nextTask, execResult.outcome, execResult.output);
      *   }
      * }
      * ```
      */
-    startWorkflow(workflowId: string, input?: Record<string, any>): Promise<WorkflowExecutionResult>;
+    start(workflowId: string, input?: Record<string, any>): Promise<WorkflowStartResult>;
     /**
-     * Execute a frontend task using AXPCommand.
+     * Execute a frontend task.
      *
-     * Only executes if task.executionMode is 'frontend' or 'both'.
-     * Backend tasks are handled automatically by backend.
+     * Delegates to ActivityExecutor for actual execution.
+     * Only executes tasks with executionMode 'frontend' or 'both'.
+     *
+     * Provides workflow state to executor for expression evaluation.
      *
      * @param task - Task to execute
      * @returns Execution result with output and outcome
+     *
+     * @throws Error if task is not a frontend task
      */
-    executeTask(task: AXPWorkflowTask): Promise<{
-        output: any;
-        outcome: string;
-    }>;
+    execute(task: AXPWorkflowTask): Promise<ActivityExecutionResult>;
     /**
      * 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 instanceId - Workflow instance 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.
+     * @param output - Task output/result (optional)
+     * @returns Complete result with next task (if any)
      */
-    executeWorkflowById(workflowId: string, input?: Record<string, any>): Promise<WorkflowExecutionResult>;
+    complete(instanceId: string, task: AXPWorkflowTask, outcome: string, output?: any): Promise<WorkflowCompleteResult>;
     /**
      * 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.
+     * Client only provides instanceId, stepId, outcome, and optional userInput.
      *
-     * @param executionId - Workflow execution ID
+     * @param instanceId - Workflow instance 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
+     * @param taskToken - Secure task token (required for secure resumption)
+     * @returns Resume result with next task (if any)
      */
-    resumeWorkflow(executionId: string, stepId: string, outcome: string, userInput?: any, taskToken?: string): Promise<WorkflowExecutionResult>;
+    resume(instanceId: string, stepId: string, outcome: string, userInput?: any, taskToken?: string): Promise<WorkflowResumeResult>;
     /**
-     * Get workflow execution state (from cache or backend).
-     */
-    getWorkflowState(executionId: string): Promise<AXPWorkflowExecutionState | null>;
-    /**
-     * Execute a frontend activity using CommandBus.
+     * Get workflow instance state.
      *
-     * Frontend activities are executed in the browser using AXPCommandService.
-     * Activities can also be executed in both frontend and backend (hybrid mode).
+     * Retrieves state from cache (if valid) or from backend.
      *
-     * @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.
+     * @param instanceId - Workflow instance ID
+     * @returns Workflow instance state or null if not found
      */
-    private startWorkflowExecution;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowCoordinator, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WorkflowCoordinator>;
+    getState(instanceId: string): Promise<AXPWorkflowInstanceState | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowManager>;
 }
 
 /**
- * Abstract service for workflow execution operations.
- *
- * This service handles communication with backend for workflow execution.
+ * Local engine implementation that manages workflow progression and state.
  *
- * 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
- *   }
- * }
+ * This engine:
+ * - Returns frontend/both activities as pendingTask (does NOT execute them)
+ * - Skips backend activities (does not error, continues execution)
+ * - Maintains workflow state in memory
+ * - Does not require backend API calls
  *
- * // In connectivity/api
- * @Injectable()
- * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
- *   constructor(private http: HttpClient) {}
+ * Execution of frontend tasks is handled by AXPWorkflowManager via ActivityExecutor.
+ * This engine only manages workflow progression and state storage.
  *
- *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
- *     return firstValueFrom(
- *       this.http.post<AXPStartWorkflowExecutionResponse>(
- *         `${this.config.baseUrl}/api/workflows/${request.workflowId}/start`,
- *         { input: request.input }
- *       )
- *     );
- *   }
- * }
- * ```
+ * This is the DEFAULT engine provider. Applications can override it with
+ * an API-based engine implementation.
  */
-declare abstract class AXPWorkflowExecutionService {
+declare class AXPWorkflowLocalEngine implements AXPWorkflowEngine {
+    private readonly activityDefinitionService;
+    private readonly workflowProviders;
     /**
-     * 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);
-     * ```
+     * In-memory storage for workflow instances.
+     * Key: instanceId
+     * Value: LocalWorkflowState
      */
-    abstract startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse>;
+    private instances;
     /**
-     * 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);
-     * ```
+     * Task token storage for secure resume operations.
+     * Key: taskToken
+     * Value: { instanceId, activityId }
      */
-    abstract resumeExecution(request: AXPResumeWorkflowExecutionRequest): Promise<AXPResumeWorkflowExecutionResponse>;
+    private taskTokens;
     /**
-     * Get current workflow execution state.
-     *
-     * Retrieves current state of a workflow execution from backend.
-     *
-     * @param request - Get state request
-     * @returns Current workflow execution state
+     * Start a new workflow instance.
      *
-     * @example
-     * ```typescript
-     * const state = await workflowExecutionService.getExecutionState({
-     *   executionId: 'exec-123'
-     * });
-     *
-     * console.log('Status:', state.status);
-     * console.log('Variables:', state.variables);
-     * ```
+     * Creates an in-memory workflow instance and progresses it.
+     * Frontend/both activities are returned as pendingTask for external execution.
+     * Backend activities are skipped.
      */
-    abstract getExecutionState(request: AXPGetWorkflowExecutionStateRequest): Promise<AXPWorkflowExecutionState>;
+    start(request: AXPStartWorkflowRequest): Promise<AXPStartWorkflowResponse>;
     /**
-     * Get workflow definition by ID.
+     * Resume a suspended workflow instance.
      *
-     * Retrieves workflow definition from backend.
-     *
-     * @param request - Get workflow definition request
-     * @returns Workflow definition in executable format
+     * Validates task token, applies externally executed result,
+     * and continues progressing workflow steps.
+     */
+    resume(request: AXPResumeWorkflowRequest): Promise<AXPResumeWorkflowResponse>;
+    /**
+     * Get current workflow instance state.
+     */
+    getState(request: AXPGetWorkflowStateRequest): Promise<AXPWorkflowInstanceState>;
+    /**
+     * Get workflow definition from available providers.
+     */
+    private getDefinition;
+    /**
+     * Progress workflow steps starting from the current position.
      *
-     * @example
-     * ```typescript
-     * const response = await workflowExecutionService.getWorkflowDefinition({
-     *   workflowId: 'my-workflow'
-     * });
+     * For frontend/both activities: returns task immediately (suspends workflow).
+     * For backend activities: skips and continues.
      *
-     * console.log('Workflow:', response.workflow);
-     * ```
+     * Returns the next pending task (if frontend activity found) or null (if completed).
+     */
+    private executeWorkflowSteps;
+    /**
+     * Get next activity ID based on connections and outcomes.
      */
-    abstract getWorkflowDefinition(request: AXPGetWorkflowDefinitionRequest): Promise<AXPGetWorkflowDefinitionResponse>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowExecutionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowExecutionService>;
+    private getNextActivityId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowLocalEngine, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowLocalEngine>;
 }
 
 /**
- * WriteLine Activity - Simple console logging activity.
- *
- * Usage:
- * ```typescript
- * const activity = new WriteLine();
- * await activity.execute({ text: 'Hello World' });
- * ```
+ * Workflow expression evaluation context.
+ * Contains workflow state data needed for expression evaluation.
  */
-declare class WriteLine extends Activity<{
-    text?: string;
-}, void> {
-    constructor();
-    execute(input: {
-        text?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+interface WorkflowExpressionContext {
+    /** Workflow input values */
+    inputs: Record<string, any>;
+    /** Workflow state variables */
+    variables: Record<string, any>;
+    /** Previous activity outputs (activityId -> output) */
+    outputs: Record<string, any>;
 }
-
 /**
- * Sequence Activity - Executes activities in sequential order.
+ * Workflow Expression Scope Service
  *
- * Usage:
- * ```typescript
- * const sequence = new Sequence();
- * sequence.activities = [activity1, activity2, activity3];
- * await sequence.execute({});
- * ```
- */
-declare class Sequence extends Activity<{}, void> {
-    /**
-     * Activities to execute in sequence.
-     */
-    activities: IActivity[];
-    constructor();
-    execute(input: {}): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Show Confirm Dialog Activity - Displays confirmation dialog to user.
+ * Shared service for building expression evaluation scope from workflow data.
+ * Used by both Local Engine and Mock Runtime to manage workflow data (inputs, variables, outputs).
+ *
+ * Responsibilities:
+ * - Build expression evaluation scope from workflow state
+ * - Provide context.eval() function for accessing workflow data
+ * - Manage workflow data structure (inputs, variables, outputs)
  *
- * Has two outcomes:
- * - 'Confirmed': User clicked confirm/yes
- * - 'Cancelled': User clicked cancel/no
+ * This service does NOT:
+ * - Execute activities
+ * - Evaluate expressions (delegates to AXPExpressionEvaluatorService)
+ * - Manage workflow state (handled by runtime)
  *
- * Usage:
+ * @example
  * ```typescript
- * const dialog = new ShowConfirmDialog();
- * await dialog.execute({
- *   title: 'Confirm Delete',
- *   message: 'Are you sure?',
- *   color: 'danger'
+ * const scopeService = inject(WorkflowExpressionScopeService);
+ *
+ * // Build scope from workflow state
+ * const scope = scopeService.buildScope({
+ *   inputs: state.input || {},
+ *   variables: state.variables || {},
+ *   outputs: activityOutputs
  * });
+ *
+ * // Or build from state directly
+ * const scope = scopeService.buildScopeFromState(state, activityOutputs);
  * ```
  */
-declare class ShowConfirmDialog extends Activity<{
-    title?: string;
-    message?: string;
-    color?: AXStyleColorType;
-    defaultAction?: 'confirm' | 'cancel';
-    align?: 'horizontal' | 'vertical';
-    backdrop?: boolean;
-}, {
-    result: boolean;
-    action: string;
-}> {
-    private readonly dialogService;
-    private readonly translationService;
-    constructor();
-    execute(input: {
-        title?: string;
-        message?: string;
-        color?: AXStyleColorType;
-        defaultAction?: 'confirm' | 'cancel';
-        align?: 'horizontal' | 'vertical';
-        backdrop?: boolean;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: {
-            result: boolean;
-            action: string;
-        };
-        outcomes: Record<string, any>;
-    }>>;
+declare class WorkflowExpressionScopeService {
+    /**
+     * Build expression evaluation scope for workflow activities.
+     *
+     * Provides workflow-specific data (inputs, variables, outputs) and context.eval() function.
+     * Other data (session, current user, etc.) are provided by expression evaluator scope providers.
+     *
+     * Scope includes:
+     * - inputs: Workflow input values (accessible as inputs.propertyName)
+     * - variables: Workflow state variables (accessible as variables.propertyName or vars.propertyName)
+     * - outputs: Previous activity outputs (accessible as outputs.activityId)
+     * - context.eval(path): Function to access nested properties from workflow data
+     *
+     * Expressions can use:
+     * - {{inputs.userName}} - Direct access to workflow input
+     * - {{variables.someVar}} or {{vars.someVar}} - Direct access to workflow variable
+     * - {{outputs.activityId.property}} - Direct access to previous activity output
+     * - {{context.eval("inputs.userName")}} - Access via context.eval (supports nested paths)
+     * - {{context.eval("variables.someVar")}} - Access variables via context.eval
+     * - {{context.eval("outputs.activityId.property")}} - Access outputs via context.eval
+     * - {{session.currentUser().name}} - Access current user via expression evaluator scope providers
+     *
+     * The context.eval() function provides a unified way to access all workflow data,
+     * similar to how entity-detail-list uses context.eval() to access parent data.
+     *
+     * @param context - Workflow expression context containing inputs, variables, and outputs
+     * @returns Expression evaluator scope with workflow data and context.eval() function
+     */
+    buildScope(context: WorkflowExpressionContext): AXPExpressionEvaluatorScope;
+    /**
+     * Build expression evaluation scope from workflow instance state.
+     *
+     * Convenience method that extracts data from AXPWorkflowInstanceState.
+     *
+     * @param state - Workflow instance state
+     * @param activityOutputs - Map of activity outputs (activityId -> output)
+     * @returns Expression evaluator scope with workflow data and context.eval() function
+     */
+    buildScopeFromState(state: AXPWorkflowInstanceState, activityOutputs?: Map<string, any> | Record<string, any>): AXPExpressionEvaluatorScope;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowExpressionScopeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkflowExpressionScopeService>;
 }
 
 /**
- * Show Alert Dialog Activity - Displays alert dialog to user.
- *
- * Has one outcome:
- * - 'Done': User clicked OK
+ * Workflow Category - Extends AXPCategoryEntity for consistency and performance
  *
- * Usage:
- * ```typescript
- * const dialog = new ShowAlertDialog();
- * await dialog.execute({
- *   title: 'Alert',
- *   message: 'This is an alert',
- *   color: 'info'
- * });
- * ```
+ * 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 workflows count
+ * - totalChildren?: number       - Total nested categories (optional, for analytics)
+ * - totalItems?: number          - Total workflows in tree (optional, for analytics)
  */
-declare class ShowAlertDialog extends Activity<{
-    title?: string;
-    message?: string;
-    color?: AXStyleColorType;
-}, {
-    result: boolean;
-    action: string;
-}> {
-    private readonly dialogService;
-    private readonly translationService;
-    constructor();
-    execute(input: {
-        title?: string;
-        message?: string;
-        color?: AXStyleColorType;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: {
-            result: boolean;
-            action: string;
-        };
-        outcomes: Record<string, any>;
-    }>>;
+interface AXPWorkflowCategory extends AXPCategoryEntity {
+}
+type AXPWorkflowProviderToken = AXPWorkflowProvider | Promise<AXPWorkflowProvider>;
+declare const AXP_WORKFLOW_PROVIDER: InjectionToken<AXPWorkflowProviderToken[]>;
+interface AXPWorkflowProvider {
+    /**
+     * Get list of workflow definitions for a category.
+     * @param categoryId - Category ID to filter workflows
+     * @returns Promise of workflow definition array
+     */
+    getList(categoryId: string): Promise<AXPWorkflowDefinition[]>;
+    /**
+     * Get full workflow definition by name (unique identifier).
+     * Used by workflow engines for execution and UI for metadata.
+     * @param name - Workflow name (unique identifier)
+     * @returns Promise of full workflow definition or null if not found
+     */
+    getByName(name: string): Promise<AXPWorkflowDefinition | null>;
+}
+type AXPWorkflowCategoryProviderToken = AXPWorkflowCategoryProvider | Promise<AXPWorkflowCategoryProvider>;
+declare const AXP_WORKFLOW_CATEGORY_PROVIDER: InjectionToken<AXPWorkflowCategoryProviderToken[]>;
+interface AXPWorkflowCategoryProvider {
+    getList(parentId?: string): Promise<AXPWorkflowCategory[]>;
+    getById(id: string): Promise<AXPWorkflowCategory | undefined>;
 }
 
 /**
- * Show Dialog Layout Builder Activity - Displays dialog using Layout Builder.
- *
- * This activity allows you to create custom dialogs using the Layout Builder API.
- * It accepts JSON-serializable content (AXPWidgetNode) and actions configuration.
- *
- * The content can be created using Layout Builder and then converted to JSON:
- * ```typescript
- * const builder = layoutBuilderService.create();
- * builder.flex(flex => {
- *   flex.setDirection('column')
- *     .formField('First Name', field => {
- *       field.path('firstName');
- *       field.textBox({ placeholder: 'Enter first name' });
- *     });
- * });
- * const contentNode = builder.build();
- * ```
+ * Optimized Workflow Definition Service
  *
- * Usage in Workflow:
- * ```typescript
- * const dialog = new ShowDialogLayoutBuilder();
- * await dialog.execute({
- *   title: 'User Information',
- *   size: 'md',
- *   context: { firstName: '', lastName: '' },
- *   content: {
- *     type: 'flex-layout',
- *     mode: 'edit',
- *     options: {
- *       flexDirection: 'column',
- *       gap: '16px'
- *     },
- *     children: [
- *       {
- *         type: 'form-field',
- *         mode: 'edit',
- *         options: {
- *           label: 'First Name',
- *           showLabel: true
- *         },
- *         children: [{
- *           type: 'text-editor',
- *           path: 'firstName',
- *           options: {
- *             placeholder: 'Enter first name'
- *           }
- *         }]
- *       }
- *     ]
- *   },
- *   actions: {
- *     cancel: '@general:actions.cancel.title',
- *     submit: '@general:actions.submit.title',
- *     custom: [{
- *       title: 'Save Draft',
- *       icon: 'fa-save',
- *       color: 'secondary',
- *       command: { name: 'save-draft' }
- *     }]
- *   }
- * });
- * ```
+ * Manages workflow definitions (metadata) for UI and tooling.
+ * Similar to AXPActivityDefinitionService - only handles metadata, not execution.
  *
- * Usage in JSON Workflow Definition:
- * ```json
- * {
- *   "type": "ShowDialogLayoutBuilder",
- *   "properties": {
- *     "title": "User Information",
- *     "size": "md",
- *     "context": { "firstName": "", "lastName": "" },
- *     "content": {
- *       "type": "flex-layout",
- *       "mode": "edit",
- *       "options": {
- *         "flexDirection": "column",
- *         "gap": "16px"
- *       },
- *       "children": [
- *         {
- *           "type": "form-field",
- *           "mode": "edit",
- *           "options": {
- *             "label": "First Name",
- *             "showLabel": true
- *           },
- *           "children": [{
- *             "type": "text-editor",
- *             "path": "firstName",
- *             "options": {
- *               "placeholder": "Enter first name"
- *             }
- *           }]
- *         }
- *       ]
- *     },
- *     "actions": {
- *       "cancel": "@general:actions.cancel.title",
- *       "submit": "@general:actions.submit.title"
- *     }
- *   }
- * }
- * ```
- */
-declare class ShowDialogLayoutBuilder extends Activity<{
+ * Performance optimizations:
+ * 1. Uses childrenCount to determine if category has children (no query needed)
+ * 2. Uses itemsCount to determine if category has workflows (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 AXPWorkflowDefinitionService {
+    private readonly categoryProviders;
+    private readonly workflowProviders;
+    /** Cache for categories by id - O(1) lookup */
+    private categoriesById;
+    /** Cache for categories by parentId - O(1) lookup */
+    private categoriesByParentId;
+    /** Cache for workflow definitions by categoryId - O(1) lookup */
+    private workflowsByCategory;
+    /** Cache for individual workflow definitions by name - O(1) lookup */
+    private workflowsByName;
+    /** Track which provider index owns each category (by category ID) */
+    private categoryOwnership;
+    /** Pending API requests to prevent duplicate calls */
+    private pendingCategoriesRequests;
+    private pendingWorkflowsRequests;
+    private pendingWorkflowRequests;
+    /**
+     * 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<AXPWorkflowCategory[]>;
+    /**
+     * 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<AXPWorkflowCategory | undefined>;
     /**
-     * Dialog title
+     * Get category path from root to specified category
+     *
+     * Optimization: Builds path using cached categories only
      */
-    title?: string;
+    getCategoriesPathById(categoryId: string): Promise<AXPWorkflowCategory[]>;
     /**
-     * Dialog size
+     * Get workflow 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 workflow definitions
+     * - Returns cached result on subsequent calls
+     *
+     * @param categoryId - Category ID to get workflow definitions from
+     * @returns Array of workflow definitions
      */
-    size?: AXPopupSizeType;
+    getWorkflowsByCategoryId(categoryId: string): Promise<AXPWorkflowDefinition[]>;
     /**
-     * Initial dialog context/data
+     * Get single workflow definition by name with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval
+     *
+     * @param name - Workflow name (unique identifier)
+     * @returns Workflow definition or undefined if not found
      */
-    context?: Record<string, any>;
+    getWorkflowByName(name: string): Promise<AXPWorkflowDefinition | undefined>;
     /**
-     * Show close button
+     * Get category ID containing a specific workflow definition
+     *
+     * Optimization: Searches cache first, loads on-demand if needed
      */
-    closeButton?: boolean;
+    getCategoryIdByWorkflowName(workflowName: string): Promise<string | undefined>;
     /**
-     * Dialog message (optional, shown above content)
+     * Get category path for a workflow
      */
-    message?: string;
+    getCategoriesPathByWorkflowName(workflowName: string): Promise<AXPWorkflowCategory[]>;
     /**
-     * Dialog content as AXPWidgetNode (JSON-serializable)
-     * This can be created using Layout Builder and then converted to JSON.
+     * 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
      */
-    content?: AXPWidgetNode;
+    private loadCategoriesFromProviders;
     /**
-     * Dialog actions configuration (JSON-serializable)
+     * Get the provider index that owns a specific category
+     *
+     * @returns Array with provider index, or null if ownership unknown (query all)
      */
-    actions?: {
-        /**
-         * Cancel button text (optional)
-         */
-        cancel?: string;
-        /**
-         * Submit button text (optional)
-         */
-        submit?: string;
-        /**
-         * Custom actions array (optional)
-         */
-        custom?: AXPActionMenuItem[];
-    };
-}, {
+    private getProviderIndexForCategory;
     /**
-     * Dialog context/data after user interaction
+     * Load workflow definitions from providers and cache results
+     *
+     * Optimization: Only queries the provider that owns the category
+     * Uses provider INDEX to match category provider with workflow provider
      */
-    context: Record<string, any>;
+    private loadWorkflowsFromProviders;
     /**
-     * Action that user clicked (e.g., 'submit', 'cancel', or custom action name)
+     * Load single workflow definition from providers and cache result
      */
-    action: string;
+    private loadWorkflowFromProviders;
     /**
-     * Whether user cancelled the dialog
+     * Breadth-first search through category hierarchy
      */
-    cancelled: boolean;
+    private searchCategoryInHierarchy;
     /**
-     * Whether user confirmed/submitted the dialog
+     * Check if category has children (uses cached count)
      */
-    confirmed: boolean;
-}> {
-    private readonly layoutBuilder;
-    constructor();
-    execute(input: {
-        title?: string;
-        size?: AXPopupSizeType;
-        context?: Record<string, any>;
-        closeButton?: boolean;
-        message?: string;
-        content?: AXPWidgetNode;
-        actions?: {
-            cancel?: string;
-            submit?: string;
-            custom?: AXPActionMenuItem[];
-        };
-    }): Promise<AXPExecuteCommandResult<{
-        output: {
-            context: Record<string, any>;
-            action: string;
-            cancelled: boolean;
-            confirmed: boolean;
-        };
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Show Toast Activity - Displays toast notification to user.
- *
- * Usage:
- * ```typescript
- * const toast = new ShowToast();
- * await toast.execute({
- *   color: 'success',
- *   title: 'Success',
- *   message: 'Operation completed successfully!'
- * });
- * ```
- */
-declare class ShowToast extends Activity<{
-    color?: AXStyleColorType;
-    title?: string;
-    message?: string;
-    duration?: number;
-}, void> {
-    private readonly toastService;
-    private readonly translationService;
-    constructor();
-    execute(input: {
-        color?: AXStyleColorType;
-        title?: string;
-        message?: string;
-        duration?: number;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Navigate Activity - Navigates to different pages/routes.
- *
- * Usage:
- * ```typescript
- * const navigate = new Navigate();
- * await navigate.execute({
- *   mode: 'route',
- *   route: '/users',
- *   params: { id: '123' }
- * });
- * ```
- */
-declare class Navigate extends Activity<{
-    mode?: 'route' | 'entity-details' | 'entity-list' | 'external';
-    route?: string;
-    params?: Record<string, any>;
-    queryParams?: Record<string, any>;
-    entity?: string;
-    entityId?: string;
-    url?: string;
-}, void> {
-    private readonly router;
-    constructor();
-    execute(input: {
-        mode?: 'route' | 'entity-details' | 'entity-list' | 'external';
-        route?: string;
-        params?: Record<string, any>;
-        queryParams?: Record<string, any>;
-        entity?: string;
-        entityId?: string;
-        url?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Set Variable Activity - Sets a variable value in workflow context.
- *
- * Usage:
- * ```typescript
- * const setVar = new SetVariable();
- * await setVar.execute({
- *   variableName: 'userId',
- *   value: '12345'
- * });
- * ```
- */
-declare class SetVariable extends Activity<{
-    variableName: string;
-    value: any;
-}, void> {
-    constructor();
-    execute(input: {
-        variableName: string;
-        value: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Dispatch Event Activity - Dispatches an event to the system.
- *
- * Usage:
- * ```typescript
- * const dispatch = new DispatchEvent();
- * await dispatch.execute({
- *   eventName: 'user-created',
- *   eventData: { userId: '123', name: 'John' }
- * });
- * ```
- */
-declare class DispatchEvent extends Activity<{
-    eventName: string;
-    eventData?: any;
-}, void> {
-    constructor();
-    execute(input: {
-        eventName: string;
-        eventData?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * If Activity - Conditional execution based on a condition.
- *
- * Usage:
- * ```typescript
- * const ifActivity = new If();
- * ifActivity.condition = '{{user.isAdmin}}';
- * ifActivity.thenActivities = [activity1, activity2];
- * ifActivity.elseActivities = [activity3];
- * ```
- */
-declare class If extends Activity<{
-    condition: string | boolean;
-    thenActivities?: IActivity[];
-    elseActivities?: IActivity[];
-}, any> {
-    constructor();
-    execute(input: {
-        condition: string | boolean;
-        thenActivities?: IActivity[];
-        elseActivities?: IActivity[];
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-    private evaluateCondition;
-}
-
-/**
- * While Activity - Loop execution while condition is true.
- *
- * Usage:
- * ```typescript
- * const whileActivity = new While();
- * whileActivity.condition = '{{counter < 10}}';
- * whileActivity.activities = [incrementActivity, logActivity];
- * ```
- */
-declare class While extends Activity<{
-    condition: string | boolean;
-    activities?: IActivity[];
-    maxIterations?: number;
-}, any> {
-    constructor();
-    execute(input: {
-        condition: string | boolean;
-        activities?: IActivity[];
-        maxIterations?: number;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-    private evaluateCondition;
-}
-
-/**
- * ForEach Activity - Iterates over a collection of items.
- *
- * Usage:
- * ```typescript
- * const forEach = new ForEach();
- * await forEach.execute({
- *   items: ['item1', 'item2', 'item3'],
- *   activities: [processItemActivity]
- * });
- * ```
- */
-declare class ForEach extends Activity<{
-    items: any[];
-    activities?: IActivity[];
-    itemVariableName?: string;
-    indexVariableName?: string;
-}, any> {
-    constructor();
-    execute(input: {
-        items: any[];
-        activities?: IActivity[];
-        itemVariableName?: string;
-        indexVariableName?: string;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Execute Command Activity - Executes a command through Command Bus.
- *
- * Usage:
- * ```typescript
- * const executeCmd = new ExecuteCommand();
- * await executeCmd.execute({
- *   commandKey: 'UserManagement.CreateUser',
- *   input: { name: 'John', email: 'john@example.com' }
- * });
- * ```
- */
-declare class ExecuteCommand extends Activity<{
-    commandKey: string;
-    input?: any;
-}, any> {
-    private readonly commandService;
-    constructor();
-    execute(input: {
-        commandKey: string;
-        input?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Execute Query Activity - Executes a query through Query Bus.
- *
- * Usage:
- * ```typescript
- * const executeQuery = new ExecuteQuery();
- * await executeQuery.execute({
- *   queryKey: 'UserManagement.GetUsers',
- *   input: { page: 1, pageSize: 10 }
- * });
- * ```
- */
-declare class ExecuteQuery extends Activity<{
-    queryKey: string;
-    input?: any;
-}, any> {
-    private readonly queryService;
-    constructor();
-    execute(input: {
-        queryKey: string;
-        input?: any;
-    }): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: any;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * Start Activity - Marks the start point of a workflow.
- *
- * This is a visual marker activity that doesn't perform any actual work.
- * It's used in workflow designers to clearly indicate where a workflow begins.
- *
- * Usage:
- * ```typescript
- * const start = new StartActivity();
- * await start.execute({});
- * ```
- */
-declare class StartActivity extends Activity<Record<string, never>, void> {
-    constructor();
-    execute(input: Record<string, never>): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
-}
-
-/**
- * End Activity - Marks the end point of a workflow.
- *
- * This is a visual marker activity that terminates the workflow execution.
- * When this activity is reached, the workflow completes successfully.
- *
- * Usage:
- * ```typescript
- * const end = new EndActivity();
- * await end.execute({});
- * ```
- */
-declare class EndActivity extends Activity<Record<string, never>, void> {
-    constructor();
-    execute(input: Record<string, never>): Promise<_acorex_platform_core.AXPExecuteCommandResult<{
-        output: void;
-        outcomes: Record<string, any>;
-    }>>;
+    categoryHasChildren(categoryId: string): boolean;
+    /**
+     * Check if category has workflows (uses cached count)
+     */
+    categoryHasWorkflows(categoryId: string): boolean;
+    /**
+     * Clear all caches
+     */
+    clearAllCache(): void;
+    /**
+     * Clear categories cache only
+     */
+    clearCategoriesCache(): void;
+    /**
+     * Clear workflows cache only
+     */
+    clearWorkflowsCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionService>;
 }
 
-/**
- * Command setups for all built-in workflow activities.
- * Registers activities as AXPCommand instances.
- */
-declare const provideWorkflowActivityCommands: () => i0.EnvironmentProviders;
-
-export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowDialogLayoutBuilder, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
-export type { AXPActivity, AXPActivityCategoryProvider, AXPActivityCategoryProviderContext, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderContext, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPCustomProperties, AXPEndpoint, AXPExceptionState, AXPExpression, AXPFlowchart, AXPGetWorkflowDefinitionRequest, AXPGetWorkflowDefinitionResponse, AXPGetWorkflowExecutionStateRequest, AXPInputValue, AXPMetadata, AXPOutputValue, AXPPosition, AXPResumeWorkflowExecutionRequest, AXPResumeWorkflowExecutionResponse, AXPStartWorkflowExecutionRequest, AXPStartWorkflowExecutionResponse, AXPStoredWorkflowDefinition, AXPVariableDefinition, AXPVariableModel, AXPVersionedEntity, AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionPreloader, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityCategory, ActivityCategoryDescriptor, ActivityDescriptor, ActivityPropertyWidget, IActivity, InputDescriptor, OutputDescriptor, WorkflowExecutionResult };
+export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_PROVIDER, ActivityExecutor, WorkflowExpressionScopeService, createWorkFlowEvent, ofType };
+export type { AXPActivity, AXPActivityCategory, AXPActivityCategoryProvider, AXPActivityCategoryProviderToken, AXPActivityDefinition, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderToken, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPElsaWorkflowExtensions, AXPExceptionState, AXPGetWorkflowStateRequest, AXPResumeWorkflowRequest, AXPResumeWorkflowResponse, AXPStartWorkflowRequest, AXPStartWorkflowResponse, AXPVariableDefinition, AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowActivityInstance, AXPWorkflowBinding, AXPWorkflowCategory, AXPWorkflowCategoryProvider, AXPWorkflowCategoryProviderToken, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowEngine, AXPWorkflowEvent, AXPWorkflowExtensions, AXPWorkflowFaultState, AXPWorkflowGraph, AXPWorkflowInputDescriptor, AXPWorkflowInstance, AXPWorkflowInstanceState, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOutputDescriptor, AXPWorkflowProvider, AXPWorkflowProviderToken, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityExecutionResult, WorkflowCompleteResult, WorkflowExpressionContext, WorkflowResumeResult, WorkflowStartResult };