@serverlessworkflow/sdk 1.0.0 → 1.0.1

package/umd/index.umd.js

@@ -139,6 +139,17 @@
       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;
@@ -18095,7 +18106,7 @@
    * 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.
@@ -18130,7 +18141,7 @@
       };
       return FlowDirective;
   }(ObjectHydrator));
-  var _FlowDirective = FlowDirective;
+  var _FlowDirective = FlowDirective$1;
 
   /*
    * Copyright 2021-Present The Serverless Workflow Specification Authors
@@ -24820,6 +24831,541 @@
   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.
+   */
+  exports.GraphNodeType = void 0;
+  (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";
+  })(exports.GraphNodeType || (exports.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 ? exports.GraphNodeType.Start : exports.GraphNodeType.Entry,
+          id: "".concat(id).concat(entrySuffix),
+      };
+      var exitNode = {
+          type: id === rooId ? exports.GraphNodeType.End : exports.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.GraphNodeType.TryCatch, context.taskReference, context.taskName, context.graph);
+      var trySubgraph = initGraph(exports.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: exports.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(exports.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(exports.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 exports.GraphNodeType.Entry:
+              case exports.GraphNodeType.Exit:
+                  code += ':::hidden';
+                  break;
+              case exports.GraphNodeType.Start:
+                  code += '(( ))'; // alt '@{ shape: circle, label: " "}';
+                  break;
+              case exports.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
    *
@@ -24905,6 +25451,12 @@
           }
           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'
@@ -24916,6 +25468,20 @@
           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;
@@ -30725,6 +31291,7 @@
   });
 
   exports.Classes = Classes;
+  exports.MermaidDiagram = MermaidDiagram;
   exports.Specification = specification;
   exports.allEventConsumptionStrategyBuilder = allEventConsumptionStrategyBuilder;
   exports.allEventConsumptionStrategyConfigurationBuilder = allEventConsumptionStrategyConfigurationBuilder;
@@ -30741,6 +31308,7 @@
   exports.bearerAuthenticationPolicyBuilder = bearerAuthenticationPolicyBuilder;
   exports.bearerAuthenticationPolicyConfigurationBuilder = bearerAuthenticationPolicyConfigurationBuilder;
   exports.bearerAuthenticationPropertiesBuilder = bearerAuthenticationPropertiesBuilder;
+  exports.buildGraph = buildGraph;
   exports.callAsyncAPIBuilder = callAsyncAPIBuilder;
   exports.callFunctionBuilder = callFunctionBuilder;
   exports.callGRPCBuilder = callGRPCBuilder;
@@ -30755,6 +31323,7 @@
   exports.containerLifetimeBuilder = containerLifetimeBuilder;
   exports.containerPortsBuilder = containerPortsBuilder;
   exports.containerVolumesBuilder = containerVolumesBuilder;
+  exports.convertToMermaidCode = convertToMermaidCode;
   exports.digestAuthenticationPolicyBuilder = digestAuthenticationPolicyBuilder;
   exports.digestAuthenticationPolicyConfigurationBuilder = digestAuthenticationPolicyConfigurationBuilder;
   exports.digestAuthenticationPropertiesBuilder = digestAuthenticationPropertiesBuilder;