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

package/workflow/index.d.ts

@@ -629,99 +629,11 @@ interface AXPWorkflowDefinitionLoader {
      */
     getAllNames?(): Promise<string[]>;
 }
-/**
- * Workflow definition preloader interface.
- * Implement this to provide a list of workflow definitions that should be preloaded.
- */
-interface AXPWorkflowDefinitionPreloader {
-    /**
-     * Get list of workflow definition IDs to preload.
-     * @returns Array of definition IDs
-     */
-    preload(): string[];
-}
 /**
  * Injection token for workflow definition loaders.
  * Multiple loaders can be provided (multi: true).
  */
 declare const AXP_WORKFLOW_DEFINITION_LOADER: InjectionToken<AXPWorkflowDefinitionLoader>;
-/**
- * Resolver service for workflow definitions.
- * Aggregates all registered loaders and resolves workflow definitions.
- */
-declare class AXPWorkflowDefinitionResolver {
-    private loaders;
-    /**
-     * Get workflow definition by name (unique key).
-     * Tries all registered loaders until one returns a definition.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
-    /**
-     * Get all available workflow names from all loaders.
-     * @returns Array of unique workflow names
-     */
-    getAllNames(): Promise<string[]>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowDefinitionResolver, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionResolver>;
-}
-
-/**
- * Registry service for workflow definitions.
- * Caches loaded definitions and provides change notifications.
- */
-declare class AXPWorkflowDefinitionRegistryService {
-    private resolver;
-    private cache;
-    private onChanged;
-    /**
-     * Observable for workflow definition changes.
-     */
-    get onChanged$(): rxjs.Observable<{
-        name: string;
-        action: "registered" | "updated" | "removed";
-    }>;
-    /**
-     * Get workflow definition by name (unique key).
-     * Uses cache if available, otherwise loads from resolver.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    get(name: string): Promise<AXPWorkflowDefinition | null>;
-    /**
-     * Register a workflow definition in the cache.
-     * @param definition - The workflow definition to register
-     */
-    register(definition: AXPWorkflowDefinition): void;
-    /**
-     * Update a workflow definition in the cache.
-     * @param definition - The updated workflow definition
-     */
-    update(definition: AXPWorkflowDefinition): void;
-    /**
-     * Remove a workflow definition from the cache.
-     * @param name - The workflow name to remove
-     */
-    remove(name: string): void;
-    /**
-     * Clear all cached workflow definitions.
-     */
-    clear(): void;
-    /**
-     * Check if a workflow definition is cached.
-     * @param definitionId - The workflow definition ID
-     * @returns True if cached, false otherwise
-     */
-    has(definitionId: string): boolean;
-    /**
-     * Get all cached workflow definition IDs.
-     * @returns Array of definition IDs (only those that have been loaded)
-     */
-    getAllIds(): string[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowDefinitionRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionRegistryService>;
-}
 
 /**
  * Workflow status.
@@ -1379,10 +1291,6 @@ declare class AXPActivityDefinitionService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityDefinitionService>;
 }
 
-/**
- * Types and interfaces for Workflow Execution Service.
- */
-
 /**
  * Represents a workflow task that needs to be executed.
  * Inspired by Temporal's Activity Tasks and Camunda's External Tasks.
@@ -1421,9 +1329,9 @@ interface AXPWorkflowTask {
     config?: Record<string, any>;
 }
 /**
- * Request to start a workflow execution.
+ * Request to start a workflow instance.
  */
-interface AXPStartWorkflowExecutionRequest {
+interface AXPStartWorkflowRequest {
     /**
      * Workflow ID to execute.
      */
@@ -1434,17 +1342,17 @@ interface AXPStartWorkflowExecutionRequest {
     input: Record<string, any>;
 }
 /**
- * Response after starting workflow execution.
+ * Response after starting workflow instance.
  */
-interface AXPStartWorkflowExecutionResponse {
+interface AXPStartWorkflowResponse {
     /**
-     * Unique execution ID for this workflow run.
+     * Unique instance ID for this workflow run.
      */
-    executionId: string;
+    instanceId: string;
     /**
      * Current workflow state.
      */
-    state: AXPWorkflowExecutionState;
+    state: AXPWorkflowInstanceState;
     /**
      * First task to execute (determined by backend).
      * Client should execute this task based on executionMode.
@@ -1454,11 +1362,11 @@ interface AXPStartWorkflowExecutionResponse {
 /**
  * Request to resume a suspended workflow.
  */
-interface AXPResumeWorkflowExecutionRequest {
+interface AXPResumeWorkflowRequest {
     /**
-     * Execution ID.
+     * Instance ID.
      */
-    executionId: string;
+    instanceId: string;
     /**
      * Step ID that was waiting for user input.
      */
@@ -1480,7 +1388,7 @@ interface AXPResumeWorkflowExecutionRequest {
 /**
  * Response after resuming workflow.
  */
-interface AXPResumeWorkflowExecutionResponse {
+interface AXPResumeWorkflowResponse {
     /**
      * Activity execution output.
      */
@@ -1496,49 +1404,31 @@ interface AXPResumeWorkflowExecutionResponse {
     /**
      * Updated workflow state.
      */
-    state: AXPWorkflowExecutionState;
+    state: AXPWorkflowInstanceState;
 }
 /**
- * Request to get workflow execution state.
+ * Request to get workflow instance state.
  */
-interface AXPGetWorkflowExecutionStateRequest {
+interface AXPGetWorkflowStateRequest {
     /**
-     * Execution ID.
+     * Instance ID.
      */
-    executionId: string;
+    instanceId: string;
 }
 /**
- * Request to get workflow definition.
+ * Workflow instance state (managed by backend, cached in client).
  */
-interface AXPGetWorkflowDefinitionRequest {
+interface AXPWorkflowInstanceState {
     /**
-     * Workflow ID or definition ID.
-     */
-    workflowId: string;
-}
-/**
- * Response with workflow definition.
- */
-interface AXPGetWorkflowDefinitionResponse {
-    /**
-     * Workflow definition.
-     */
-    workflow: AXPWorkflowDefinition;
-}
-/**
- * Workflow execution state (managed by backend, cached in client).
- */
-interface AXPWorkflowExecutionState {
-    /**
-     * Unique execution ID.
+     * Unique instance ID.
      */
-    executionId: string;
+    instanceId: string;
     /**
      * Workflow ID.
      */
     workflowId: string;
     /**
-     * Current execution status.
+     * Current instance status.
      */
     status: 'running' | 'completed' | 'suspended' | 'error';
     /**
@@ -1564,245 +1454,566 @@ interface AXPWorkflowExecutionState {
 }
 
 /**
- * Workflow execution result.
+ * Interface for workflow engine operations.
+ */
+interface AXPWorkflowEngine {
+    /**
+     * 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
+     *
+     */
+    start(request: AXPStartWorkflowRequest): Promise<AXPStartWorkflowResponse>;
+    /**
+     * 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
+     *
+     */
+    resume(request: AXPResumeWorkflowRequest): Promise<AXPResumeWorkflowResponse>;
+    /**
+     * Get current workflow instance state.
+     *
+     * Retrieves current state of a workflow instance from backend.
+     *
+     * @param request - Get state request
+     * @returns Current workflow instance state
+     *
+     */
+    getState(request: AXPGetWorkflowStateRequest): Promise<AXPWorkflowInstanceState>;
+}
+/**
+ * Injection token for workflow engine.
+ * Default implementation is AXPWorkflowLocalEngine.
+ */
+declare const AXP_WORKFLOW_ENGINE: InjectionToken<AXPWorkflowEngine>;
+
+/**
+ * Result of executing a frontend task.
+ */
+interface FrontendTaskExecutionResult {
+    /**
+     * Task execution output.
+     */
+    output: any;
+    /**
+     * Task execution outcome (e.g., 'Done', 'Confirmed', 'Cancelled', 'Failed').
+     */
+    outcome: string;
+}
+/**
+ * Service responsible for executing frontend workflow tasks.
+ *
+ * This service handles the execution of frontend or hybrid tasks using
+ * the command infrastructure. It translates command results into
+ * workflow-compatible output and outcome format.
+ *
+ * This service is replaceable per platform and contains all execution logic.
+ */
+declare class FrontendTaskExecutor {
+    private readonly commandService;
+    /**
+     * Execute a frontend workflow task.
+     *
+     * Only executes tasks with executionMode 'frontend' or 'both'.
+     * Backend tasks should not be passed to this executor.
+     *
+     * @param task - Task to execute
+     * @returns Execution result with output and outcome
+     *
+     * @throws Error if task is not a frontend task
+     */
+    execute(task: AXPWorkflowTask): Promise<FrontendTaskExecutionResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FrontendTaskExecutor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FrontendTaskExecutor>;
+}
+
+/**
+ * Result of starting a workflow.
  */
-interface WorkflowExecutionResult {
+interface WorkflowStartResult {
+    /**
+     * Whether the operation succeeded.
+     */
+    success: boolean;
+    /**
+     * Workflow instance ID.
+     */
+    instanceId?: string;
+    /**
+     * Initial workflow state.
+     */
+    state?: AXPWorkflowInstanceState;
+    /**
+     * First task to execute (if any).
+     */
+    nextTask?: AXPWorkflowTask | null;
+    /**
+     * Workflow output (if completed immediately).
+     */
+    output?: any;
+    /**
+     * Error message (if failed).
+     */
+    error?: string;
+}
+/**
+ * Result of completing a task.
+ */
+interface WorkflowCompleteResult {
+    /**
+     * Whether the operation succeeded.
+     */
     success: boolean;
+    /**
+     * Workflow instance ID.
+     */
+    instanceId: string;
+    /**
+     * Updated workflow state.
+     */
+    state?: AXPWorkflowInstanceState;
+    /**
+     * Next task to execute (if any).
+     */
+    nextTask?: AXPWorkflowTask | null;
+    /**
+     * Workflow output (if completed).
+     */
     output?: any;
+    /**
+     * Error message (if failed).
+     */
     error?: string;
+}
+/**
+ * Result of resuming a workflow.
+ */
+interface WorkflowResumeResult {
+    /**
+     * Whether the operation succeeded.
+     */
+    success: boolean;
+    /**
+     * Workflow instance ID.
+     */
+    instanceId: string;
+    /**
+     * Updated workflow state.
+     */
+    state?: AXPWorkflowInstanceState;
+    /**
+     * Next task to execute (if any).
+     */
     nextTask?: AXPWorkflowTask | null;
-    executionId?: string;
-    state?: AXPWorkflowExecutionState;
+    /**
+     * Workflow output (if completed).
+     */
+    output?: any;
+    /**
+     * Error message (if failed).
+     */
+    error?: string;
 }
 /**
- * Production Workflow Coordinator.
+ * Workflow Manager - Facade for workflow lifecycle orchestration.
+ *
+ * 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.
  *
- * 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
+ * Responsibilities:
+ * - Orchestrate workflow lifecycle (start, execute, complete, resume)
+ * - Delegate execution to FrontendTaskExecutor
+ * - Cache workflow state in memory
+ * - Expose a stable API for UI
  *
+ * Rules:
+ * - No HTTP calls (delegates to AXPWorkflowEngine)
+ * - No CommandBus / Command execution (delegates to FrontendTaskExecutor)
+ * - 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 frontendTaskExecutor;
     /**
      * 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 FrontendTaskExecutor for actual execution.
+     * Only executes tasks with executionMode 'frontend' or 'both'.
      *
      * @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<FrontendTaskExecutionResult>;
     /**
      * 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>;
-    /**
-     * Get workflow execution state (from cache or backend).
-     */
-    getWorkflowState(executionId: string): Promise<AXPWorkflowExecutionState | null>;
+    resume(instanceId: string, stepId: string, outcome: string, userInput?: any, taskToken?: string): Promise<WorkflowResumeResult>;
     /**
-     * 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.
+ * Local engine implementation that manages workflow progression and state.
  *
- * This service handles communication with backend for workflow execution.
+ * 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
  *
- * Implementation should be provided in connectivity layer:
- * - Mock implementation: @acorex/connectivity/mock
- * - API implementation: @acorex/connectivity/api
+ * Execution of frontend tasks is handled by AXPWorkflowManager via FrontendTaskExecutor.
+ * This engine only manages workflow progression and state storage.
  *
- * @example
- * ```typescript
- * // In connectivity/mock
- * @Injectable()
- * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
- *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
- *     // Mock implementation
- *   }
- * }
- *
- * // In connectivity/api
- * @Injectable()
- * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
- *   constructor(private http: HttpClient) {}
- *
- *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
- *     return firstValueFrom(
- *       this.http.post<AXPStartWorkflowExecutionResponse>(
- *         `${this.config.baseUrl}/api/workflows/${request.workflowId}/start`,
- *         { input: request.input }
- *       )
- *     );
- *   }
- * }
- * ```
+ * 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 definitionLoaders;
+    constructor(definitionLoaders?: AXPWorkflowDefinitionLoader[] | null);
     /**
-     * Start a new workflow execution.
+     * In-memory storage for workflow instances.
+     * Key: instanceId
+     * Value: LocalWorkflowState
+     */
+    private instances;
+    /**
+     * Task token storage for secure resume operations.
+     * Key: taskToken
+     * Value: { instanceId, activityId }
+     */
+    private taskTokens;
+    /**
+     * Start a new workflow instance.
      *
-     * Creates a new workflow execution instance in backend and returns execution ID.
+     * Creates an in-memory workflow instance and progresses it.
+     * Frontend/both activities are returned as pendingTask for external execution.
+     * Backend activities are skipped.
+     */
+    start(request: AXPStartWorkflowRequest): Promise<AXPStartWorkflowResponse>;
+    /**
+     * Resume a suspended workflow instance.
      *
-     * @param request - Start execution request
-     * @returns Execution response with executionId and initial state
+     * 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 loaders.
+     */
+    private getDefinition;
+    /**
+     * Progress workflow steps starting from the current position.
      *
-     * @example
-     * ```typescript
-     * const response = await workflowExecutionService.startExecution({
-     *   workflowId: 'my-workflow',
-     *   input: { userId: '123', action: 'create' }
-     * });
+     * For frontend/both activities: returns task immediately (suspends workflow).
+     * For backend activities: skips and continues.
      *
-     * console.log('Execution ID:', response.executionId);
-     * console.log('Initial State:', response.state);
-     * ```
+     * Returns the next pending task (if frontend activity found) or null (if completed).
+     */
+    private executeWorkflowSteps;
+    /**
+     * Get next activity ID based on connections and outcomes.
+     */
+    private getNextActivityId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowLocalEngine, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowLocalEngine>;
+}
+
+/**
+ * Workflow 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 workflows count
+ * - totalChildren?: number       - Total nested categories (optional, for analytics)
+ * - totalItems?: number          - Total workflows in tree (optional, for analytics)
+ */
+interface AXPWorkflowCategory extends AXPCategoryEntity {
+}
+/**
+ * Workflow Definition - Metadata for UI and tooling.
+ * Contains all metadata needed for displaying workflows in toolbox and designer.
+ * The `name` property is used as the workflow identifier.
+ */
+interface AXPWorkflowDefinitionMetadata {
+    /**
+     * Workflow name - used as unique identifier.
+     * This is the unique identifier for the workflow.
+     */
+    name: string;
+    /**
+     * Display name for UI.
+     */
+    title?: string;
+    /**
+     * Description of what the workflow does.
+     */
+    description?: string;
+    /**
+     * Category for grouping in toolbox.
+     */
+    category?: string;
+    /**
+     * Icon name or class.
+     */
+    icon?: string;
+    /**
+     * Whether this workflow is browsable in the toolbox.
+     * Default: true
      */
-    abstract startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse>;
+    isBrowsable?: boolean;
+    /**
+     * Version number.
+     */
+    version?: number;
+    /**
+     * Whether this workflow is published.
+     */
+    isPublished?: boolean;
+}
+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 metadata array
+     */
+    getList(categoryId: string): Promise<AXPWorkflowDefinitionMetadata[]>;
+    /**
+     * Get workflow definition metadata by name (unique identifier).
+     * @param name - Workflow name (unique identifier)
+     * @returns Promise of workflow definition metadata or undefined if not found
+     */
+    getById(name: string): Promise<AXPWorkflowDefinitionMetadata | undefined>;
+}
+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>;
+}
+
+/**
+ * Optimized Workflow Definition Service
+ *
+ * Manages workflow definitions (metadata) for UI and tooling.
+ * Similar to AXPActivityDefinitionService - 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 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;
     /**
-     * Resume a suspended workflow execution.
+     * Get categories by parentId with aggressive caching
      *
-     * Resumes workflow execution after user interaction (e.g., after show-dialog).
+     * Optimization: Returns cached result immediately if available,
+     * preventing unnecessary API calls during navigation
      *
-     * @param request - Resume execution request
-     * @returns Resume response with next step and updated state
+     * @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
      *
-     * @example
-     * ```typescript
-     * const response = await workflowExecutionService.resumeExecution({
-     *   executionId: 'exec-123',
-     *   stepId: 'step-dialog-1',
-     *   taskToken: 'sec-task-token',
-     *   outcome: 'Confirmed',
-     *   userInput: { confirmed: true }
-     * });
+     * Optimization: Uses Map for instant retrieval, falls back to
+     * searching cache, then providers if not found
+     */
+    getCategoryById(categoryId: string): Promise<AXPWorkflowCategory | undefined>;
+    /**
+     * Get category path from root to specified category
      *
-     * console.log('Next Step:', response.nextStep);
-     * console.log('Updated State:', response.state);
-     * ```
+     * Optimization: Builds path using cached categories only
      */
-    abstract resumeExecution(request: AXPResumeWorkflowExecutionRequest): Promise<AXPResumeWorkflowExecutionResponse>;
+    getCategoriesPathById(categoryId: string): Promise<AXPWorkflowCategory[]>;
     /**
-     * Get current workflow execution state.
+     * Get workflow definitions for a category with smart caching
      *
-     * Retrieves current state of a workflow execution from backend.
+     * 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 request - Get state request
-     * @returns Current workflow execution state
+     * @param categoryId - Category ID to get workflow definitions from
+     * @returns Array of workflow definition metadata
+     */
+    getWorkflowsByCategoryId(categoryId: string): Promise<AXPWorkflowDefinitionMetadata[]>;
+    /**
+     * Get single workflow definition metadata by name with O(1) lookup
      *
-     * @example
-     * ```typescript
-     * const state = await workflowExecutionService.getExecutionState({
-     *   executionId: 'exec-123'
-     * });
+     * Optimization: Uses Map for instant retrieval
      *
-     * console.log('Status:', state.status);
-     * console.log('Variables:', state.variables);
-     * ```
+     * @param name - Workflow name (unique identifier)
+     * @returns Workflow definition metadata or undefined if not found
      */
-    abstract getExecutionState(request: AXPGetWorkflowExecutionStateRequest): Promise<AXPWorkflowExecutionState>;
+    getWorkflowByName(name: string): Promise<AXPWorkflowDefinitionMetadata | undefined>;
     /**
-     * Get workflow definition by ID.
+     * Get category ID containing a specific workflow definition
      *
-     * Retrieves workflow definition from backend.
+     * Optimization: Searches cache first, loads on-demand if needed
+     */
+    getCategoryIdByWorkflowName(workflowName: string): Promise<string | undefined>;
+    /**
+     * Get category path for a workflow
+     */
+    getCategoriesPathByWorkflowName(workflowName: string): Promise<AXPWorkflowCategory[]>;
+    /**
+     * Load categories from providers and cache results
      *
-     * @param request - Get workflow definition request
-     * @returns Workflow definition in executable format
+     * Optimization: Tracks provider ownership to avoid unnecessary API calls
+     * - For root (parentId = undefined): Query ALL providers
+     * - For children: Only query the provider that owns the parent
+     */
+    private loadCategoriesFromProviders;
+    /**
+     * Get the provider index that owns a specific category
      *
-     * @example
-     * ```typescript
-     * const response = await workflowExecutionService.getWorkflowDefinition({
-     *   workflowId: 'my-workflow'
-     * });
+     * @returns Array with provider index, or null if ownership unknown (query all)
+     */
+    private getProviderIndexForCategory;
+    /**
+     * Load workflow definitions from providers and cache results
      *
-     * console.log('Workflow:', response.workflow);
-     * ```
+     * Optimization: Only queries the provider that owns the category
+     * Uses provider INDEX to match category provider with workflow provider
+     */
+    private loadWorkflowsFromProviders;
+    /**
+     * Load single workflow definition from providers and cache result
+     */
+    private loadWorkflowFromProviders;
+    /**
+     * Breadth-first search through category hierarchy
+     */
+    private searchCategoryInHierarchy;
+    /**
+     * Check if category has children (uses cached count)
+     */
+    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
      */
-    abstract getWorkflowDefinition(request: AXPGetWorkflowDefinitionRequest): Promise<AXPGetWorkflowDefinitionResponse>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowExecutionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowExecutionService>;
+    clearWorkflowsCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowDefinitionService>;
 }
 
-export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, WorkflowCoordinator, createWorkFlowEvent, ofType };
-export type { AXPActivity, AXPActivityCategory, AXPActivityCategoryProvider, AXPActivityCategoryProviderToken, AXPActivityDefinition, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderToken, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPCustomProperties, AXPEndpoint, AXPExceptionState, AXPExpression, AXPFlowchart, AXPGetWorkflowDefinitionRequest, AXPGetWorkflowDefinitionResponse, AXPGetWorkflowExecutionStateRequest, AXPInputValue, AXPMetadata, AXPOutputValue, AXPPosition, AXPResumeWorkflowExecutionRequest, AXPResumeWorkflowExecutionResponse, AXPStartWorkflowExecutionRequest, AXPStartWorkflowExecutionResponse, AXPStoredWorkflowDefinition, AXPVariableDefinition, AXPVariableModel, AXPVersionedEntity, AXPWorkflow, AXPWorkflowActionInput, AXPActivity$1 as AXPWorkflowActivity, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionPreloader, AXPWorkflowEvent, AXPWorkflowExecutionState, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityPropertyWidget, InputDescriptor, OutputDescriptor, WorkflowExecutionResult };
+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_DEFINITION_LOADER, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_PROVIDER, FrontendTaskExecutor, createWorkFlowEvent, ofType };
+export type { AXPActivity, AXPActivityCategory, AXPActivityCategoryProvider, AXPActivityCategoryProviderToken, AXPActivityDefinition, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityProvider, AXPActivityProviderToken, AXPActivityStatus, AXPActivityVariable, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPCustomProperties, AXPEndpoint, AXPExceptionState, AXPExpression, AXPFlowchart, AXPGetWorkflowStateRequest, AXPInputValue, AXPMetadata, AXPOutputValue, AXPPosition, AXPResumeWorkflowRequest, AXPResumeWorkflowResponse, AXPStartWorkflowRequest, AXPStartWorkflowResponse, AXPStoredWorkflowDefinition, AXPVariableDefinition, AXPVariableModel, AXPVersionedEntity, AXPWorkflow, AXPWorkflowActionInput, AXPActivity$1 as AXPWorkflowActivity, AXPWorkflowCategory, AXPWorkflowCategoryProvider, AXPWorkflowCategoryProviderToken, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowDefinition, AXPWorkflowDefinitionJson, AXPWorkflowDefinitionLoader, AXPWorkflowDefinitionMetadata, AXPWorkflowEngine, AXPWorkflowEvent, AXPWorkflowFaultState, AXPWorkflowInputDefinition, AXPWorkflowInstance, AXPWorkflowInstanceState, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowOptions, AXPWorkflowOutputDefinition, AXPWorkflowProvider, AXPWorkflowProviderToken, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowStep, AXPWorkflowSubStatus, AXPWorkflowTask, ActivityPropertyWidget, FrontendTaskExecutionResult, InputDescriptor, OutputDescriptor, WorkflowCompleteResult, WorkflowResumeResult, WorkflowStartResult };