@serverlessworkflow/sdk 1.0.0 → 1.0.1

package/esm/index.esm.js

@@ -133,6 +133,17 @@ function __extends(d, b) {
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
 
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -18089,7 +18100,7 @@ var _ExternalScript = ExternalScript;
  * Represents a FlowDirective with methods for validation and normalization.
  * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
  */
-var FlowDirective = /** @class */ (function (_super) {
+var FlowDirective$1 = /** @class */ (function (_super) {
     __extends(FlowDirective, _super);
     /**
      * Instanciates a new instance of the FlowDirective class.
@@ -18124,7 +18135,7 @@ var FlowDirective = /** @class */ (function (_super) {
     };
     return FlowDirective;
 }(ObjectHydrator));
-var _FlowDirective = FlowDirective;
+var _FlowDirective = FlowDirective$1;
 
 /*
  * Copyright 2021-Present The Serverless Workflow Specification Authors
@@ -24814,6 +24825,541 @@ var dumper = {
 var load                = loader.load;
 var dump                = dumper.dump;
 
+var entrySuffix = '-entry-node';
+var exitSuffix = '-exit-node';
+var rooId = 'root';
+var doReference = '/do';
+var forReference = '/for';
+var catchReference = '/catch';
+var branchReference = '/fork/branches';
+var tryReference = '/try';
+/**
+ * Enumeration of possible node types in a graph.
+ */
+var GraphNodeType;
+(function (GraphNodeType) {
+    GraphNodeType["Root"] = "root";
+    GraphNodeType["Start"] = "start";
+    GraphNodeType["End"] = "end";
+    GraphNodeType["Entry"] = "entry";
+    GraphNodeType["Exit"] = "exit";
+    GraphNodeType["Call"] = "call";
+    GraphNodeType["Catch"] = "catch";
+    GraphNodeType["Do"] = "do";
+    GraphNodeType["Emit"] = "emit";
+    GraphNodeType["For"] = "for";
+    GraphNodeType["Fork"] = "fork";
+    GraphNodeType["Listen"] = "listen";
+    GraphNodeType["Raise"] = "raise";
+    GraphNodeType["Run"] = "run";
+    GraphNodeType["Set"] = "set";
+    GraphNodeType["Switch"] = "switch";
+    GraphNodeType["Try"] = "try";
+    GraphNodeType["TryCatch"] = "try-catch";
+    GraphNodeType["Wait"] = "wait";
+})(GraphNodeType || (GraphNodeType = {}));
+/**
+ * Enumeration of possible workflow flow directives.
+ */
+var FlowDirective;
+(function (FlowDirective) {
+    FlowDirective["Exit"] = "exit";
+    FlowDirective["End"] = "end";
+    FlowDirective["Continue"] = "continue";
+})(FlowDirective || (FlowDirective = {}));
+/**
+ * Converts an array of TaskItem objects into a Map for easy lookup.
+ *
+ * @param tasksList An array of TaskItem objects.
+ * @returns A map where keys are task names and values are Task objects.
+ */
+function mapTasks(tasksList) {
+    return (tasksList || []).reduce(function (acc, item) {
+        var _a = Object.entries(item)[0], key = _a[0], task = _a[1];
+        acc.set(key, task);
+        return acc;
+    }, new Map());
+}
+/**
+ * Initializes a graph with default entry and exit nodes.
+ *
+ * @param type The type of the graph node.
+ * @param id Unique identifier for the graph.
+ * @param label Optional label for the graph.
+ * @param parent Optional parent graph if this is a subgraph.
+ * @returns A newly created Graph instance.
+ */
+function initGraph(type, id, label, parent) {
+    if (id === void 0) { id = rooId; }
+    if (label === void 0) { label = undefined; }
+    if (parent === void 0) { parent = undefined; }
+    var entryNode = {
+        type: id === rooId ? GraphNodeType.Start : GraphNodeType.Entry,
+        id: "".concat(id).concat(entrySuffix),
+    };
+    var exitNode = {
+        type: id === rooId ? GraphNodeType.End : GraphNodeType.Exit,
+        id: "".concat(id).concat(exitSuffix),
+    };
+    var graph = {
+        id: id,
+        label: label,
+        type: type,
+        parent: parent,
+        entryNode: entryNode,
+        exitNode: exitNode,
+        nodes: [entryNode, exitNode],
+        edges: [],
+    };
+    if (parent)
+        parent.nodes.push(graph);
+    return graph;
+}
+/**
+ * Constructs a graph representation based on the given workflow.
+ *
+ * @param workflow The workflow to be converted into a graph structure.
+ * @returns A graph representation of the workflow.
+ */
+function buildGraph(workflow) {
+    var graph = initGraph(GraphNodeType.Root);
+    buildTransitions(graph.entryNode, {
+        graph: graph,
+        reference: doReference,
+        taskList: mapTasks(workflow.do),
+        taskReference: doReference,
+    });
+    return graph;
+}
+/**
+ * Gets the next task to be executed in the workflow
+ * @param tasksList The list of task to resolve the next task from
+ * @param taskName The current task name, if any
+ * @param transition A specific transition, if any
+ * @returns
+ */
+function getNextTask(tasksList, taskName, transition) {
+    if (taskName === void 0) { taskName = undefined; }
+    if (transition === void 0) { transition = undefined; }
+    if (!(tasksList === null || tasksList === void 0 ? void 0 : tasksList.size))
+        throw new Error('The task list cannot be empty. No tasks list to get the next task from.');
+    var currentTask = tasksList.get(taskName || '');
+    transition = transition || (currentTask === null || currentTask === void 0 ? void 0 : currentTask.then) || '';
+    if (transition == FlowDirective.End || transition == FlowDirective.Exit) {
+        return {
+            name: transition,
+            index: -1,
+        };
+    }
+    var index = 0;
+    if (transition && transition != FlowDirective.Continue) {
+        index = Array.from(tasksList.keys()).indexOf(transition);
+    }
+    else if (currentTask) {
+        index = Array.from(tasksList.values()).indexOf(currentTask) + 1;
+        if (index >= tasksList.size) {
+            return {
+                name: FlowDirective.End,
+                index: -1,
+            };
+        }
+    }
+    var taskEntry = Array.from(tasksList.entries())[index];
+    return {
+        index: index,
+        name: taskEntry[0],
+        task: taskEntry[1],
+    };
+}
+/**
+ * Builds the provided transition from the source node
+ * @param sourceNode The node to build the transition from
+ * @param transition The transition to follow
+ * @param context The context in which the transition is built
+ */
+function buildTransition(sourceNode, transition, context) {
+    var exitAnchor = sourceNode.exitNode || sourceNode;
+    if (transition.index != -1) {
+        var destinationNode = buildTaskNode(__assign(__assign({}, context), { taskReference: "".concat(context.reference, "/").concat(transition.index, "/").concat(transition.name), taskName: transition.name }));
+        buildEdge(context.graph, exitAnchor, destinationNode.entryNode || destinationNode, transition.label);
+    }
+    else if (transition.name === FlowDirective.Exit) {
+        buildEdge(context.graph, exitAnchor, context.graph.exitNode, transition.label);
+    }
+    else if (transition.name === FlowDirective.End) {
+        buildEdge(context.graph, exitAnchor, context.graph.exitNode, transition.label);
+    }
+    else
+        throw new Error('Invalid transition');
+}
+/**
+ * Builds all the possible transitions from the provided node in the provided context
+ * @param sourceNode The node to build the transitions from
+ * @param context The context in which the transitions are built
+ */
+function buildTransitions(sourceNode, context) {
+    var _a, _b;
+    var transitions = [];
+    var nextTransition = getNextTask(context.taskList, context.taskName);
+    transitions.push(nextTransition);
+    while ((_a = nextTransition === null || nextTransition === void 0 ? void 0 : nextTransition.task) === null || _a === void 0 ? void 0 : _a.if) {
+        nextTransition.label = (_b = nextTransition === null || nextTransition === void 0 ? void 0 : nextTransition.task) === null || _b === void 0 ? void 0 : _b.if;
+        nextTransition = getNextTask(context.taskList, nextTransition.name, FlowDirective.Continue);
+        transitions.push(nextTransition);
+    }
+    transitions
+        .filter(function (transition, index) {
+        return transitions.findIndex(function (t) { return t.index === transition.index && t.name === transition.name && t.task === transition.task; }) === index;
+    })
+        .forEach(function (transition) { return buildTransition(sourceNode, transition, context); });
+}
+/**
+ * Builds a graph representation of a task
+ * @param context The context to build the graph/node for
+ * @returns A graph or node for the provided context
+ */
+function buildTaskNode(context) {
+    var task = context.taskList.get(context.taskName);
+    if (!task)
+        throw new Error("Unabled to find the task '".concat(context.taskName, "' in the current context"));
+    if (task.call)
+        return buildCallTaskNode(task, context);
+    if (task.catch)
+        return buildTryCatchTaskNode(task, context);
+    if (task.emit)
+        return buildEmitTaskNode(task, context);
+    if (task.for)
+        return buildForTaskNode(task, context);
+    if (task.fork)
+        return buildForkTaskNode(task, context);
+    if (task.listen)
+        return buildListenTaskNode(task, context);
+    if (task.raise)
+        return buildRaiseTaskNode(task, context);
+    if (task.run)
+        return buildRunTaskNode(task, context);
+    if (task.set)
+        return buildSetTaskNode(task, context);
+    if (task.switch)
+        return buildSwitchTaskNode(task, context);
+    if (task.wait)
+        return buildWaitTaskNode(task, context);
+    if (task.do)
+        return buildDoTaskNode(task, context);
+    throw new Error("Unable to defined task type of task named '".concat(context.taskName, "'"));
+}
+/**
+ * Builds a graph node with the provided type and context
+ * @param type The type of the node
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided context
+ */
+function buildGenericTaskNode(type, context) {
+    var node = {
+        type: type,
+        id: context.taskReference,
+        label: context.taskName,
+    };
+    context.graph.nodes.push(node);
+    buildTransitions(node, context);
+    return node;
+}
+/**
+ * Builds a graph node for the provided call task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildCallTaskNode(task, context) {
+    var node = buildGenericTaskNode(GraphNodeType.Call, context);
+    // TODO: add some details about the task?
+    return node;
+}
+/**
+ * Builds a graph for the provided do task
+ * @param task The task to build the graph for
+ * @param context The context to build the graph for
+ * @returns A graph for the provided task
+ */
+function buildDoTaskNode(task, context) {
+    var subgraph = initGraph(GraphNodeType.Do, context.taskReference, context.taskName, context.graph);
+    var doContext = __assign(__assign({}, context), { graph: subgraph, reference: context.taskReference + doReference, taskList: mapTasks(task.do), taskName: null });
+    buildTransitions(subgraph.entryNode, doContext);
+    buildTransitions(subgraph, context);
+    return subgraph;
+}
+/**
+ * Builds a graph node for the provided emit task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildEmitTaskNode(task, context) {
+    var node = buildGenericTaskNode(GraphNodeType.Emit, context);
+    // TODO: add some details about the task?
+    return node;
+}
+/**
+ * Builds a graph for the provided for task
+ * @param task The task to build the graph for
+ * @param context The context to build the graph for
+ * @returns A graph for the provided task
+ */
+function buildForTaskNode(task, context) {
+    var subgraph = initGraph(GraphNodeType.For, context.taskReference, context.taskName, context.graph);
+    var forContext = __assign(__assign({}, context), { graph: subgraph, reference: subgraph.id + forReference + doReference, taskList: mapTasks(task.do), taskName: null });
+    buildTransitions(subgraph.entryNode, forContext);
+    buildTransitions(subgraph, context);
+    return subgraph;
+}
+/**
+ * Builds a graph for the provided fork task
+ * @param task The task to build the graph for
+ * @param context The context to build the graph for
+ * @returns A graph for the provided task
+ */
+function buildForkTaskNode(task, context) {
+    var _a, _b;
+    var subgraph = initGraph(GraphNodeType.Fork, context.taskReference, context.taskName, context.graph);
+    for (var i = 0, c = ((_a = task.fork) === null || _a === void 0 ? void 0 : _a.branches.length) || 0; i < c; i++) {
+        var branchItem = (_b = task.fork) === null || _b === void 0 ? void 0 : _b.branches[i];
+        if (!branchItem)
+            continue;
+        var branchName = Object.entries(branchItem)[0][0];
+        var branchContext = __assign(__assign({}, context), { graph: subgraph, reference: "".concat(context.taskReference).concat(branchReference), taskList: mapTasks([branchItem]), taskReference: "".concat(context.taskReference).concat(branchReference, "/").concat(i, "/").concat(branchName), taskName: branchName });
+        var branchNode = buildTaskNode(branchContext);
+        buildEdge(subgraph, subgraph.entryNode, branchNode.entryNode || branchNode);
+        buildEdge(subgraph, branchNode.exitNode || branchNode, subgraph.exitNode);
+    }
+    buildTransitions(subgraph, context);
+    return subgraph;
+}
+/**
+ * Builds a graph node for the provided listen task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildListenTaskNode(task, context) {
+    var node = buildGenericTaskNode(GraphNodeType.Listen, context);
+    // TODO: add some details about the task?
+    return node;
+}
+/**
+ * Builds a graph node for the provided rasie task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildRaiseTaskNode(task, context) {
+    var node = buildGenericTaskNode(GraphNodeType.Raise, context);
+    // TODO: add some details about the task?
+    return node;
+}
+/**
+ * Builds a graph node for the provided run task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildRunTaskNode(task, context) {
+    var node = buildGenericTaskNode(GraphNodeType.Run, context);
+    // TODO: add some details about the task?
+    return node;
+}
+/**
+ * Builds a graph node for the provided set task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildSetTaskNode(task, context) {
+    var node = buildGenericTaskNode(GraphNodeType.Set, context);
+    // TODO: add some details about the task?
+    return node;
+}
+/**
+ * Builds a graph node for the provided switch task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildSwitchTaskNode(task, context) {
+    var _a;
+    var node = buildGenericTaskNode(GraphNodeType.Switch, context);
+    var hasDefaultCase = false;
+    (_a = task.switch) === null || _a === void 0 ? void 0 : _a.forEach(function (switchItem) {
+        var _a = Object.entries(switchItem)[0], caseName = _a[0], switchCase = _a[1];
+        if (!switchCase.when)
+            hasDefaultCase = true;
+        var transition = getNextTask(context.taskList, context.taskName, switchCase.then);
+        transition.label = caseName;
+        buildTransition(node, transition, context);
+    });
+    if (!hasDefaultCase) {
+        buildTransitions(node, context);
+    }
+    return node;
+}
+/**
+ * Builds a graph for the provided try/catch task
+ * @param task The task to build the graph for
+ * @param context The context to build the graph for
+ * @returns A graph for the provided task
+ */
+function buildTryCatchTaskNode(task, context) {
+    var _a, _b;
+    var containerSubgraph = initGraph(GraphNodeType.TryCatch, context.taskReference, context.taskName, context.graph);
+    var trySubgraph = initGraph(GraphNodeType.Try, context.taskReference + tryReference, context.taskName + ' (try)', containerSubgraph);
+    buildEdge(containerSubgraph, containerSubgraph.entryNode, trySubgraph.entryNode);
+    var tryContext = __assign(__assign({}, context), { graph: trySubgraph, reference: trySubgraph.id, taskList: mapTasks(task.try), taskName: null });
+    buildTransitions(trySubgraph.entryNode, tryContext);
+    if (!((_b = (_a = task.catch) === null || _a === void 0 ? void 0 : _a.do) === null || _b === void 0 ? void 0 : _b.length)) {
+        var catchNode = {
+            type: GraphNodeType.Catch,
+            id: context.taskReference + catchReference,
+            label: context.taskName + ' (catch)',
+        };
+        containerSubgraph.nodes.push(catchNode);
+        buildEdge(containerSubgraph, trySubgraph.exitNode, catchNode);
+        buildEdge(containerSubgraph, catchNode, containerSubgraph.exitNode);
+    }
+    else {
+        var catchSubgraph = initGraph(GraphNodeType.Catch, context.taskReference + catchReference + doReference, context.taskName + ' (catch)', containerSubgraph);
+        buildEdge(containerSubgraph, trySubgraph.exitNode, catchSubgraph.entryNode);
+        var catchContext = __assign(__assign({}, context), { graph: catchSubgraph, reference: catchSubgraph.id, taskList: mapTasks(task.catch.do), taskName: null });
+        buildTransitions(catchSubgraph.entryNode, catchContext);
+        buildEdge(containerSubgraph, catchSubgraph.exitNode, containerSubgraph.exitNode);
+    }
+    buildTransitions(containerSubgraph, context);
+    return containerSubgraph;
+}
+/**
+ * Builds a graph node for the provided wait task
+ * @param task The task to build the graph node for
+ * @param context The context to build the graph node for
+ * @returns A graph node for the provided task
+ */
+function buildWaitTaskNode(task, context) {
+    var node = buildGenericTaskNode(GraphNodeType.Wait, context);
+    // TODO: add some details about the task?
+    return node;
+}
+/**
+ * Builds an edge between two elements
+ * @param graph The graph element containing the nodes
+ * @param source The origin node
+ * @param destination The destination node
+ * @param label The edge label, if any
+ */
+function buildEdge(graph, source, destination, label) {
+    if (label === void 0) { label = ''; }
+    var edge = graph.edges.find(function (e) { return e.sourceId === source.id && e.destinationId === destination.id; });
+    if (edge) {
+        if (label) {
+            edge.label = edge.label + (edge.label ? ' / ' : '') + label;
+        }
+        return edge;
+    }
+    edge = {
+        label: label,
+        id: "".concat(source.id, "-").concat(destination.id).concat(label ? "-".concat(label) : ''),
+        sourceId: source.id,
+        destinationId: destination.id,
+    };
+    graph.edges.push(edge);
+}
+
+/**
+ * Adds indentation to each line of the provided code
+ * @param code The code to indent
+ * @returns The indented code
+ */
+var indent = function (code) {
+    return code
+        .split('\n')
+        .map(function (line) { return "    ".concat(line); })
+        .join('\n');
+};
+/**
+ * Converts a graph to Mermaid code
+ * @param graph The graph to convert
+ * @returns The converted graph
+ */
+function convertGraphToCode(graph) {
+    var isRoot = graph.id === 'root';
+    var code = "".concat(isRoot ? 'flowchart TD' : "subgraph ".concat(graph.id, " [\"").concat(graph.label || graph.id, "\"]"), "\n").concat(indent(graph.nodes.map(function (node) { return convertNodeToCode(node); }).join('\n')), "\n").concat(indent(graph.edges.map(function (edge) { return convertEdgeToCode(edge); }).join('\n')), "\n").concat(isRoot ? '' : 'end');
+    return code;
+}
+/**
+ * Converts a node to Mermaid code
+ * @param node The node to convert
+ * @returns The converted node
+ */
+function convertNodeToCode(node) {
+    var _a;
+    var code = '';
+    if ((_a = node.nodes) === null || _a === void 0 ? void 0 : _a.length) {
+        code = convertGraphToCode(node);
+    }
+    else {
+        code = node.id;
+        switch (node.type) {
+            case GraphNodeType.Entry:
+            case GraphNodeType.Exit:
+                code += ':::hidden';
+                break;
+            case GraphNodeType.Start:
+                code += '(( ))'; // alt '@{ shape: circle, label: " "}';
+                break;
+            case GraphNodeType.End:
+                code += '((( )))'; // alt '@{ shape: dbl-circ, label: " "}';
+                break;
+            default:
+                code += "[\"".concat(node.label, "\"]"); // alt `@{ label: "${node.label}" }`
+        }
+    }
+    return code;
+}
+/**
+ * Converts an edge to Mermaid code
+ * @param edge The edge to convert
+ * @returns The converted edge
+ */
+function convertEdgeToCode(edge) {
+    var ignoreEndArrow = !edge.destinationId.startsWith('root') &&
+        (edge.destinationId.endsWith('-entry-node') || edge.destinationId.endsWith('-exit-node'));
+    var code = "".concat(edge.sourceId, " ").concat(edge.label ? "--\"".concat(edge.label, "\"") : '', "--").concat(ignoreEndArrow ? '-' : '>', " ").concat(edge.destinationId);
+    return code;
+}
+/**
+ * Converts the provided workflow to Mermaid code
+ * @param workflow The workflow to convert
+ * @returns The Mermaid diagram
+ */
+function convertToMermaidCode(workflow) {
+    var graph = buildGraph(workflow);
+    return (convertGraphToCode(graph) +
+        "\n\nclassDef hidden display: none;");
+}
+/**
+ * Represents a Mermaid diagram generator for a given workflow.
+ * This class takes a workflow definition and converts it into a Mermaid.js-compatible diagram.
+ */
+var MermaidDiagram = /** @class */ (function () {
+    function MermaidDiagram(workflow) {
+        this.workflow = workflow;
+    }
+    /**
+     * Generates the Mermaid code representation of the workflow.
+     * @returns The Mermaid diagram source code as a string.
+     */
+    MermaidDiagram.prototype.sourceCode = function () {
+        return convertToMermaidCode(this.workflow);
+    };
+    return MermaidDiagram;
+}());
+
 /*
  * Copyright 2021-Present The Serverless Workflow Specification Authors
  *
@@ -24899,6 +25445,12 @@ var Workflow = /** @class */ (function (_super) {
         }
         return dump(normalized);
     };
+    Workflow.toGraph = function (model) {
+        return buildGraph(model);
+    };
+    Workflow.toMermaidCode = function (model) {
+        return convertToMermaidCode(model);
+    };
     /**
      * Serializes the workflow to YAML or JSON
      * @param format The format, 'yaml' or 'json', default is 'yaml'
@@ -24910,6 +25462,20 @@ var Workflow = /** @class */ (function (_super) {
         if (normalize === void 0) { normalize = true; }
         return Workflow.serialize(this, format, normalize);
     };
+    /**
+     * Creates a directed graph representation of the workflow
+     * @returns A directed graph of the workflow
+     */
+    Workflow.prototype.toGraph = function () {
+        return Workflow.toGraph(this);
+    };
+    /**
+     * Generates the MermaidJS code corresponding to the workflow
+     * @returns The MermaidJS code
+     */
+    Workflow.prototype.toMermaidCode = function () {
+        return Workflow.toMermaidCode(this);
+    };
     return Workflow;
 }(ObjectHydrator));
 var _Workflow = Workflow;
@@ -30718,5 +31284,5 @@ var specification = /*#__PURE__*/Object.freeze({
   __proto__: null
 });
 
-export { Classes, specification as Specification, allEventConsumptionStrategyBuilder, allEventConsumptionStrategyConfigurationBuilder, anyEventConsumptionStrategyBuilder, anyEventConsumptionStrategyConfigurationBuilder, anyEventConsumptionStrategyUntilBuilder, anyEventUntilConsumedBuilder, asyncApiArgumentsBuilder, authenticationPolicyBuilder, authenticationPolicyReferenceBuilder, basicAuthenticationPolicyBuilder, basicAuthenticationPolicyConfigurationBuilder, basicAuthenticationPropertiesBuilder, bearerAuthenticationPolicyBuilder, bearerAuthenticationPolicyConfigurationBuilder, bearerAuthenticationPropertiesBuilder, callAsyncAPIBuilder, callFunctionBuilder, callGRPCBuilder, callHTTPBuilder, callOpenAPIBuilder, callTaskBuilder, catalogBuilder, catchErrorsBuilder, constantBackoffBuilder, containerBuilder, containerEnvironmentBuilder, containerLifetimeBuilder, containerPortsBuilder, containerVolumesBuilder, digestAuthenticationPolicyBuilder, digestAuthenticationPolicyConfigurationBuilder, digestAuthenticationPropertiesBuilder, doTaskBuilder, documentBuilder, durationBuilder, durationInlineBuilder, emitEventDefinitionBuilder, emitEventWithBuilder, emitTaskBuilder, emitTaskConfigurationBuilder, endpointBuilder, endpointConfigurationBuilder, endpointUriBuilder, errorBuilder, errorFilterBuilder, errorInstanceBuilder, errorTypeBuilder, eventConsumptionStrategyBuilder, eventDataBuilder, eventDataschemaBuilder, eventFilterBuilder, eventFilterCorrelateBuilder, eventSourceBuilder, eventTimeBuilder, exponentialBackOffBuilder, exportAsBuilder, exportBuilder, extensionBuilder, extensionItemBuilder, externalResourceBuilder, externalScriptBuilder, flowDirectiveBuilder, forTaskBuilder, forTaskConfigurationBuilder, forkTaskBuilder, forkTaskConfigurationBuilder, functionArgumentsBuilder, gRPCArgumentsBuilder, hTTPArgumentsBuilder, hTTPBodyBuilder, hTTPHeadersBuilder, hTTPQueryBuilder, inlineScriptBuilder, inputBuilder, inputFromBuilder, linearBackoffBuilder, listenTaskBuilder, listenTaskConfigurationBuilder, oAuth2AutenthicationDataAudiencesBuilder, oAuth2AutenthicationDataBuilder, oAuth2AutenthicationDataClientBuilder, oAuth2AutenthicationDataScopesBuilder, oAuth2AuthenticationPolicyBuilder, oAuth2AuthenticationPolicyConfigurationBuilder, oAuth2AuthenticationPropertiesEndpointsBuilder, oAuth2ConnectAuthenticationPropertiesBuilder, oAuth2IssuersBuilder, oAuth2TokenDefinitionBuilder, oAuth2TokenRequestBuilder, oneEventConsumptionStrategyBuilder, openAPIArgumentsBuilder, openIdConnectAuthenticationPolicyBuilder, openIdConnectAuthenticationPolicyConfigurationBuilder, openIdConnectAuthenticationPropertiesBuilder, outputAsBuilder, outputBuilder, raiseTaskBuilder, raiseTaskConfigurationBuilder, raiseTaskErrorBuilder, referenceableAuthenticationPolicyBuilder, retryBackoffBuilder, retryLimitAttemptBuilder, retryLimitBuilder, retryPolicyBuilder, retryPolicyJitterBuilder, runContainerBuilder, runScriptBuilder, runShellBuilder, runTaskBuilder, runTaskConfigurationBuilder, runWorkflowBuilder, runtimeExpressionBuilder, scheduleBuilder, schemaBuilder, schemaExternalBuilder, schemaInlineBuilder, scriptBuilder, secretBasedAuthenticationPolicyBuilder, setTaskBuilder, setTaskConfigurationBuilder, shellArgumentsBuilder, shellBuilder, shellEnvironmentBuilder, subflowConfigurationBuilder, subflowInputBuilder, subscriptionIteratorBuilder, switchCaseBuilder, switchItemBuilder, switchTaskBuilder, switchTaskConfigurationBuilder, taskBaseBuilder, taskBaseIfBuilder, taskBuilder, taskItemBuilder, taskListBuilder, taskMetadataBuilder, taskTimeoutBuilder, timeoutBuilder, tryTaskBuilder, tryTaskCatchBuilder, tryTaskCatchRetryBuilder, uriTemplateBuilder, useAuthenticationsBuilder, useBuilder, useCatalogsBuilder, useErrorsBuilder, useExtensionsBuilder, useFunctionsBuilder, useRetriesBuilder, useSecretsBuilder, useTimeoutsBuilder, validate, waitTaskBuilder, withEventBuilder, withGRPCArgumentsBuilder, withGRPCServiceBuilder, withOpenAPIParametersBuilder, workflowBuilder, workflowMetadataBuilder, workflowTagsBuilder, workflowTimeoutBuilder };
+export { Classes, GraphNodeType, MermaidDiagram, specification as Specification, allEventConsumptionStrategyBuilder, allEventConsumptionStrategyConfigurationBuilder, anyEventConsumptionStrategyBuilder, anyEventConsumptionStrategyConfigurationBuilder, anyEventConsumptionStrategyUntilBuilder, anyEventUntilConsumedBuilder, asyncApiArgumentsBuilder, authenticationPolicyBuilder, authenticationPolicyReferenceBuilder, basicAuthenticationPolicyBuilder, basicAuthenticationPolicyConfigurationBuilder, basicAuthenticationPropertiesBuilder, bearerAuthenticationPolicyBuilder, bearerAuthenticationPolicyConfigurationBuilder, bearerAuthenticationPropertiesBuilder, buildGraph, callAsyncAPIBuilder, callFunctionBuilder, callGRPCBuilder, callHTTPBuilder, callOpenAPIBuilder, callTaskBuilder, catalogBuilder, catchErrorsBuilder, constantBackoffBuilder, containerBuilder, containerEnvironmentBuilder, containerLifetimeBuilder, containerPortsBuilder, containerVolumesBuilder, convertToMermaidCode, digestAuthenticationPolicyBuilder, digestAuthenticationPolicyConfigurationBuilder, digestAuthenticationPropertiesBuilder, doTaskBuilder, documentBuilder, durationBuilder, durationInlineBuilder, emitEventDefinitionBuilder, emitEventWithBuilder, emitTaskBuilder, emitTaskConfigurationBuilder, endpointBuilder, endpointConfigurationBuilder, endpointUriBuilder, errorBuilder, errorFilterBuilder, errorInstanceBuilder, errorTypeBuilder, eventConsumptionStrategyBuilder, eventDataBuilder, eventDataschemaBuilder, eventFilterBuilder, eventFilterCorrelateBuilder, eventSourceBuilder, eventTimeBuilder, exponentialBackOffBuilder, exportAsBuilder, exportBuilder, extensionBuilder, extensionItemBuilder, externalResourceBuilder, externalScriptBuilder, flowDirectiveBuilder, forTaskBuilder, forTaskConfigurationBuilder, forkTaskBuilder, forkTaskConfigurationBuilder, functionArgumentsBuilder, gRPCArgumentsBuilder, hTTPArgumentsBuilder, hTTPBodyBuilder, hTTPHeadersBuilder, hTTPQueryBuilder, inlineScriptBuilder, inputBuilder, inputFromBuilder, linearBackoffBuilder, listenTaskBuilder, listenTaskConfigurationBuilder, oAuth2AutenthicationDataAudiencesBuilder, oAuth2AutenthicationDataBuilder, oAuth2AutenthicationDataClientBuilder, oAuth2AutenthicationDataScopesBuilder, oAuth2AuthenticationPolicyBuilder, oAuth2AuthenticationPolicyConfigurationBuilder, oAuth2AuthenticationPropertiesEndpointsBuilder, oAuth2ConnectAuthenticationPropertiesBuilder, oAuth2IssuersBuilder, oAuth2TokenDefinitionBuilder, oAuth2TokenRequestBuilder, oneEventConsumptionStrategyBuilder, openAPIArgumentsBuilder, openIdConnectAuthenticationPolicyBuilder, openIdConnectAuthenticationPolicyConfigurationBuilder, openIdConnectAuthenticationPropertiesBuilder, outputAsBuilder, outputBuilder, raiseTaskBuilder, raiseTaskConfigurationBuilder, raiseTaskErrorBuilder, referenceableAuthenticationPolicyBuilder, retryBackoffBuilder, retryLimitAttemptBuilder, retryLimitBuilder, retryPolicyBuilder, retryPolicyJitterBuilder, runContainerBuilder, runScriptBuilder, runShellBuilder, runTaskBuilder, runTaskConfigurationBuilder, runWorkflowBuilder, runtimeExpressionBuilder, scheduleBuilder, schemaBuilder, schemaExternalBuilder, schemaInlineBuilder, scriptBuilder, secretBasedAuthenticationPolicyBuilder, setTaskBuilder, setTaskConfigurationBuilder, shellArgumentsBuilder, shellBuilder, shellEnvironmentBuilder, subflowConfigurationBuilder, subflowInputBuilder, subscriptionIteratorBuilder, switchCaseBuilder, switchItemBuilder, switchTaskBuilder, switchTaskConfigurationBuilder, taskBaseBuilder, taskBaseIfBuilder, taskBuilder, taskItemBuilder, taskListBuilder, taskMetadataBuilder, taskTimeoutBuilder, timeoutBuilder, tryTaskBuilder, tryTaskCatchBuilder, tryTaskCatchRetryBuilder, uriTemplateBuilder, useAuthenticationsBuilder, useBuilder, useCatalogsBuilder, useErrorsBuilder, useExtensionsBuilder, useFunctionsBuilder, useRetriesBuilder, useSecretsBuilder, useTimeoutsBuilder, validate, waitTaskBuilder, withEventBuilder, withGRPCArgumentsBuilder, withGRPCServiceBuilder, withOpenAPIParametersBuilder, workflowBuilder, workflowMetadataBuilder, workflowTagsBuilder, workflowTimeoutBuilder };
 //# sourceMappingURL=index.esm.js.map