@acorex-platform/framework-client 0.0.10 → 0.0.14

package/fesm2022/acorex-platform-framework-client-workflow.mjs

@@ -1,18 +1,17 @@
+import { filter, Subject } from 'rxjs';
 import * as i0 from '@angular/core';
-import { Injectable, inject, InjectionToken, Optional, Inject, NgModule } from '@angular/core';
-import { Subject, filter } from 'rxjs';
-import { cloneDeep, get, set } from 'lodash-es';
-import { setSmart } from '@acorex-platform/framework-shared/core';
+import { Injectable, InjectionToken, inject, NgModule } from '@angular/core';
 import { AXPContextEvalFactory, AXPExpressionEvaluatorService, AXPDebugService, AXPDataGenerator } from '@acorex-platform/framework-client/core';
 import { AXTranslationService } from '@acorex/core/translation';
 import { AXPCommandService } from '@acorex-platform/framework-client/runtime';
 
-class AXPWorkflowError extends Error {
-    constructor(message, inner = null) {
-        super(message);
-        this.inner = inner;
-        this.name = 'AXPWorkflowError';
-    }
+function createWorkFlowEvent(type) {
+    const eventCreator = ((payload) => ({ type, payload }));
+    eventCreator.type = type;
+    return eventCreator;
+}
+function ofType(...allowedTypes) {
+    return filter((event) => allowedTypes.some((creator) => event.type === creator.type) && event.payload !== undefined);
 }
 
 class AXPWorkflowEventService {
@@ -35,387 +34,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
-class AXPWorkflowContext {
-    constructor(initialData = {}) {
-        this.variables = {};
-        this.stepOutputs = new Map();
-        this.variables = cloneDeep(initialData);
-    }
-    setVariable(key, value) {
-        setSmart(this.variables, key, value);
-    }
-    setVariables(context = {}) {
-        this.variables = { ...this.variables, ...context };
-    }
-    getVariable(key) {
-        return !key ? this.variables : get(this.variables, key);
-    }
-    setOutput(key, output) {
-        this.stepOutputs.set(key, output);
-    }
-    setOutputs(values) {
-        this.stepOutputs = new Map([...this.stepOutputs, ...values]);
-    }
-    getOutput(key) {
-        return this.stepOutputs.get(key);
-    }
-}
-class AXPWorkflowAction {
-    constructor() {
-        this.eventService = inject(AXPWorkflowEventService);
-    }
-    dispatch(event) {
-        this.eventService.dispatch(event);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowAction }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowAction, decorators: [{
-            type: Injectable
-        }] });
-class AXPWorkflowFunction {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowFunction }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
-            type: Injectable
-        }] });
-function createWorkFlowEvent(type) {
-    const eventCreator = (payload) => ({ type, payload });
-    eventCreator.type = type;
-    return eventCreator;
-}
-function ofType(...allowedTypes) {
-    return filter((event) => allowedTypes.some((type) => event.type === type.type));
-}
-
-//#region ---- Contracts barrel ----
-//#endregion
-
-class AXPWorkflowRegistryService {
-    constructor() {
-        this.functionsMap = new Map();
-        this.actionsMap = new Map();
-        this.workflowsMap = new Map();
-    }
-    registerWorkflow(name, workflow) {
-        this.workflowsMap.set(name, workflow);
-    }
-    getWorkflow(name) {
-        return this.workflowsMap.get(name);
-    }
-    registerAction(name, action) {
-        this.actionsMap.set(name, action);
-    }
-    getAction(name) {
-        return this.actionsMap.get(name);
-    }
-    registerFunction(name, func) {
-        this.functionsMap.set(name, func);
-    }
-    getFunction(name) {
-        return this.functionsMap.get(name);
-    }
-    getFunctionNames() {
-        return Array.from(this.functionsMap.keys());
-    }
-    getStep(workflowName, stepName) {
-        const workflow = this.workflowsMap.get(workflowName);
-        if (workflow) {
-            const steps = workflow.steps;
-            return steps[stepName];
-        }
-        return undefined;
-    }
-    updateStepInWorkflow(workflowName, stepName, step) {
-        const workflow = this.workflowsMap.get(workflowName);
-        if (workflow) {
-            const steps = workflow.steps;
-            if (steps[stepName]) {
-                steps[stepName] = step;
-            }
-            else {
-                throw new Error(`Step with name ${stepName} does not exist in workflow ${workflowName}.`);
-            }
-        }
-        else {
-            throw new Error(`Workflow with name ${workflowName} does not exist.`);
-        }
-    }
-    addStepToWorkflow(workflowName, stepName, step) {
-        const workflow = this.workflowsMap.get(workflowName);
-        if (workflow) {
-            const steps = workflow.steps;
-            if (!steps[stepName]) {
-                steps[stepName] = step;
-            }
-            else {
-                throw new Error(`Step with name ${stepName} already exists in workflow ${workflowName}.`);
-            }
-        }
-        else {
-            throw new Error(`Workflow with name ${workflowName} does not exist.`);
-        }
-    }
-    addAfterStep(workflowId, stepId, newStepId, newStepAction, conditionExpression) {
-        const step = this.getStep(workflowId, stepId);
-        if (step != undefined) {
-            this.addStepToWorkflow(workflowId, newStepId, {
-                action: newStepAction,
-                nextSteps: step.nextSteps,
-            });
-            this.updateStepInWorkflow(workflowId, stepId, {
-                ...step,
-                nextSteps: [
-                    {
-                        conditions: [{ type: 'SINGLE', expression: conditionExpression }],
-                        nextStepId: newStepId,
-                    },
-                ],
-            });
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AXPWorkflowDecideAction extends AXPWorkflowAction {
-    async execute(context) {
-        // its a fake action
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDecideAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDecideAction, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDecideAction, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AXPWorkflowService {
-    get events$() {
-        return this.eventService.events$;
-    }
-    constructor(registryService, injector) {
-        this.registryService = registryService;
-        this.injector = injector;
-        this.eventService = inject(AXPWorkflowEventService);
-    }
-    exists(name) {
-        return !!this.registryService.getWorkflow(name);
-    }
-    async execute(workflow, initialContext = null) {
-        // Instantiate or retrieve the workflow
-        const wk = typeof workflow === 'string' ? this.getWorkflowInstance(workflow) : workflow;
-        let currentStepId = wk.startStepId;
-        const context = initialContext instanceof AXPWorkflowContext
-            ? initialContext
-            : new AXPWorkflowContext(this.processData(initialContext) ?? {});
-        // Initialize context with initial variables
-        while (currentStepId) {
-            const currentStep = wk.steps[currentStepId];
-            if (!currentStep) {
-                throw new AXPWorkflowError(`Step '${currentStepId}' not found in the workflow steps.`);
-            }
-            // Instantiate or retrieve the action
-            const action = typeof currentStep.action === 'string' ? this.getActionInstance(currentStep.action) : currentStep.action;
-            //
-            if (currentStep.input) {
-                let inputs = {};
-                await this.processInputs(cloneDeep(currentStep.input), inputs, '', context);
-                await new Promise((resolve) => setTimeout(async () => {
-                    Object.assign(action, inputs);
-                    resolve(0);
-                }));
-            }
-            try {
-                await new Promise((resolve) => setTimeout(async () => {
-                    await action.execute(context);
-                    resolve(0);
-                }, 0));
-            }
-            catch (error) {
-                console.error(error);
-                throw new AXPWorkflowError('Workflow Error', error);
-            }
-            // Determine the next step based on the conditions
-            const nextStepInfo = await this.determineNextStep(currentStep, context);
-            if (nextStepInfo) {
-                currentStepId = nextStepInfo.nextStepId;
-            }
-            else {
-                break; // Exit the loop if no next step is determined
-            }
-        }
-        return context;
-    }
-    processData(initialContext) {
-        //TODO: update values with expressions and return new object
-        return initialContext;
-    }
-    getActionInstance(actionName) {
-        const actionType = this.registryService.getAction(actionName);
-        if (!actionType) {
-            throw new AXPWorkflowError(`Action type '${actionName}' not found in the registry.`);
-        }
-        return this.injector.get(actionType);
-    }
-    getWorkflowInstance(workflowName) {
-        const workflowType = this.registryService.getWorkflow(workflowName);
-        if (!workflowType) {
-            throw new AXPWorkflowError(`Workflow type '${workflowName}' not found in the registry.`);
-        }
-        return workflowType;
-    }
-    async determineNextStep(currentStep, context) {
-        if (!currentStep.nextSteps) {
-            return null;
-        }
-        for (const nextStep of currentStep.nextSteps) {
-            if (await this.evaluateCondition(nextStep.conditions, context)) {
-                return nextStep;
-            }
-        }
-        return null;
-    }
-    async evaluateCondition(conditions, context) {
-        if (!conditions || conditions.length === 0) {
-            return true; // If no conditions, the step proceeds
-        }
-        // Map each condition to a promise using evaluateSingleCondition
-        const conditionPromises = conditions.map((condition) => this.evaluateSingleCondition(condition, context));
-        // Wait for all promises to resolve
-        const results = await Promise.all(conditionPromises);
-        // Check if every condition is true
-        return results.every((result) => result);
-    }
-    async evaluateSingleCondition(condition, context) {
-        switch (condition.type) {
-            case 'SINGLE':
-                return (!condition.expression ? true : await this.evaluateExpression(condition.expression, context));
-            case 'AND':
-                // Evaluate all conditions with 'AND' logic
-                const andConditions = condition.conditions ?? [];
-                const andResults = await Promise.all(andConditions.map((cond) => this.evaluateSingleCondition(cond, context)));
-                return andResults.every((result) => result);
-            case 'OR':
-                // Evaluate all conditions with 'OR' logic
-                const orConditions = condition.conditions ?? [];
-                const orResults = await Promise.all(orConditions.map((cond) => this.evaluateSingleCondition(cond, context)));
-                return orResults.some((result) => result);
-            default:
-                throw new AXPWorkflowError(`Unsupported condition type: ${condition.type}`);
-        }
-    }
-    //TODO: return any and recursively update object, update scopes
-    async evaluateExpression(templateExpression, context) {
-        try {
-            let expression = '';
-            if (typeof templateExpression === 'string' && templateExpression.trim().includes('{{')) {
-                const expressionMatch = templateExpression.match(/\{\{\s*(.*?)\s*\}\}/);
-                if (!expressionMatch) {
-                    throw Error(`No valid expression found in "${templateExpression}"`);
-                }
-                expression = expressionMatch[1];
-            }
-            else {
-                expression = templateExpression;
-            }
-            // Create a scope that includes context and registered functions
-            const scope = { context, ...this.createFunctionScope() };
-            // Evaluating the expression within the created scope
-            const sandbox = new Function('scope', `return (async function() { with (scope) { return ${expression}; } })();`);
-            const result = await sandbox(scope);
-            return result;
-        }
-        catch (error) {
-            console.error('Error evaluating expression:', error);
-            return false;
-        }
-    }
-    async processInputs(obj, inputs, pathPrefix = '', context = {}) {
-        if (!obj) {
-            return;
-        }
-        for await (const i of Object.entries(obj)) {
-            const key = i[0];
-            const value = i[1];
-            const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;
-            if (typeof value === 'string' && value.trim().includes('{{')) {
-                const expValue = await this.evaluateExpression(value, context);
-                set(inputs, currentPath, expValue);
-            }
-            else if (typeof value === 'object' &&
-                value !== null &&
-                (value.constructor === Object || Array.isArray(value))) {
-                // Recursively handle nested objects
-                this.processInputs(value, inputs, currentPath, context);
-            }
-            else {
-                // Apply static values directly
-                set(inputs, currentPath, value);
-            }
-        }
-    }
-    createFunctionScope() {
-        const scope = {};
-        this.registryService.getFunctionNames().forEach((name) => {
-            scope[name] = this.getFunctionInstance(name).execute;
-        });
-        return { methods: { scope } };
-    }
-    getFunctionInstance(functionName) {
-        const functionType = this.registryService.getFunction(functionName);
-        if (!functionType) {
-            throw new AXPWorkflowError(`Function type '${functionName}' not found in the registry.`);
-        }
-        return this.injector.get(functionType);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowService, deps: [{ token: AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: AXPWorkflowRegistryService }, { type: i0.Injector }] });
-
-class AXPStartWorkflowAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.workflowService = inject(AXPWorkflowService);
-    }
-    async execute(context) {
-        //console.log("start WK current context", context);
-        //console.log("start WK input context", this.context);
-        if (this.context)
-            context.setVariables(this.context);
-        //console.log("start WK merged context", context);
-        try {
-            await this.workflowService.execute(this.workflow, context);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
 const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER', {
     factory: () => [],
 });
@@ -596,11 +214,21 @@ class AXPActivityDefinitionService {
      * Used by activity selector UIs (e.g. automation command configurator).
      */
     async getAllActivities() {
-        const categories = await this.getCategories(undefined);
         const all = [];
-        for (const cat of categories) {
-            const activities = await this.getActivitiesByCategoryId(cat.id);
+        const visited = new Set();
+        const queue = await this.getCategories(undefined);
+        while (queue.length > 0) {
+            const category = queue.shift();
+            if (visited.has(category.id)) {
+                continue;
+            }
+            visited.add(category.id);
+            const activities = await this.getActivitiesByCategoryId(category.id);
             all.push(...activities);
+            if (category.childrenCount > 0) {
+                const children = await this.getCategories(category.id);
+                queue.push(...children);
+            }
         }
         return all;
     }
@@ -2713,89 +2341,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
         }] });
 
 class AXPWorkflowModule {
-    static forRoot(config) {
+    static forRoot() {
         return {
             ngModule: AXPWorkflowModule,
-            providers: [
-                {
-                    provide: 'AXPWorkflowModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
-                        registry.registerAction('decide', AXPWorkflowDecideAction);
-                        //
-                        if (config?.functions) {
-                            for (const [key, type] of Object.entries(config.functions)) {
-                                registry.registerFunction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.actions) {
-                            for (const [key, type] of Object.entries(config.actions)) {
-                                registry.registerAction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.workflows) {
-                            for (const [key, type] of Object.entries(config.workflows)) {
-                                registry.registerWorkflow(key, type);
-                            }
-                        }
-                    },
-                    deps: [AXPWorkflowRegistryService],
-                    multi: true,
-                },
-                ...Object.values(config?.actions ?? { AXPStartWorkflowAction }),
-                ...Object.values(config?.functions ?? {}),
-            ],
         };
     }
-    static forChild(config) {
-        return {
-            ngModule: AXPWorkflowModule,
-            providers: [
-                // Built-in activities are already registered in forRoot via @NgModule providers
-                // No need to register again in forChild
-                {
-                    provide: 'AXPWorkflowModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
-                        registry.registerAction('decide', AXPWorkflowDecideAction);
-                        //
-                        if (config?.functions) {
-                            for (const [key, type] of Object.entries(config.functions)) {
-                                registry.registerFunction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.actions) {
-                            for (const [key, type] of Object.entries(config.actions)) {
-                                registry.registerAction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.workflows) {
-                            for (const [key, type] of Object.entries(config.workflows)) {
-                                registry.registerWorkflow(key, type);
-                            }
-                        }
-                    },
-                    deps: [AXPWorkflowRegistryService],
-                    multi: true,
-                },
-                ...Object.values(config?.actions ?? {}),
-                ...Object.values(config?.functions ?? {}),
-            ],
-        };
-    }
-    /**
-     * @ignore
-     */
-    constructor(instances) {
-        instances?.forEach((f) => {
-            f();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, providers: [
             AXPWorkflowLocalEngine,
@@ -2809,9 +2360,6 @@ class AXPWorkflowModule {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [],
-                    exports: [],
-                    declarations: [],
                     providers: [
                         AXPWorkflowLocalEngine,
                         {
@@ -2821,16 +2369,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                         AXPWorkflowManager,
                     ],
                 }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: ['AXPWorkflowModuleFactory']
-                }] }] });
+        }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowEngineError, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_ERROR_CODES, AXP_WORKFLOW_PROVIDER, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES, ActivityExecutor, WorkflowExpressionScopeService, axpIsWorkflowInlineFrontendTask, axpIsWorkflowInteractiveFrontendTask, axpIsWorkflowTaskBoardActivityType, axpResolveWorkflowContinuationBeforeInteractive, axpShouldOfferBeforeInteractiveFlow, axpShouldOfferWorkflowContinuationAfterStep, axpShouldSkipBeforeInteractiveFromMetadata, createWorkFlowEvent, getWorkflowEngineErrorCode, getWorkflowEngineErrorInfo, isWorkflowContinuationSuppressed, ofType };
+export { AXPActivityDefinitionService, AXPWorkflowDefinitionService, AXPWorkflowEngineError, AXPWorkflowEventService, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_ERROR_CODES, AXP_WORKFLOW_PROVIDER, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES, ActivityExecutor, WorkflowExpressionScopeService, axpIsWorkflowInlineFrontendTask, axpIsWorkflowInteractiveFrontendTask, axpIsWorkflowTaskBoardActivityType, axpResolveWorkflowContinuationBeforeInteractive, axpShouldOfferBeforeInteractiveFlow, axpShouldOfferWorkflowContinuationAfterStep, axpShouldSkipBeforeInteractiveFromMetadata, createWorkFlowEvent, getWorkflowEngineErrorCode, getWorkflowEngineErrorInfo, isWorkflowContinuationSuppressed, ofType };
 //# sourceMappingURL=acorex-platform-framework-client-workflow.mjs.map