@erxes/api-shared 3.2.21-1 → 3.2.22-1

package/core-modules/dist/erxes-api-shared-core-modules.cjs.prod.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var startPlugin = require('../../dist/start-plugin-b095acca.cjs.prod.js');
+var startPlugin = require('../../dist/start-plugin-46baacee.cjs.prod.js');
 var dayjs = require('dayjs');
 require('node-fetch');
 var nanoid = require('nanoid');
@@ -543,7 +543,7 @@ var AUTOMATION_RETRY_LIMITS = {
   MIN_DELAY_SECONDS: 5,
   MAX_DELAY_SECONDS: 3600
 };
-var isRecord$1 = function isRecord(value) {
+var isRecord$2 = function isRecord(value) {
   return startPlugin._typeof(value) === 'object' && value !== null;
 };
 var asActionId = function asActionId(value) {
@@ -566,8 +566,8 @@ var isBackoff = function isBackoff(value) {
  * never park an execution for longer than the ceiling allows.
  */
 var resolveActionErrorPolicy = function resolveActionErrorPolicy(config) {
-  var policy = isRecord$1(config) && isRecord$1(config.errorPolicy) ? config.errorPolicy : {};
-  var retry = isRecord$1(policy.retry) ? policy.retry : {};
+  var policy = isRecord$2(config) && isRecord$2(config.errorPolicy) ? config.errorPolicy : {};
+  var retry = isRecord$2(policy.retry) ? policy.retry : {};
   var MAX_ATTEMPTS = AUTOMATION_RETRY_LIMITS.MAX_ATTEMPTS,
     DEFAULT_DELAY_SECONDS = AUTOMATION_RETRY_LIMITS.DEFAULT_DELAY_SECONDS,
     MIN_DELAY_SECONDS = AUTOMATION_RETRY_LIMITS.MIN_DELAY_SECONDS,
@@ -585,7 +585,7 @@ var resolveActionErrorPolicy = function resolveActionErrorPolicy(config) {
  * the plain `nextActionId` is only read while the policy is off.
  */
 var resolveActionBranchTarget = function resolveActionBranchTarget(action, outcome) {
-  var config = isRecord$1(action === null || action === void 0 ? void 0 : action.config) ? action.config : {};
+  var config = isRecord$2(action === null || action === void 0 ? void 0 : action.config) ? action.config : {};
   var branching = resolveActionErrorPolicy(config).onError === AUTOMATION_ERROR_BEHAVIOURS.BRANCH;
   if (!branching) {
     return outcome === 'success' ? action === null || action === void 0 ? void 0 : action.nextActionId : undefined;
@@ -637,7 +637,7 @@ var buildFailedAction = function buildFailedAction(message, code, result) {
     result: result
   };
 };
-var isRecord = function isRecord(value) {
+var isRecord$1 = function isRecord(value) {
   return startPlugin._typeof(value) === 'object' && value !== null;
 };
 var isDeclaredStatus = function isDeclaredStatus(value) {
@@ -646,7 +646,7 @@ var isDeclaredStatus = function isDeclaredStatus(value) {
 
 /** For callers that forward an action's answer without reading it. */
 var isActionOutcomeEnvelope = function isActionOutcomeEnvelope(value) {
-  return isRecord(value) && isRecord(value.outcome) && isDeclaredStatus(value.outcome.status);
+  return isRecord$1(value) && isRecord$1(value.outcome) && isDeclaredStatus(value.outcome.status);
 };
 var asString = function asString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : undefined;
@@ -661,7 +661,7 @@ var resolveActionOutcome = function resolveActionOutcome(actionResponse) {
     status: AUTOMATION_ACTION_OUTCOMES.SUCCESS,
     result: actionResponse
   };
-  if (!isRecord(actionResponse) || !isRecord(actionResponse.outcome)) {
+  if (!isRecord$1(actionResponse) || !isRecord$1(actionResponse.outcome)) {
     return asSuccess;
   }
   var outcome = actionResponse.outcome,
@@ -783,6 +783,503 @@ var reEnrollmentRelationPaths = function reEnrollmentRelationPaths() {
   });
 };
 
+/**
+ * A field whose value depends on the run holds a token instead of a value;
+ * the rules behind it live in the action config under this key. The engine
+ * swaps tokens for the first matching row before the action ever sees its
+ * config, so no action has to know conditionals exist.
+ */
+var AUTOMATION_CONDITIONALS_KEY = '_conditionals';
+var CONDITIONAL_TOKEN_REGEX = /^<<\s*cond:([A-Za-z0-9_-]+)\s*>>$/;
+var formatConditionalToken = function formatConditionalToken(id) {
+  return "<< cond:".concat(id, " >>");
+};
+
+// The whole value must be the token, so text that merely mentions one is left alone
+var parseConditionalToken = function parseConditionalToken(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  var match = value.match(CONDITIONAL_TOKEN_REGEX);
+  return match ? match[1] : null;
+};
+// Operators that test presence or truth and take no right-hand value
+var AUTOMATION_UNARY_OPERATORS = ['is', 'ins', 'dateis', 'dateins', 'it', 'if'];
+var isEmptyValue = function isEmptyValue(value) {
+  return value === undefined || value === null || value === '' || Array.isArray(value) && !value.length;
+};
+var normalizeDate = function normalizeDate(value) {
+  var date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.getTime();
+};
+var compareDates = function compareDates(actual, expected, compare) {
+  var actualDate = normalizeDate(actual);
+  var expectedDate = normalizeDate(expected);
+  return actualDate !== null && expectedDate !== null ? compare(actualDate, expectedDate) : false;
+};
+
+/** Split and conditional values share one meaning per operator. */
+var isAutomationConditionMatched = function isAutomationConditionMatched(actualValue, operator, expectedValue) {
+  switch (operator) {
+    case 'e':
+      return actualValue === expectedValue;
+    case 'numbere':
+      return Number(actualValue) === Number(expectedValue);
+    case 'dne':
+      return actualValue !== expectedValue;
+    case 'numberdne':
+      return Number(actualValue) !== Number(expectedValue);
+    case 'c':
+      return String(actualValue || '').toLowerCase().includes(String(expectedValue || '').toLowerCase());
+    case 'dnc':
+      return !String(actualValue || '').toLowerCase().includes(String(expectedValue || '').toLowerCase());
+    case 'it':
+      return actualValue === true;
+    case 'if':
+      return actualValue === false;
+    case 'is':
+    case 'dateis':
+      return !isEmptyValue(actualValue);
+    case 'ins':
+    case 'dateins':
+      return isEmptyValue(actualValue);
+    case 'numberigt':
+      return Number(actualValue) >= Number(expectedValue);
+    case 'numberilt':
+      return Number(actualValue) <= Number(expectedValue);
+    case 'dateigt':
+      return compareDates(actualValue, expectedValue, function (a, b) {
+        return a >= b;
+      });
+    case 'dateilt':
+      return compareDates(actualValue, expectedValue, function (a, b) {
+        return a <= b;
+      });
+    default:
+      return false;
+  }
+};
+
+/** Problems that keep a conditional from running; empty when it can. */
+var validateAutomationConditional = function validateAutomationConditional(conditional) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$requiredKeys = _ref.requiredKeys,
+    requiredKeys = _ref$requiredKeys === void 0 ? [] : _ref$requiredKeys;
+  var errors = [];
+  if (!conditional.rows.length) {
+    errors.push('Add at least one condition row');
+  }
+  conditional.rows.forEach(function (row, rowIndex) {
+    var at = "Row ".concat(rowIndex + 1);
+    if (!row.conditions.length) {
+      errors.push("".concat(at, ": add at least one condition"));
+    }
+    row.conditions.forEach(function (condition, conditionIndex) {
+      var _condition$left;
+      var where = "".concat(at, ", condition ").concat(conditionIndex + 1);
+      if (condition.kind === 'segment') {
+        if (!condition.segmentId) {
+          errors.push("".concat(where, ": pick a segment"));
+        }
+        return;
+      }
+      if (!((_condition$left = condition.left) !== null && _condition$left !== void 0 && _condition$left.trim())) {
+        errors.push("".concat(where, ": pick a value to check"));
+      }
+      if (!condition.operator) {
+        errors.push("".concat(where, ": pick an operator"));
+      } else if (!AUTOMATION_UNARY_OPERATORS.includes(condition.operator) && isEmptyValue(condition.right)) {
+        errors.push("".concat(where, ": enter a value to compare with"));
+      }
+    });
+    var _iterator = startPlugin._createForOfIteratorHelper(conditional.keys),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _row$values;
+        var key = _step.value;
+        if (isEmptyValue((_row$values = row.values) === null || _row$values === void 0 ? void 0 : _row$values[key])) {
+          errors.push("".concat(at, ": set a value"));
+          break;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  });
+  var _iterator2 = startPlugin._createForOfIteratorHelper(requiredKeys),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _conditional$otherwis;
+      var key = _step2.value;
+      if (isEmptyValue((_conditional$otherwis = conditional.otherwise) === null || _conditional$otherwis === void 0 ? void 0 : _conditional$otherwis[key])) {
+        errors.push('Otherwise: set a value');
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return errors;
+};
+var conditionCacheKey = function conditionCacheKey(condition) {
+  var _condition$right;
+  return condition.kind === 'segment' ? "segment|".concat(condition.segmentId) : "value|".concat(condition.left, "|").concat(condition.operator, "|").concat((_condition$right = condition.right) !== null && _condition$right !== void 0 ? _condition$right : '');
+};
+// One answer per distinct condition for the whole action, however many
+// fields repeat it
+var createConditionEvaluator = function createConditionEvaluator(_ref2) {
+  var subdomain = _ref2.subdomain,
+    execution = _ref2.execution,
+    isInSegment = _ref2.isInSegment;
+  var answers = new Map();
+  var evaluate = /*#__PURE__*/function () {
+    var _ref3 = startPlugin._asyncToGenerator(/*#__PURE__*/startPlugin._regeneratorRuntime().mark(function _callee(condition) {
+      var _condition$right2;
+      var resolved;
+      return startPlugin._regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!(condition.kind === 'segment')) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return", isInSegment(condition.segmentId));
+          case 2:
+            _context.next = 4;
+            return startPlugin.replaceOutputPlaceholders({
+              subdomain: subdomain,
+              execution: execution,
+              values: {
+                left: condition.left,
+                right: (_condition$right2 = condition.right) !== null && _condition$right2 !== void 0 ? _condition$right2 : ''
+              },
+              defaultValue: '',
+              keepUnresolvedPlaceholders: false
+            });
+          case 4:
+            resolved = _context.sent;
+            return _context.abrupt("return", isAutomationConditionMatched(resolved.left, condition.operator, resolved.right));
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function evaluate(_x) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+  return function (condition) {
+    var key = conditionCacheKey(condition);
+    if (!answers.has(key)) {
+      answers.set(key, evaluate(condition));
+    }
+    return answers.get(key);
+  };
+};
+var isRowMatched = /*#__PURE__*/function () {
+  var _ref4 = startPlugin._asyncToGenerator(/*#__PURE__*/startPlugin._regeneratorRuntime().mark(function _callee2(row, evaluate) {
+    var _iterator3, _step3, _condition, _iterator4, _step4, _condition2;
+    return startPlugin._regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (row.conditions.length) {
+            _context2.next = 2;
+            break;
+          }
+          return _context2.abrupt("return", false);
+        case 2:
+          if (!(row.conjunction === 'or')) {
+            _context2.next = 23;
+            break;
+          }
+          _iterator3 = startPlugin._createForOfIteratorHelper(row.conditions);
+          _context2.prev = 4;
+          _iterator3.s();
+        case 6:
+          if ((_step3 = _iterator3.n()).done) {
+            _context2.next = 14;
+            break;
+          }
+          _condition = _step3.value;
+          _context2.next = 10;
+          return evaluate(_condition);
+        case 10:
+          if (!_context2.sent) {
+            _context2.next = 12;
+            break;
+          }
+          return _context2.abrupt("return", true);
+        case 12:
+          _context2.next = 6;
+          break;
+        case 14:
+          _context2.next = 19;
+          break;
+        case 16:
+          _context2.prev = 16;
+          _context2.t0 = _context2["catch"](4);
+          _iterator3.e(_context2.t0);
+        case 19:
+          _context2.prev = 19;
+          _iterator3.f();
+          return _context2.finish(19);
+        case 22:
+          return _context2.abrupt("return", false);
+        case 23:
+          _iterator4 = startPlugin._createForOfIteratorHelper(row.conditions);
+          _context2.prev = 24;
+          _iterator4.s();
+        case 26:
+          if ((_step4 = _iterator4.n()).done) {
+            _context2.next = 34;
+            break;
+          }
+          _condition2 = _step4.value;
+          _context2.next = 30;
+          return evaluate(_condition2);
+        case 30:
+          if (_context2.sent) {
+            _context2.next = 32;
+            break;
+          }
+          return _context2.abrupt("return", false);
+        case 32:
+          _context2.next = 26;
+          break;
+        case 34:
+          _context2.next = 39;
+          break;
+        case 36:
+          _context2.prev = 36;
+          _context2.t1 = _context2["catch"](24);
+          _iterator4.e(_context2.t1);
+        case 39:
+          _context2.prev = 39;
+          _iterator4.f();
+          return _context2.finish(39);
+        case 42:
+          return _context2.abrupt("return", true);
+        case 43:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[4, 16, 19, 22], [24, 36, 39, 42]]);
+  }));
+  return function isRowMatched(_x2, _x3) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var isRecord = function isRecord(value) {
+  return startPlugin._typeof(value) === 'object' && value !== null && !Array.isArray(value);
+};
+
+/**
+ * Returns the config the action should run with: every token replaced by its
+ * first matching row (or otherwise), the conditionals key removed, and which
+ * row each conditional used. Tokens without a conditional are reported, never
+ * passed through as text.
+ */
+var applyAutomationConditionals = /*#__PURE__*/function () {
+  var _ref6 = startPlugin._asyncToGenerator(/*#__PURE__*/startPlugin._regeneratorRuntime().mark(function _callee5(_ref5) {
+    var subdomain, execution, config, isInSegment, _ref7, rawConditionals, rest, conditionals, evaluate, matches, missing, chosenById, choose, _walk;
+    return startPlugin._regeneratorRuntime().wrap(function _callee5$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          subdomain = _ref5.subdomain, execution = _ref5.execution, config = _ref5.config, isInSegment = _ref5.isInSegment;
+          _ref7 = config || {}, rawConditionals = _ref7[AUTOMATION_CONDITIONALS_KEY], rest = startPlugin._objectWithoutProperties(_ref7, [AUTOMATION_CONDITIONALS_KEY].map(startPlugin._toPropertyKey));
+          conditionals = isRecord(rawConditionals) ? rawConditionals : {};
+          evaluate = createConditionEvaluator({
+            subdomain: subdomain,
+            execution: execution,
+            isInSegment: isInSegment
+          });
+          matches = {};
+          missing = [];
+          chosenById = new Map();
+          choose = /*#__PURE__*/function () {
+            var _ref8 = startPlugin._asyncToGenerator(/*#__PURE__*/startPlugin._regeneratorRuntime().mark(function _callee3(id, conditional) {
+              var chosen, _iterator5, _step5, row;
+              return startPlugin._regeneratorRuntime().wrap(function _callee3$(_context3) {
+                while (1) switch (_context3.prev = _context3.next) {
+                  case 0:
+                    if (chosenById.has(id)) {
+                      _context3.next = 24;
+                      break;
+                    }
+                    chosen = {
+                      rowId: 'otherwise',
+                      values: conditional.otherwise || {}
+                    };
+                    _iterator5 = startPlugin._createForOfIteratorHelper(conditional.rows || []);
+                    _context3.prev = 3;
+                    _iterator5.s();
+                  case 5:
+                    if ((_step5 = _iterator5.n()).done) {
+                      _context3.next = 14;
+                      break;
+                    }
+                    row = _step5.value;
+                    _context3.next = 9;
+                    return isRowMatched(row, evaluate);
+                  case 9:
+                    if (!_context3.sent) {
+                      _context3.next = 12;
+                      break;
+                    }
+                    chosen = {
+                      rowId: row.id,
+                      values: row.values || {}
+                    };
+                    return _context3.abrupt("break", 14);
+                  case 12:
+                    _context3.next = 5;
+                    break;
+                  case 14:
+                    _context3.next = 19;
+                    break;
+                  case 16:
+                    _context3.prev = 16;
+                    _context3.t0 = _context3["catch"](3);
+                    _iterator5.e(_context3.t0);
+                  case 19:
+                    _context3.prev = 19;
+                    _iterator5.f();
+                    return _context3.finish(19);
+                  case 22:
+                    matches[id] = chosen.rowId;
+                    chosenById.set(id, startPlugin._objectSpread2(startPlugin._objectSpread2({}, conditional.otherwise || {}), chosen.values));
+                  case 24:
+                    return _context3.abrupt("return", chosenById.get(id));
+                  case 25:
+                  case "end":
+                    return _context3.stop();
+                }
+              }, _callee3, null, [[3, 16, 19, 22]]);
+            }));
+            return function choose(_x5, _x6) {
+              return _ref8.apply(this, arguments);
+            };
+          }();
+          _walk = /*#__PURE__*/function () {
+            var _ref9 = startPlugin._asyncToGenerator(/*#__PURE__*/startPlugin._regeneratorRuntime().mark(function _callee4(node) {
+              var next, patches, _loop, _ret, _i, _Object$entries;
+              return startPlugin._regeneratorRuntime().wrap(function _callee4$(_context5) {
+                while (1) switch (_context5.prev = _context5.next) {
+                  case 0:
+                    if (!Array.isArray(node)) {
+                      _context5.next = 2;
+                      break;
+                    }
+                    return _context5.abrupt("return", Promise.all(node.map(_walk)));
+                  case 2:
+                    if (isRecord(node)) {
+                      _context5.next = 4;
+                      break;
+                    }
+                    return _context5.abrupt("return", node);
+                  case 4:
+                    next = {};
+                    patches = [];
+                    _loop = /*#__PURE__*/startPlugin._regeneratorRuntime().mark(function _loop() {
+                      var _conditional$keys;
+                      var _Object$entries$_i, key, value, id, conditional, chosen, keys;
+                      return startPlugin._regeneratorRuntime().wrap(function _loop$(_context4) {
+                        while (1) switch (_context4.prev = _context4.next) {
+                          case 0:
+                            _Object$entries$_i = startPlugin._slicedToArray(_Object$entries[_i], 2), key = _Object$entries$_i[0], value = _Object$entries$_i[1];
+                            id = parseConditionalToken(value);
+                            if (id) {
+                              _context4.next = 7;
+                              break;
+                            }
+                            _context4.next = 5;
+                            return _walk(value);
+                          case 5:
+                            next[key] = _context4.sent;
+                            return _context4.abrupt("return", 0);
+                          case 7:
+                            conditional = conditionals[id];
+                            if (conditional) {
+                              _context4.next = 12;
+                              break;
+                            }
+                            missing.push(id);
+                            next[key] = '';
+                            return _context4.abrupt("return", 0);
+                          case 12:
+                            _context4.next = 14;
+                            return choose(id, conditional);
+                          case 14:
+                            chosen = _context4.sent;
+                            keys = (_conditional$keys = conditional.keys) !== null && _conditional$keys !== void 0 && _conditional$keys.length ? conditional.keys : [key];
+                            patches.push(Object.fromEntries(keys.map(function (patchKey) {
+                              return [patchKey, chosen[patchKey]];
+                            })));
+                          case 17:
+                          case "end":
+                            return _context4.stop();
+                        }
+                      }, _loop);
+                    });
+                    _i = 0, _Object$entries = Object.entries(node);
+                  case 8:
+                    if (!(_i < _Object$entries.length)) {
+                      _context5.next = 16;
+                      break;
+                    }
+                    return _context5.delegateYield(_loop(), "t0", 10);
+                  case 10:
+                    _ret = _context5.t0;
+                    if (!(_ret === 0)) {
+                      _context5.next = 13;
+                      break;
+                    }
+                    return _context5.abrupt("continue", 13);
+                  case 13:
+                    _i++;
+                    _context5.next = 8;
+                    break;
+                  case 16:
+                    return _context5.abrupt("return", Object.assign.apply(Object, [next].concat(patches)));
+                  case 17:
+                  case "end":
+                    return _context5.stop();
+                }
+              }, _callee4);
+            }));
+            return function walk(_x7) {
+              return _ref9.apply(this, arguments);
+            };
+          }();
+          _context6.next = 11;
+          return _walk(rest);
+        case 11:
+          _context6.t0 = _context6.sent;
+          _context6.t1 = matches;
+          _context6.t2 = missing;
+          return _context6.abrupt("return", {
+            config: _context6.t0,
+            matches: _context6.t1,
+            missing: _context6.t2
+          });
+        case 15:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee5);
+  }));
+  return function applyAutomationConditionals(_x4) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
 var userActionsMap = /*#__PURE__*/function () {
   var _ref = startPlugin._asyncToGenerator(/*#__PURE__*/startPlugin._regeneratorRuntime().mark(function _callee(userPermissions, groupPermissions, user) {
     var totalPermissions, allowedActions, check, _iterator, _step, _step$value, requiredActions, allowed, action, _iterator2, _step2, actionName;
@@ -6582,6 +7079,7 @@ exports.zonedDayStart = startPlugin.zonedDayStart;
 exports.zonedPeriodRange = startPlugin.zonedPeriodRange;
 exports.AUTOMATION_ACTION_OUTCOMES = AUTOMATION_ACTION_OUTCOMES;
 exports.AUTOMATION_BRANCH_KEYS = AUTOMATION_BRANCH_KEYS;
+exports.AUTOMATION_CONDITIONALS_KEY = AUTOMATION_CONDITIONALS_KEY;
 exports.AUTOMATION_ERROR_BEHAVIOURS = AUTOMATION_ERROR_BEHAVIOURS;
 exports.AUTOMATION_RETRY_BACKOFFS = AUTOMATION_RETRY_BACKOFFS;
 exports.AUTOMATION_RETRY_LIMITS = AUTOMATION_RETRY_LIMITS;
@@ -6589,6 +7087,7 @@ exports.AUTOMATION_RE_ENROLL_EVERY_TIME = AUTOMATION_RE_ENROLL_EVERY_TIME;
 exports.AUTOMATION_RE_ENROLL_RELATION_PREFIX = AUTOMATION_RE_ENROLL_RELATION_PREFIX;
 exports.AUTOMATION_SEGMENT_MEMBERSHIP_EVENT = AUTOMATION_SEGMENT_MEMBERSHIP_EVENT;
 exports.AUTOMATION_SEGMENT_MEMBERSHIP_FOLKS = AUTOMATION_SEGMENT_MEMBERSHIP_FOLKS;
+exports.AUTOMATION_UNARY_OPERATORS = AUTOMATION_UNARY_OPERATORS;
 exports.COLORS_DEFAULT = COLORS_DEFAULT;
 exports.DEFAULT_SEGMENT_PAGE_SIZE = DEFAULT_SEGMENT_PAGE_SIZE;
 exports.EMAIL_CONTENT_FORMATS = EMAIL_CONTENT_FORMATS;
@@ -6601,6 +7100,7 @@ exports.TemplateManager = TemplateManager;
 exports.actionRetryDelayMs = actionRetryDelayMs;
 exports.activityBuilder = activityBuilder;
 exports.appendUnsubscribeFooter = appendUnsubscribeFooter;
+exports.applyAutomationConditionals = applyAutomationConditionals;
 exports.applySegmentMembership = applySegmentMembership;
 exports.assignmentRule = assignmentRule;
 exports.blocksToHtml = blocksToHtml;
@@ -6635,12 +7135,14 @@ exports.expandRepeatRows = expandRepeatRows;
 exports.featuredFieldCode = featuredFieldCode;
 exports.fieldChangeRule = fieldChangeRule;
 exports.findUnresolvedPlaceholders = findUnresolvedPlaceholders;
+exports.formatConditionalToken = formatConditionalToken;
 exports.gatherAssociatedTypes = gatherAssociatedTypes;
 exports.gatherDependentServicesType = gatherDependentServicesType;
 exports.generateFieldsFromSchema = generateFieldsFromSchema;
 exports.getRecordReferenceFields = getRecordReferenceFields;
 exports.getUserActionsMap = getUserActionsMap;
 exports.isActionOutcomeEnvelope = isActionOutcomeEnvelope;
+exports.isAutomationConditionMatched = isAutomationConditionMatched;
 exports.isPropertyFilterOperator = isPropertyFilterOperator;
 exports.isSegmentMembershipTrigger = isSegmentMembershipTrigger;
 exports.measureSegmentRelations = measureSegmentRelations;
@@ -6649,6 +7151,7 @@ exports.mergePropertyData = mergePropertyData;
 exports.namespacePaths = namespacePaths;
 exports.normalizeDiffs = normalizeDiffs;
 exports.normalizeExportLimit = normalizeExportLimit;
+exports.parseConditionalToken = parseConditionalToken;
 exports.parsePropertyFilterConditions = parsePropertyFilterConditions;
 exports.planValueRefs = planValueRefs;
 exports.projectionForRequests = projectionForRequests;
@@ -6682,4 +7185,5 @@ exports.sendSegmentMaterialized = sendSegmentMaterialized;
 exports.sendSegmentMembershipToAutomations = sendSegmentMembershipToAutomations;
 exports.splitSegmentFieldRequests = splitSegmentFieldRequests;
 exports.userActionsMap = userActionsMap;
+exports.validateAutomationConditional = validateAutomationConditional;
 exports.validateWorkflowBindings = validateWorkflowBindings;