@budibase/backend-core 2.19.1 → 2.19.2

package/dist/index.js

@@ -325,6 +325,3844 @@ var require_dayjs_min = __commonJS({
   }
 });
 
+// ../../node_modules/cron-validate/lib/result.js
+var require_result = __commonJS({
+  "../../node_modules/cron-validate/lib/result.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Err = exports.Valid = exports.err = exports.valid = void 0;
+    var valid = (value) => new Valid(value);
+    exports.valid = valid;
+    var err = (error) => new Err(error);
+    exports.err = err;
+    var Valid = class {
+      constructor(value) {
+        this.value = value;
+      }
+      isValid() {
+        return true;
+      }
+      isError() {
+        return !this.isValid();
+      }
+      getValue() {
+        return this.value;
+      }
+      getError() {
+        throw new Error("Tried to get error from a valid.");
+      }
+      map(func) {
+        return (0, exports.valid)(func(this.value));
+      }
+      mapErr(func) {
+        return (0, exports.valid)(this.value);
+      }
+    };
+    exports.Valid = Valid;
+    var Err = class {
+      constructor(error) {
+        this.error = error;
+      }
+      isError() {
+        return true;
+      }
+      isValid() {
+        return !this.isError();
+      }
+      getValue() {
+        throw new Error("Tried to get success value from an error.");
+      }
+      getError() {
+        return this.error;
+      }
+      map(func) {
+        return (0, exports.err)(this.error);
+      }
+      mapErr(func) {
+        return (0, exports.err)(func(this.error));
+      }
+    };
+    exports.Err = Err;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/types.js
+var require_types = __commonJS({
+  "../../node_modules/cron-validate/lib/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/cron-validate/lib/helper.js
+var require_helper = __commonJS({
+  "../../node_modules/cron-validate/lib/helper.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    require_types();
+    var monthAliases = [
+      "jan",
+      "feb",
+      "mar",
+      "apr",
+      "may",
+      "jun",
+      "jul",
+      "aug",
+      "sep",
+      "oct",
+      "nov",
+      "dec"
+    ];
+    var daysOfWeekAliases = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+    var checkWildcardLimit = (cronFieldType, options2) => options2[cronFieldType].lowerLimit === options2.preset[cronFieldType].minValue && options2[cronFieldType].upperLimit === options2.preset[cronFieldType].maxValue;
+    var checkSingleElementWithinLimits = (element, cronFieldType, options2) => {
+      if (cronFieldType === "months" && options2.useAliases && monthAliases.indexOf(element.toLowerCase()) !== -1) {
+        return (0, result_1.valid)(true);
+      }
+      if (cronFieldType === "daysOfWeek" && options2.useAliases && daysOfWeekAliases.indexOf(element.toLowerCase()) !== -1) {
+        return (0, result_1.valid)(true);
+      }
+      const number = Number(element);
+      if (isNaN(number)) {
+        return (0, result_1.err)(`Element '${element} of ${cronFieldType} field is invalid.`);
+      }
+      const { lowerLimit } = options2[cronFieldType];
+      const { upperLimit } = options2[cronFieldType];
+      if (lowerLimit && number < lowerLimit) {
+        return (0, result_1.err)(`Number ${number} of ${cronFieldType} field is smaller than lower limit '${lowerLimit}'`);
+      }
+      if (upperLimit && number > upperLimit) {
+        return (0, result_1.err)(`Number ${number} of ${cronFieldType} field is bigger than upper limit '${upperLimit}'`);
+      }
+      return (0, result_1.valid)(true);
+    };
+    var checkSingleElement = (element, cronFieldType, options2) => {
+      if (element === "*") {
+        if (!checkWildcardLimit(cronFieldType, options2)) {
+          return (0, result_1.err)(`Field ${cronFieldType} uses wildcard '*', but is limited to ${options2[cronFieldType].lowerLimit}-${options2[cronFieldType].upperLimit}`);
+        }
+        return (0, result_1.valid)(true);
+      }
+      if (element === "") {
+        return (0, result_1.err)(`One of the elements is empty in ${cronFieldType} field.`);
+      }
+      if (cronFieldType === "daysOfMonth" && options2.useLastDayOfMonth && element === "L") {
+        return (0, result_1.valid)(true);
+      }
+      if (cronFieldType === "daysOfWeek" && options2.useLastDayOfWeek && element.endsWith("L")) {
+        const day = element.slice(0, -1);
+        if (day === "") {
+          return (0, result_1.valid)(true);
+        }
+        return checkSingleElementWithinLimits(day, cronFieldType, options2);
+      }
+      if (cronFieldType === "daysOfMonth" && options2.useNearestWeekday && element.endsWith("W")) {
+        const day = element.slice(0, -1);
+        if (day === "") {
+          return (0, result_1.err)(`The 'W' must be preceded by a day`);
+        }
+        if (options2.useLastDayOfMonth && day === "L") {
+          return (0, result_1.valid)(true);
+        }
+        return checkSingleElementWithinLimits(day, cronFieldType, options2);
+      }
+      if (cronFieldType === "daysOfWeek" && options2.useNthWeekdayOfMonth && element.indexOf("#") !== -1) {
+        const [day, occurrence, ...leftOvers] = element.split("#");
+        if (leftOvers.length !== 0) {
+          return (0, result_1.err)(`Unexpected number of '#' in ${element}, can only be used once.`);
+        }
+        const occurrenceNum = Number(occurrence);
+        if (!occurrence || isNaN(occurrenceNum)) {
+          return (0, result_1.err)(`Unexpected value following the '#' symbol, a positive number was expected but found ${occurrence}.`);
+        }
+        if (occurrenceNum > 5) {
+          return (0, result_1.err)(`Number of occurrence of the day of the week cannot be greater than 5.`);
+        }
+        return checkSingleElementWithinLimits(day, cronFieldType, options2);
+      }
+      return checkSingleElementWithinLimits(element, cronFieldType, options2);
+    };
+    var checkRangeElement = (element, cronFieldType, options2, position) => {
+      if (element === "*") {
+        return (0, result_1.err)(`'*' can't be part of a range in ${cronFieldType} field.`);
+      }
+      if (element === "") {
+        return (0, result_1.err)(`One of the range elements is empty in ${cronFieldType} field.`);
+      }
+      if (options2.useLastDayOfMonth && cronFieldType === "daysOfMonth" && element === "L" && position === 0) {
+        return (0, result_1.valid)(true);
+      }
+      return checkSingleElementWithinLimits(element, cronFieldType, options2);
+    };
+    var checkFirstStepElement = (firstStepElement, cronFieldType, options2) => {
+      const rangeArray = firstStepElement.split("-");
+      if (rangeArray.length > 2) {
+        return (0, result_1.err)(`List element '${firstStepElement}' is not valid. (More than one '-')`);
+      }
+      if (rangeArray.length === 1) {
+        return checkSingleElement(rangeArray[0], cronFieldType, options2);
+      }
+      if (rangeArray.length === 2) {
+        const firstRangeElementResult = checkRangeElement(rangeArray[0], cronFieldType, options2, 0);
+        const secondRangeElementResult = checkRangeElement(rangeArray[1], cronFieldType, options2, 1);
+        if (firstRangeElementResult.isError()) {
+          return firstRangeElementResult;
+        }
+        if (secondRangeElementResult.isError()) {
+          return secondRangeElementResult;
+        }
+        if (Number(rangeArray[0]) > Number(rangeArray[1])) {
+          return (0, result_1.err)(`Lower range end '${rangeArray[0]}' is bigger than upper range end '${rangeArray[1]}' of ${cronFieldType} field.`);
+        }
+        return (0, result_1.valid)(true);
+      }
+      return (0, result_1.err)("Some other error in checkFirstStepElement (rangeArray less than 1)");
+    };
+    var checkListElement = (listElement, cronFieldType, options2) => {
+      const stepArray = listElement.split("/");
+      if (stepArray.length > 2) {
+        return (0, result_1.err)(`List element '${listElement}' is not valid. (More than one '/')`);
+      }
+      const firstElementResult = checkFirstStepElement(stepArray[0], cronFieldType, options2);
+      if (firstElementResult.isError()) {
+        return firstElementResult;
+      }
+      if (stepArray.length === 2) {
+        const secondStepElement = stepArray[1];
+        if (!secondStepElement) {
+          return (0, result_1.err)(`Second step element '${secondStepElement}' of '${listElement}' is not valid (doesnt exist).`);
+        }
+        if (isNaN(Number(secondStepElement))) {
+          return (0, result_1.err)(`Second step element '${secondStepElement}' of '${listElement}' is not valid (not a number).`);
+        }
+        if (Number(secondStepElement) === 0) {
+          return (0, result_1.err)(`Second step element '${secondStepElement}' of '${listElement}' cannot be zero.`);
+        }
+      }
+      return (0, result_1.valid)(true);
+    };
+    var checkField = (cronField, cronFieldType, options2) => {
+      if (![
+        "seconds",
+        "minutes",
+        "hours",
+        "daysOfMonth",
+        "months",
+        "daysOfWeek",
+        "years"
+      ].includes(cronFieldType)) {
+        return (0, result_1.err)([`Cron field type '${cronFieldType}' does not exist.`]);
+      }
+      if (cronField === "?") {
+        if (cronFieldType === "daysOfMonth" || cronFieldType === "daysOfWeek") {
+          if (options2.useBlankDay) {
+            return (0, result_1.valid)(true);
+          }
+          return (0, result_1.err)([
+            `useBlankDay is not enabled, but is used in ${cronFieldType} field`
+          ]);
+        }
+        return (0, result_1.err)([`blank notation is not allowed in ${cronFieldType} field`]);
+      }
+      const listArray = cronField.split(",");
+      const checkResults = [];
+      listArray.forEach((listElement) => {
+        checkResults.push(checkListElement(listElement, cronFieldType, options2));
+      });
+      if (checkResults.every((value) => value.isValid())) {
+        return (0, result_1.valid)(true);
+      }
+      const errorArray = [];
+      checkResults.forEach((result) => {
+        if (result.isError()) {
+          errorArray.push(result.getError());
+        }
+      });
+      return (0, result_1.err)(errorArray);
+    };
+    exports.default = checkField;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/fieldCheckers/secondChecker.js
+var require_secondChecker = __commonJS({
+  "../../node_modules/cron-validate/lib/fieldCheckers/secondChecker.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    var helper_1 = __importDefault(require_helper());
+    require_types();
+    var checkSeconds = (cronData, options2) => {
+      if (!cronData.seconds) {
+        return (0, result_1.err)([
+          "seconds field is undefined, but useSeconds options is enabled."
+        ]);
+      }
+      const { seconds } = cronData;
+      return (0, helper_1.default)(seconds, "seconds", options2);
+    };
+    exports.default = checkSeconds;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/fieldCheckers/minuteChecker.js
+var require_minuteChecker = __commonJS({
+  "../../node_modules/cron-validate/lib/fieldCheckers/minuteChecker.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    var helper_1 = __importDefault(require_helper());
+    require_types();
+    var checkMinutes = (cronData, options2) => {
+      if (!cronData.minutes) {
+        return (0, result_1.err)(["minutes field is undefined."]);
+      }
+      const { minutes } = cronData;
+      return (0, helper_1.default)(minutes, "minutes", options2);
+    };
+    exports.default = checkMinutes;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/fieldCheckers/hourChecker.js
+var require_hourChecker = __commonJS({
+  "../../node_modules/cron-validate/lib/fieldCheckers/hourChecker.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    var helper_1 = __importDefault(require_helper());
+    require_types();
+    var checkHours = (cronData, options2) => {
+      if (!cronData.hours) {
+        return (0, result_1.err)(["hours field is undefined."]);
+      }
+      const { hours } = cronData;
+      return (0, helper_1.default)(hours, "hours", options2);
+    };
+    exports.default = checkHours;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/fieldCheckers/dayOfMonthChecker.js
+var require_dayOfMonthChecker = __commonJS({
+  "../../node_modules/cron-validate/lib/fieldCheckers/dayOfMonthChecker.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    var helper_1 = __importDefault(require_helper());
+    require_types();
+    var checkDaysOfMonth = (cronData, options2) => {
+      if (!cronData.daysOfMonth) {
+        return (0, result_1.err)(["daysOfMonth field is undefined."]);
+      }
+      const { daysOfMonth } = cronData;
+      if (options2.allowOnlyOneBlankDayField && options2.useBlankDay && cronData.daysOfMonth === "?" && cronData.daysOfWeek === "?") {
+        return (0, result_1.err)([
+          `Cannot use blank value in daysOfMonth and daysOfWeek field when allowOnlyOneBlankDayField option is enabled.`
+        ]);
+      }
+      if (options2.mustHaveBlankDayField && cronData.daysOfMonth !== "?" && cronData.daysOfWeek !== "?") {
+        return (0, result_1.err)([
+          `Cannot specify both daysOfMonth and daysOfWeek field when mustHaveBlankDayField option is enabled.`
+        ]);
+      }
+      if (options2.useLastDayOfMonth && cronData.daysOfMonth.indexOf("L") !== -1 && cronData.daysOfMonth.match(/[,/]/)) {
+        return (0, result_1.err)([
+          `Cannot specify last day of month with lists, or ranges (symbols ,/).`
+        ]);
+      }
+      if (options2.useNearestWeekday && cronData.daysOfMonth.indexOf("W") !== -1 && cronData.daysOfMonth.match(/[,/-]/)) {
+        return (0, result_1.err)([
+          `Cannot specify nearest weekday with lists, steps or ranges (symbols ,-/).`
+        ]);
+      }
+      return (0, helper_1.default)(daysOfMonth, "daysOfMonth", options2);
+    };
+    exports.default = checkDaysOfMonth;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/fieldCheckers/monthChecker.js
+var require_monthChecker = __commonJS({
+  "../../node_modules/cron-validate/lib/fieldCheckers/monthChecker.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    var helper_1 = __importDefault(require_helper());
+    require_types();
+    var checkMonths = (cronData, options2) => {
+      if (!cronData.months) {
+        return (0, result_1.err)(["months field is undefined."]);
+      }
+      const { months } = cronData;
+      return (0, helper_1.default)(months, "months", options2);
+    };
+    exports.default = checkMonths;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/fieldCheckers/dayOfWeekChecker.js
+var require_dayOfWeekChecker = __commonJS({
+  "../../node_modules/cron-validate/lib/fieldCheckers/dayOfWeekChecker.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    var helper_1 = __importDefault(require_helper());
+    require_types();
+    var checkDaysOfWeek = (cronData, options2) => {
+      if (!cronData.daysOfWeek) {
+        return (0, result_1.err)(["daysOfWeek field is undefined."]);
+      }
+      const { daysOfWeek } = cronData;
+      if (options2.allowOnlyOneBlankDayField && cronData.daysOfMonth === "?" && cronData.daysOfWeek === "?") {
+        return (0, result_1.err)([
+          `Cannot use blank value in daysOfMonth and daysOfWeek field when allowOnlyOneBlankDayField option is enabled.`
+        ]);
+      }
+      if (options2.mustHaveBlankDayField && cronData.daysOfMonth !== "?" && cronData.daysOfWeek !== "?") {
+        return (0, result_1.err)([
+          `Cannot specify both daysOfMonth and daysOfWeek field when mustHaveBlankDayField option is enabled.`
+        ]);
+      }
+      if (options2.useLastDayOfWeek && cronData.daysOfWeek.indexOf("L") !== -1 && cronData.daysOfWeek.match(/[,/-]/)) {
+        return (0, result_1.err)([
+          `Cannot specify last day of week with lists, steps or ranges (symbols ,-/).`
+        ]);
+      }
+      if (options2.useNthWeekdayOfMonth && cronData.daysOfWeek.indexOf("#") !== -1 && cronData.daysOfWeek.match(/[,/-]/)) {
+        return (0, result_1.err)([
+          `Cannot specify Nth weekday of month with lists, steps or ranges (symbols ,-/).`
+        ]);
+      }
+      return (0, helper_1.default)(daysOfWeek, "daysOfWeek", options2);
+    };
+    exports.default = checkDaysOfWeek;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/fieldCheckers/yearChecker.js
+var require_yearChecker = __commonJS({
+  "../../node_modules/cron-validate/lib/fieldCheckers/yearChecker.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    require_lib2();
+    var result_1 = require_result();
+    var helper_1 = __importDefault(require_helper());
+    require_types();
+    var checkYears = (cronData, options2) => {
+      if (!cronData.years) {
+        return (0, result_1.err)(["years field is undefined, but useYears option is enabled."]);
+      }
+      const { years } = cronData;
+      return (0, helper_1.default)(years, "years", options2);
+    };
+    exports.default = checkYears;
+  }
+});
+
+// ../../node_modules/nanoclone/index.js
+var require_nanoclone = __commonJS({
+  "../../node_modules/nanoclone/index.js"(exports, module2) {
+    "use strict";
+    var map;
+    try {
+      map = Map;
+    } catch (_2) {
+    }
+    var set2;
+    try {
+      set2 = Set;
+    } catch (_2) {
+    }
+    function baseClone(src, circulars, clones) {
+      if (!src || typeof src !== "object" || typeof src === "function") {
+        return src;
+      }
+      if (src.nodeType && "cloneNode" in src) {
+        return src.cloneNode(true);
+      }
+      if (src instanceof Date) {
+        return new Date(src.getTime());
+      }
+      if (src instanceof RegExp) {
+        return new RegExp(src);
+      }
+      if (Array.isArray(src)) {
+        return src.map(clone);
+      }
+      if (map && src instanceof map) {
+        return new Map(Array.from(src.entries()));
+      }
+      if (set2 && src instanceof set2) {
+        return new Set(Array.from(src.values()));
+      }
+      if (src instanceof Object) {
+        circulars.push(src);
+        var obj = Object.create(src);
+        clones.push(obj);
+        for (var key in src) {
+          var idx = circulars.findIndex(function(i) {
+            return i === src[key];
+          });
+          obj[key] = idx > -1 ? clones[idx] : baseClone(src[key], circulars, clones);
+        }
+        return obj;
+      }
+      return src;
+    }
+    function clone(src) {
+      return baseClone(src, [], []);
+    }
+    module2.exports = clone;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/printValue.js
+var require_printValue = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/printValue.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = printValue;
+    var toString = Object.prototype.toString;
+    var errorToString = Error.prototype.toString;
+    var regExpToString = RegExp.prototype.toString;
+    var symbolToString = typeof Symbol !== "undefined" ? Symbol.prototype.toString : () => "";
+    var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+    function printNumber(val) {
+      if (val != +val)
+        return "NaN";
+      const isNegativeZero = val === 0 && 1 / val < 0;
+      return isNegativeZero ? "-0" : "" + val;
+    }
+    function printSimpleValue(val, quoteStrings = false) {
+      if (val == null || val === true || val === false)
+        return "" + val;
+      const typeOf = typeof val;
+      if (typeOf === "number")
+        return printNumber(val);
+      if (typeOf === "string")
+        return quoteStrings ? `"${val}"` : val;
+      if (typeOf === "function")
+        return "[Function " + (val.name || "anonymous") + "]";
+      if (typeOf === "symbol")
+        return symbolToString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+      const tag = toString.call(val).slice(8, -1);
+      if (tag === "Date")
+        return isNaN(val.getTime()) ? "" + val : val.toISOString(val);
+      if (tag === "Error" || val instanceof Error)
+        return "[" + errorToString.call(val) + "]";
+      if (tag === "RegExp")
+        return regExpToString.call(val);
+      return null;
+    }
+    function printValue(value, quoteStrings) {
+      let result = printSimpleValue(value, quoteStrings);
+      if (result !== null)
+        return result;
+      return JSON.stringify(value, function(key, value2) {
+        let result2 = printSimpleValue(this[key], quoteStrings);
+        if (result2 !== null)
+          return result2;
+        return value2;
+      }, 2);
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/locale.js
+var require_locale = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/locale.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = exports.array = exports.object = exports.boolean = exports.date = exports.number = exports.string = exports.mixed = void 0;
+    var _printValue = _interopRequireDefault(require_printValue());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var mixed = {
+      default: "${path} is invalid",
+      required: "${path} is a required field",
+      oneOf: "${path} must be one of the following values: ${values}",
+      notOneOf: "${path} must not be one of the following values: ${values}",
+      notType: ({
+        path: path2,
+        type,
+        value,
+        originalValue
+      }) => {
+        let isCast = originalValue != null && originalValue !== value;
+        let msg = `${path2} must be a \`${type}\` type, but the final value was: \`${(0, _printValue.default)(value, true)}\`` + (isCast ? ` (cast from the value \`${(0, _printValue.default)(originalValue, true)}\`).` : ".");
+        if (value === null) {
+          msg += `
+ If "null" is intended as an empty value be sure to mark the schema as \`.nullable()\``;
+        }
+        return msg;
+      },
+      defined: "${path} must be defined"
+    };
+    exports.mixed = mixed;
+    var string = {
+      length: "${path} must be exactly ${length} characters",
+      min: "${path} must be at least ${min} characters",
+      max: "${path} must be at most ${max} characters",
+      matches: '${path} must match the following: "${regex}"',
+      email: "${path} must be a valid email",
+      url: "${path} must be a valid URL",
+      uuid: "${path} must be a valid UUID",
+      trim: "${path} must be a trimmed string",
+      lowercase: "${path} must be a lowercase string",
+      uppercase: "${path} must be a upper case string"
+    };
+    exports.string = string;
+    var number = {
+      min: "${path} must be greater than or equal to ${min}",
+      max: "${path} must be less than or equal to ${max}",
+      lessThan: "${path} must be less than ${less}",
+      moreThan: "${path} must be greater than ${more}",
+      positive: "${path} must be a positive number",
+      negative: "${path} must be a negative number",
+      integer: "${path} must be an integer"
+    };
+    exports.number = number;
+    var date = {
+      min: "${path} field must be later than ${min}",
+      max: "${path} field must be at earlier than ${max}"
+    };
+    exports.date = date;
+    var boolean = {
+      isValue: "${path} field must be ${value}"
+    };
+    exports.boolean = boolean;
+    var object = {
+      noUnknown: "${path} field has unspecified keys: ${unknown}"
+    };
+    exports.object = object;
+    var array = {
+      min: "${path} field must have at least ${min} items",
+      max: "${path} field must have less than or equal to ${max} items",
+      length: "${path} must be have ${length} items"
+    };
+    exports.array = array;
+    var _default = Object.assign(/* @__PURE__ */ Object.create(null), {
+      mixed,
+      string,
+      number,
+      date,
+      object,
+      array,
+      boolean
+    });
+    exports.default = _default;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/isSchema.js
+var require_isSchema = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/isSchema.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _default = (obj) => obj && obj.__isYupSchema__;
+    exports.default = _default;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/Condition.js
+var require_Condition = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/Condition.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _has = _interopRequireDefault(require("lodash/has"));
+    var _isSchema = _interopRequireDefault(require_isSchema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var Condition = class {
+      constructor(refs, options2) {
+        this.refs = refs;
+        this.refs = refs;
+        if (typeof options2 === "function") {
+          this.fn = options2;
+          return;
+        }
+        if (!(0, _has.default)(options2, "is"))
+          throw new TypeError("`is:` is required for `when()` conditions");
+        if (!options2.then && !options2.otherwise)
+          throw new TypeError("either `then:` or `otherwise:` is required for `when()` conditions");
+        let {
+          is,
+          then,
+          otherwise
+        } = options2;
+        let check = typeof is === "function" ? is : (...values2) => values2.every((value) => value === is);
+        this.fn = function(...args) {
+          let options3 = args.pop();
+          let schema = args.pop();
+          let branch = check(...args) ? then : otherwise;
+          if (!branch)
+            return void 0;
+          if (typeof branch === "function")
+            return branch(schema);
+          return schema.concat(branch.resolve(options3));
+        };
+      }
+      resolve(base, options2) {
+        let values2 = this.refs.map((ref) => ref.getValue(options2 == null ? void 0 : options2.value, options2 == null ? void 0 : options2.parent, options2 == null ? void 0 : options2.context));
+        let schema = this.fn.apply(base, values2.concat(base, options2));
+        if (schema === void 0 || schema === base)
+          return base;
+        if (!(0, _isSchema.default)(schema))
+          throw new TypeError("conditions must return a schema object");
+        return schema.resolve(options2);
+      }
+    };
+    var _default = Condition;
+    exports.default = _default;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/toArray.js
+var require_toArray = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/toArray.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = toArray;
+    function toArray(value) {
+      return value == null ? [] : [].concat(value);
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/ValidationError.js
+var require_ValidationError = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/ValidationError.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _printValue = _interopRequireDefault(require_printValue());
+    var _toArray = _interopRequireDefault(require_toArray());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _extends() {
+      _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    var strReg = /\$\{\s*(\w+)\s*\}/g;
+    var ValidationError = class _ValidationError extends Error {
+      static formatError(message, params2) {
+        const path2 = params2.label || params2.path || "this";
+        if (path2 !== params2.path)
+          params2 = _extends({}, params2, {
+            path: path2
+          });
+        if (typeof message === "string")
+          return message.replace(strReg, (_2, key) => (0, _printValue.default)(params2[key]));
+        if (typeof message === "function")
+          return message(params2);
+        return message;
+      }
+      static isError(err) {
+        return err && err.name === "ValidationError";
+      }
+      constructor(errorOrErrors, value, field, type) {
+        super();
+        this.name = "ValidationError";
+        this.value = value;
+        this.path = field;
+        this.type = type;
+        this.errors = [];
+        this.inner = [];
+        (0, _toArray.default)(errorOrErrors).forEach((err) => {
+          if (_ValidationError.isError(err)) {
+            this.errors.push(...err.errors);
+            this.inner = this.inner.concat(err.inner.length ? err.inner : err);
+          } else {
+            this.errors.push(err);
+          }
+        });
+        this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(this, _ValidationError);
+      }
+    };
+    exports.default = ValidationError;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/runTests.js
+var require_runTests = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/runTests.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = runTests;
+    var _ValidationError = _interopRequireDefault(require_ValidationError());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var once = (cb) => {
+      let fired = false;
+      return (...args) => {
+        if (fired)
+          return;
+        fired = true;
+        cb(...args);
+      };
+    };
+    function runTests(options2, cb) {
+      let {
+        endEarly,
+        tests,
+        args,
+        value,
+        errors,
+        sort,
+        path: path2
+      } = options2;
+      let callback = once(cb);
+      let count = tests.length;
+      const nestedErrors = [];
+      errors = errors ? errors : [];
+      if (!count)
+        return errors.length ? callback(new _ValidationError.default(errors, value, path2)) : callback(null, value);
+      for (let i = 0; i < tests.length; i++) {
+        const test = tests[i];
+        test(args, function finishTestRun(err) {
+          if (err) {
+            if (!_ValidationError.default.isError(err)) {
+              return callback(err, value);
+            }
+            if (endEarly) {
+              err.value = value;
+              return callback(err, value);
+            }
+            nestedErrors.push(err);
+          }
+          if (--count <= 0) {
+            if (nestedErrors.length) {
+              if (sort)
+                nestedErrors.sort(sort);
+              if (errors.length)
+                nestedErrors.push(...errors);
+              errors = nestedErrors;
+            }
+            if (errors.length) {
+              callback(new _ValidationError.default(errors, value, path2), value);
+              return;
+            }
+            callback(null, value);
+          }
+        });
+      }
+    }
+  }
+});
+
+// ../../node_modules/property-expr/index.js
+var require_property_expr = __commonJS({
+  "../../node_modules/property-expr/index.js"(exports, module2) {
+    "use strict";
+    function Cache(maxSize) {
+      this._maxSize = maxSize;
+      this.clear();
+    }
+    Cache.prototype.clear = function() {
+      this._size = 0;
+      this._values = /* @__PURE__ */ Object.create(null);
+    };
+    Cache.prototype.get = function(key) {
+      return this._values[key];
+    };
+    Cache.prototype.set = function(key, value) {
+      this._size >= this._maxSize && this.clear();
+      if (!(key in this._values))
+        this._size++;
+      return this._values[key] = value;
+    };
+    var SPLIT_REGEX = /[^.^\]^[]+|(?=\[\]|\.\.)/g;
+    var DIGIT_REGEX = /^\d+$/;
+    var LEAD_DIGIT_REGEX = /^\d/;
+    var SPEC_CHAR_REGEX = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g;
+    var CLEAN_QUOTES_REGEX = /^\s*(['"]?)(.*?)(\1)\s*$/;
+    var MAX_CACHE_SIZE = 512;
+    var pathCache = new Cache(MAX_CACHE_SIZE);
+    var setCache = new Cache(MAX_CACHE_SIZE);
+    var getCache2 = new Cache(MAX_CACHE_SIZE);
+    module2.exports = {
+      Cache,
+      split,
+      normalizePath,
+      setter: function(path2) {
+        var parts = normalizePath(path2);
+        return setCache.get(path2) || setCache.set(path2, function setter(obj, value) {
+          var index2 = 0;
+          var len = parts.length;
+          var data = obj;
+          while (index2 < len - 1) {
+            var part = parts[index2];
+            if (part === "__proto__" || part === "constructor" || part === "prototype") {
+              return obj;
+            }
+            data = data[parts[index2++]];
+          }
+          data[parts[index2]] = value;
+        });
+      },
+      getter: function(path2, safe) {
+        var parts = normalizePath(path2);
+        return getCache2.get(path2) || getCache2.set(path2, function getter(data) {
+          var index2 = 0, len = parts.length;
+          while (index2 < len) {
+            if (data != null || !safe)
+              data = data[parts[index2++]];
+            else
+              return;
+          }
+          return data;
+        });
+      },
+      join: function(segments) {
+        return segments.reduce(function(path2, part) {
+          return path2 + (isQuoted(part) || DIGIT_REGEX.test(part) ? "[" + part + "]" : (path2 ? "." : "") + part);
+        }, "");
+      },
+      forEach: function(path2, cb, thisArg) {
+        forEach(Array.isArray(path2) ? path2 : split(path2), cb, thisArg);
+      }
+    };
+    function normalizePath(path2) {
+      return pathCache.get(path2) || pathCache.set(
+        path2,
+        split(path2).map(function(part) {
+          return part.replace(CLEAN_QUOTES_REGEX, "$2");
+        })
+      );
+    }
+    function split(path2) {
+      return path2.match(SPLIT_REGEX) || [""];
+    }
+    function forEach(parts, iter, thisArg) {
+      var len = parts.length, part, idx, isArray, isBracket;
+      for (idx = 0; idx < len; idx++) {
+        part = parts[idx];
+        if (part) {
+          if (shouldBeQuoted(part)) {
+            part = '"' + part + '"';
+          }
+          isBracket = isQuoted(part);
+          isArray = !isBracket && /^\d+$/.test(part);
+          iter.call(thisArg, part, isBracket, isArray, idx, parts);
+        }
+      }
+    }
+    function isQuoted(str) {
+      return typeof str === "string" && str && ["'", '"'].indexOf(str.charAt(0)) !== -1;
+    }
+    function hasLeadingNumber(part) {
+      return part.match(LEAD_DIGIT_REGEX) && !part.match(DIGIT_REGEX);
+    }
+    function hasSpecialChars(part) {
+      return SPEC_CHAR_REGEX.test(part);
+    }
+    function shouldBeQuoted(part) {
+      return !isQuoted(part) && (hasLeadingNumber(part) || hasSpecialChars(part));
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/Reference.js
+var require_Reference = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/Reference.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _propertyExpr = require_property_expr();
+    var prefixes = {
+      context: "$",
+      value: "."
+    };
+    function create(key, options2) {
+      return new Reference(key, options2);
+    }
+    var Reference = class {
+      constructor(key, options2 = {}) {
+        if (typeof key !== "string")
+          throw new TypeError("ref must be a string, got: " + key);
+        this.key = key.trim();
+        if (key === "")
+          throw new TypeError("ref must be a non-empty string");
+        this.isContext = this.key[0] === prefixes.context;
+        this.isValue = this.key[0] === prefixes.value;
+        this.isSibling = !this.isContext && !this.isValue;
+        let prefix = this.isContext ? prefixes.context : this.isValue ? prefixes.value : "";
+        this.path = this.key.slice(prefix.length);
+        this.getter = this.path && (0, _propertyExpr.getter)(this.path, true);
+        this.map = options2.map;
+      }
+      getValue(value, parent, context) {
+        let result = this.isContext ? context : this.isValue ? value : parent;
+        if (this.getter)
+          result = this.getter(result || {});
+        if (this.map)
+          result = this.map(result);
+        return result;
+      }
+      /**
+       *
+       * @param {*} value
+       * @param {Object} options
+       * @param {Object=} options.context
+       * @param {Object=} options.parent
+       */
+      cast(value, options2) {
+        return this.getValue(value, options2 == null ? void 0 : options2.parent, options2 == null ? void 0 : options2.context);
+      }
+      resolve() {
+        return this;
+      }
+      describe() {
+        return {
+          type: "ref",
+          key: this.key
+        };
+      }
+      toString() {
+        return `Ref(${this.key})`;
+      }
+      static isRef(value) {
+        return value && value.__isYupRef;
+      }
+    };
+    exports.default = Reference;
+    Reference.prototype.__isYupRef = true;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/createValidation.js
+var require_createValidation = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/createValidation.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = createValidation;
+    var _mapValues = _interopRequireDefault(require("lodash/mapValues"));
+    var _ValidationError = _interopRequireDefault(require_ValidationError());
+    var _Reference = _interopRequireDefault(require_Reference());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _extends() {
+      _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function _objectWithoutPropertiesLoose(source, excluded) {
+      if (source == null)
+        return {};
+      var target = {};
+      var sourceKeys = Object.keys(source);
+      var key, i;
+      for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0)
+          continue;
+        target[key] = source[key];
+      }
+      return target;
+    }
+    function createValidation(config) {
+      function validate3(_ref, cb) {
+        let {
+          value,
+          path: path2 = "",
+          label,
+          options: options2,
+          originalValue,
+          sync
+        } = _ref, rest = _objectWithoutPropertiesLoose(_ref, ["value", "path", "label", "options", "originalValue", "sync"]);
+        const {
+          name,
+          test,
+          params: params2,
+          message
+        } = config;
+        let {
+          parent,
+          context
+        } = options2;
+        function resolve(item) {
+          return _Reference.default.isRef(item) ? item.getValue(value, parent, context) : item;
+        }
+        function createError(overrides = {}) {
+          const nextParams = (0, _mapValues.default)(_extends({
+            value,
+            originalValue,
+            label,
+            path: overrides.path || path2
+          }, params2, overrides.params), resolve);
+          const error = new _ValidationError.default(_ValidationError.default.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name);
+          error.params = nextParams;
+          return error;
+        }
+        let ctx = _extends({
+          path: path2,
+          parent,
+          type: name,
+          createError,
+          resolve,
+          options: options2,
+          originalValue
+        }, rest);
+        if (!sync) {
+          try {
+            Promise.resolve(test.call(ctx, value, ctx)).then((validOrError) => {
+              if (_ValidationError.default.isError(validOrError))
+                cb(validOrError);
+              else if (!validOrError)
+                cb(createError());
+              else
+                cb(null, validOrError);
+            });
+          } catch (err) {
+            cb(err);
+          }
+          return;
+        }
+        let result;
+        try {
+          var _ref2;
+          result = test.call(ctx, value, ctx);
+          if (typeof ((_ref2 = result) == null ? void 0 : _ref2.then) === "function") {
+            throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. This test will finish after the validate call has returned`);
+          }
+        } catch (err) {
+          cb(err);
+          return;
+        }
+        if (_ValidationError.default.isError(result))
+          cb(result);
+        else if (!result)
+          cb(createError());
+        else
+          cb(null, result);
+      }
+      validate3.OPTIONS = config;
+      return validate3;
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/reach.js
+var require_reach = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/reach.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.getIn = getIn;
+    exports.default = void 0;
+    var _propertyExpr = require_property_expr();
+    var trim = (part) => part.substr(0, part.length - 1).substr(1);
+    function getIn(schema, path2, value, context = value) {
+      let parent, lastPart, lastPartDebug;
+      if (!path2)
+        return {
+          parent,
+          parentPath: path2,
+          schema
+        };
+      (0, _propertyExpr.forEach)(path2, (_part, isBracket, isArray) => {
+        let part = isBracket ? trim(_part) : _part;
+        schema = schema.resolve({
+          context,
+          parent,
+          value
+        });
+        if (schema.innerType) {
+          let idx = isArray ? parseInt(part, 10) : 0;
+          if (value && idx >= value.length) {
+            throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path2}. because there is no value at that index. `);
+          }
+          parent = value;
+          value = value && value[idx];
+          schema = schema.innerType;
+        }
+        if (!isArray) {
+          if (!schema.fields || !schema.fields[part])
+            throw new Error(`The schema does not contain the path: ${path2}. (failed at: ${lastPartDebug} which is a type: "${schema._type}")`);
+          parent = value;
+          value = value && value[part];
+          schema = schema.fields[part];
+        }
+        lastPart = part;
+        lastPartDebug = isBracket ? "[" + _part + "]" : "." + _part;
+      });
+      return {
+        schema,
+        parent,
+        parentPath: lastPart
+      };
+    }
+    var reach = (obj, path2, value, context) => getIn(obj, path2, value, context).schema;
+    var _default = reach;
+    exports.default = _default;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/ReferenceSet.js
+var require_ReferenceSet = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/ReferenceSet.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _Reference = _interopRequireDefault(require_Reference());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var ReferenceSet = class _ReferenceSet {
+      constructor() {
+        this.list = /* @__PURE__ */ new Set();
+        this.refs = /* @__PURE__ */ new Map();
+      }
+      get size() {
+        return this.list.size + this.refs.size;
+      }
+      describe() {
+        const description = [];
+        for (const item of this.list)
+          description.push(item);
+        for (const [, ref] of this.refs)
+          description.push(ref.describe());
+        return description;
+      }
+      toArray() {
+        return Array.from(this.list).concat(Array.from(this.refs.values()));
+      }
+      add(value) {
+        _Reference.default.isRef(value) ? this.refs.set(value.key, value) : this.list.add(value);
+      }
+      delete(value) {
+        _Reference.default.isRef(value) ? this.refs.delete(value.key) : this.list.delete(value);
+      }
+      has(value, resolve) {
+        if (this.list.has(value))
+          return true;
+        let item, values2 = this.refs.values();
+        while (item = values2.next(), !item.done)
+          if (resolve(item.value) === value)
+            return true;
+        return false;
+      }
+      clone() {
+        const next = new _ReferenceSet();
+        next.list = new Set(this.list);
+        next.refs = new Map(this.refs);
+        return next;
+      }
+      merge(newItems, removeItems) {
+        const next = this.clone();
+        newItems.list.forEach((value) => next.add(value));
+        newItems.refs.forEach((value) => next.add(value));
+        removeItems.list.forEach((value) => next.delete(value));
+        removeItems.refs.forEach((value) => next.delete(value));
+        return next;
+      }
+    };
+    exports.default = ReferenceSet;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/schema.js
+var require_schema = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/schema.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _nanoclone = _interopRequireDefault(require_nanoclone());
+    var _locale = require_locale();
+    var _Condition = _interopRequireDefault(require_Condition());
+    var _runTests = _interopRequireDefault(require_runTests());
+    var _createValidation = _interopRequireDefault(require_createValidation());
+    var _printValue = _interopRequireDefault(require_printValue());
+    var _Reference = _interopRequireDefault(require_Reference());
+    var _reach = require_reach();
+    var _toArray = _interopRequireDefault(require_toArray());
+    var _ValidationError = _interopRequireDefault(require_ValidationError());
+    var _ReferenceSet = _interopRequireDefault(require_ReferenceSet());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _extends() {
+      _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    var BaseSchema = class {
+      constructor(options2) {
+        this.deps = [];
+        this.conditions = [];
+        this._whitelist = new _ReferenceSet.default();
+        this._blacklist = new _ReferenceSet.default();
+        this.exclusiveTests = /* @__PURE__ */ Object.create(null);
+        this.tests = [];
+        this.transforms = [];
+        this.withMutation(() => {
+          this.typeError(_locale.mixed.notType);
+        });
+        this.type = (options2 == null ? void 0 : options2.type) || "mixed";
+        this.spec = _extends({
+          strip: false,
+          strict: false,
+          abortEarly: true,
+          recursive: true,
+          nullable: false,
+          presence: "optional"
+        }, options2 == null ? void 0 : options2.spec);
+      }
+      // TODO: remove
+      get _type() {
+        return this.type;
+      }
+      _typeCheck(_value) {
+        return true;
+      }
+      clone(spec) {
+        if (this._mutate) {
+          if (spec)
+            Object.assign(this.spec, spec);
+          return this;
+        }
+        const next = Object.create(Object.getPrototypeOf(this));
+        next.type = this.type;
+        next._typeError = this._typeError;
+        next._whitelistError = this._whitelistError;
+        next._blacklistError = this._blacklistError;
+        next._whitelist = this._whitelist.clone();
+        next._blacklist = this._blacklist.clone();
+        next.exclusiveTests = _extends({}, this.exclusiveTests);
+        next.deps = [...this.deps];
+        next.conditions = [...this.conditions];
+        next.tests = [...this.tests];
+        next.transforms = [...this.transforms];
+        next.spec = (0, _nanoclone.default)(_extends({}, this.spec, spec));
+        return next;
+      }
+      label(label) {
+        var next = this.clone();
+        next.spec.label = label;
+        return next;
+      }
+      meta(...args) {
+        if (args.length === 0)
+          return this.spec.meta;
+        let next = this.clone();
+        next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);
+        return next;
+      }
+      // withContext<TContext extends AnyObject>(): BaseSchema<
+      //   TCast,
+      //   TContext,
+      //   TOutput
+      // > {
+      //   return this as any;
+      // }
+      withMutation(fn) {
+        let before = this._mutate;
+        this._mutate = true;
+        let result = fn(this);
+        this._mutate = before;
+        return result;
+      }
+      concat(schema) {
+        if (!schema || schema === this)
+          return this;
+        if (schema.type !== this.type && this.type !== "mixed")
+          throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema.type}`);
+        let base = this;
+        let combined = schema.clone();
+        const mergedSpec = _extends({}, base.spec, combined.spec);
+        combined.spec = mergedSpec;
+        combined._typeError || (combined._typeError = base._typeError);
+        combined._whitelistError || (combined._whitelistError = base._whitelistError);
+        combined._blacklistError || (combined._blacklistError = base._blacklistError);
+        combined._whitelist = base._whitelist.merge(schema._whitelist, schema._blacklist);
+        combined._blacklist = base._blacklist.merge(schema._blacklist, schema._whitelist);
+        combined.tests = base.tests;
+        combined.exclusiveTests = base.exclusiveTests;
+        combined.withMutation((next) => {
+          schema.tests.forEach((fn) => {
+            next.test(fn.OPTIONS);
+          });
+        });
+        return combined;
+      }
+      isType(v) {
+        if (this.spec.nullable && v === null)
+          return true;
+        return this._typeCheck(v);
+      }
+      resolve(options2) {
+        let schema = this;
+        if (schema.conditions.length) {
+          let conditions = schema.conditions;
+          schema = schema.clone();
+          schema.conditions = [];
+          schema = conditions.reduce((schema2, condition) => condition.resolve(schema2, options2), schema);
+          schema = schema.resolve(options2);
+        }
+        return schema;
+      }
+      /**
+       *
+       * @param {*} value
+       * @param {Object} options
+       * @param {*=} options.parent
+       * @param {*=} options.context
+       */
+      cast(value, options2 = {}) {
+        let resolvedSchema = this.resolve(_extends({
+          value
+        }, options2));
+        let result = resolvedSchema._cast(value, options2);
+        if (value !== void 0 && options2.assert !== false && resolvedSchema.isType(result) !== true) {
+          let formattedValue = (0, _printValue.default)(value);
+          let formattedResult = (0, _printValue.default)(result);
+          throw new TypeError(`The value of ${options2.path || "field"} could not be cast to a value that satisfies the schema type: "${resolvedSchema._type}". 
+
+attempted value: ${formattedValue} 
+` + (formattedResult !== formattedValue ? `result of cast: ${formattedResult}` : ""));
+        }
+        return result;
+      }
+      _cast(rawValue, _options) {
+        let value = rawValue === void 0 ? rawValue : this.transforms.reduce((value2, fn) => fn.call(this, value2, rawValue, this), rawValue);
+        if (value === void 0) {
+          value = this.getDefault();
+        }
+        return value;
+      }
+      _validate(_value, options2 = {}, cb) {
+        let {
+          sync,
+          path: path2,
+          from = [],
+          originalValue = _value,
+          strict = this.spec.strict,
+          abortEarly = this.spec.abortEarly
+        } = options2;
+        let value = _value;
+        if (!strict) {
+          value = this._cast(value, _extends({
+            assert: false
+          }, options2));
+        }
+        let args = {
+          value,
+          path: path2,
+          options: options2,
+          originalValue,
+          schema: this,
+          label: this.spec.label,
+          sync,
+          from
+        };
+        let initialTests = [];
+        if (this._typeError)
+          initialTests.push(this._typeError);
+        if (this._whitelistError)
+          initialTests.push(this._whitelistError);
+        if (this._blacklistError)
+          initialTests.push(this._blacklistError);
+        (0, _runTests.default)({
+          args,
+          value,
+          path: path2,
+          sync,
+          tests: initialTests,
+          endEarly: abortEarly
+        }, (err) => {
+          if (err)
+            return void cb(err, value);
+          (0, _runTests.default)({
+            tests: this.tests,
+            args,
+            path: path2,
+            sync,
+            value,
+            endEarly: abortEarly
+          }, cb);
+        });
+      }
+      validate(value, options2, maybeCb) {
+        let schema = this.resolve(_extends({}, options2, {
+          value
+        }));
+        return typeof maybeCb === "function" ? schema._validate(value, options2, maybeCb) : new Promise((resolve, reject) => schema._validate(value, options2, (err, value2) => {
+          if (err)
+            reject(err);
+          else
+            resolve(value2);
+        }));
+      }
+      validateSync(value, options2) {
+        let schema = this.resolve(_extends({}, options2, {
+          value
+        }));
+        let result;
+        schema._validate(value, _extends({}, options2, {
+          sync: true
+        }), (err, value2) => {
+          if (err)
+            throw err;
+          result = value2;
+        });
+        return result;
+      }
+      isValid(value, options2) {
+        return this.validate(value, options2).then(() => true, (err) => {
+          if (_ValidationError.default.isError(err))
+            return false;
+          throw err;
+        });
+      }
+      isValidSync(value, options2) {
+        try {
+          this.validateSync(value, options2);
+          return true;
+        } catch (err) {
+          if (_ValidationError.default.isError(err))
+            return false;
+          throw err;
+        }
+      }
+      _getDefault() {
+        let defaultValue = this.spec.default;
+        if (defaultValue == null) {
+          return defaultValue;
+        }
+        return typeof defaultValue === "function" ? defaultValue.call(this) : (0, _nanoclone.default)(defaultValue);
+      }
+      getDefault(options2) {
+        let schema = this.resolve(options2 || {});
+        return schema._getDefault();
+      }
+      default(def) {
+        if (arguments.length === 0) {
+          return this._getDefault();
+        }
+        let next = this.clone({
+          default: def
+        });
+        return next;
+      }
+      strict(isStrict = true) {
+        var next = this.clone();
+        next.spec.strict = isStrict;
+        return next;
+      }
+      _isPresent(value) {
+        return value != null;
+      }
+      defined(message = _locale.mixed.defined) {
+        return this.test({
+          message,
+          name: "defined",
+          exclusive: true,
+          test(value) {
+            return value !== void 0;
+          }
+        });
+      }
+      required(message = _locale.mixed.required) {
+        return this.clone({
+          presence: "required"
+        }).withMutation((s) => s.test({
+          message,
+          name: "required",
+          exclusive: true,
+          test(value) {
+            return this.schema._isPresent(value);
+          }
+        }));
+      }
+      notRequired() {
+        var next = this.clone({
+          presence: "optional"
+        });
+        next.tests = next.tests.filter((test) => test.OPTIONS.name !== "required");
+        return next;
+      }
+      nullable(isNullable = true) {
+        var next = this.clone({
+          nullable: isNullable !== false
+        });
+        return next;
+      }
+      transform(fn) {
+        var next = this.clone();
+        next.transforms.push(fn);
+        return next;
+      }
+      /**
+       * Adds a test function to the schema's queue of tests.
+       * tests can be exclusive or non-exclusive.
+       *
+       * - exclusive tests, will replace any existing tests of the same name.
+       * - non-exclusive: can be stacked
+       *
+       * If a non-exclusive test is added to a schema with an exclusive test of the same name
+       * the exclusive test is removed and further tests of the same name will be stacked.
+       *
+       * If an exclusive test is added to a schema with non-exclusive tests of the same name
+       * the previous tests are removed and further tests of the same name will replace each other.
+       */
+      test(...args) {
+        let opts;
+        if (args.length === 1) {
+          if (typeof args[0] === "function") {
+            opts = {
+              test: args[0]
+            };
+          } else {
+            opts = args[0];
+          }
+        } else if (args.length === 2) {
+          opts = {
+            name: args[0],
+            test: args[1]
+          };
+        } else {
+          opts = {
+            name: args[0],
+            message: args[1],
+            test: args[2]
+          };
+        }
+        if (opts.message === void 0)
+          opts.message = _locale.mixed.default;
+        if (typeof opts.test !== "function")
+          throw new TypeError("`test` is a required parameters");
+        let next = this.clone();
+        let validate3 = (0, _createValidation.default)(opts);
+        let isExclusive = opts.exclusive || opts.name && next.exclusiveTests[opts.name] === true;
+        if (opts.exclusive) {
+          if (!opts.name)
+            throw new TypeError("Exclusive tests must provide a unique `name` identifying the test");
+        }
+        if (opts.name)
+          next.exclusiveTests[opts.name] = !!opts.exclusive;
+        next.tests = next.tests.filter((fn) => {
+          if (fn.OPTIONS.name === opts.name) {
+            if (isExclusive)
+              return false;
+            if (fn.OPTIONS.test === validate3.OPTIONS.test)
+              return false;
+          }
+          return true;
+        });
+        next.tests.push(validate3);
+        return next;
+      }
+      when(keys2, options2) {
+        if (!Array.isArray(keys2) && typeof keys2 !== "string") {
+          options2 = keys2;
+          keys2 = ".";
+        }
+        let next = this.clone();
+        let deps = (0, _toArray.default)(keys2).map((key) => new _Reference.default(key));
+        deps.forEach((dep) => {
+          if (dep.isSibling)
+            next.deps.push(dep.key);
+        });
+        next.conditions.push(new _Condition.default(deps, options2));
+        return next;
+      }
+      typeError(message) {
+        var next = this.clone();
+        next._typeError = (0, _createValidation.default)({
+          message,
+          name: "typeError",
+          test(value) {
+            if (value !== void 0 && !this.schema.isType(value))
+              return this.createError({
+                params: {
+                  type: this.schema._type
+                }
+              });
+            return true;
+          }
+        });
+        return next;
+      }
+      oneOf(enums, message = _locale.mixed.oneOf) {
+        var next = this.clone();
+        enums.forEach((val) => {
+          next._whitelist.add(val);
+          next._blacklist.delete(val);
+        });
+        next._whitelistError = (0, _createValidation.default)({
+          message,
+          name: "oneOf",
+          test(value) {
+            if (value === void 0)
+              return true;
+            let valids = this.schema._whitelist;
+            return valids.has(value, this.resolve) ? true : this.createError({
+              params: {
+                values: valids.toArray().join(", ")
+              }
+            });
+          }
+        });
+        return next;
+      }
+      notOneOf(enums, message = _locale.mixed.notOneOf) {
+        var next = this.clone();
+        enums.forEach((val) => {
+          next._blacklist.add(val);
+          next._whitelist.delete(val);
+        });
+        next._blacklistError = (0, _createValidation.default)({
+          message,
+          name: "notOneOf",
+          test(value) {
+            let invalids = this.schema._blacklist;
+            if (invalids.has(value, this.resolve))
+              return this.createError({
+                params: {
+                  values: invalids.toArray().join(", ")
+                }
+              });
+            return true;
+          }
+        });
+        return next;
+      }
+      strip(strip = true) {
+        let next = this.clone();
+        next.spec.strip = strip;
+        return next;
+      }
+      describe() {
+        const next = this.clone();
+        const {
+          label,
+          meta
+        } = next.spec;
+        const description = {
+          meta,
+          label,
+          type: next.type,
+          oneOf: next._whitelist.describe(),
+          notOneOf: next._blacklist.describe(),
+          tests: next.tests.map((fn) => ({
+            name: fn.OPTIONS.name,
+            params: fn.OPTIONS.params
+          })).filter((n, idx, list) => list.findIndex((c) => c.name === n.name) === idx)
+        };
+        return description;
+      }
+    };
+    exports.default = BaseSchema;
+    BaseSchema.prototype.__isYupSchema__ = true;
+    for (const method of ["validate", "validateSync"])
+      BaseSchema.prototype[`${method}At`] = function(path2, value, options2 = {}) {
+        const {
+          parent,
+          parentPath,
+          schema
+        } = (0, _reach.getIn)(this, path2, value, options2.context);
+        return schema[method](parent && parent[parentPath], _extends({}, options2, {
+          parent,
+          path: path2
+        }));
+      };
+    for (const alias of ["equals", "is"])
+      BaseSchema.prototype[alias] = BaseSchema.prototype.oneOf;
+    for (const alias of ["not", "nope"])
+      BaseSchema.prototype[alias] = BaseSchema.prototype.notOneOf;
+    BaseSchema.prototype.optional = BaseSchema.prototype.notRequired;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/mixed.js
+var require_mixed = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/mixed.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _schema = _interopRequireDefault(require_schema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var Mixed = _schema.default;
+    var _default = Mixed;
+    exports.default = _default;
+    function create() {
+      return new Mixed();
+    }
+    create.prototype = Mixed.prototype;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/isAbsent.js
+var require_isAbsent = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/isAbsent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _default = (value) => value == null;
+    exports.default = _default;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/boolean.js
+var require_boolean = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/boolean.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _schema = _interopRequireDefault(require_schema());
+    var _locale = require_locale();
+    var _isAbsent = _interopRequireDefault(require_isAbsent());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function create() {
+      return new BooleanSchema();
+    }
+    var BooleanSchema = class extends _schema.default {
+      constructor() {
+        super({
+          type: "boolean"
+        });
+        this.withMutation(() => {
+          this.transform(function(value) {
+            if (!this.isType(value)) {
+              if (/^(true|1)$/i.test(String(value)))
+                return true;
+              if (/^(false|0)$/i.test(String(value)))
+                return false;
+            }
+            return value;
+          });
+        });
+      }
+      _typeCheck(v) {
+        if (v instanceof Boolean)
+          v = v.valueOf();
+        return typeof v === "boolean";
+      }
+      isTrue(message = _locale.boolean.isValue) {
+        return this.test({
+          message,
+          name: "is-value",
+          exclusive: true,
+          params: {
+            value: "true"
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value === true;
+          }
+        });
+      }
+      isFalse(message = _locale.boolean.isValue) {
+        return this.test({
+          message,
+          name: "is-value",
+          exclusive: true,
+          params: {
+            value: "false"
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value === false;
+          }
+        });
+      }
+    };
+    exports.default = BooleanSchema;
+    create.prototype = BooleanSchema.prototype;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/string.js
+var require_string = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/string.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _locale = require_locale();
+    var _isAbsent = _interopRequireDefault(require_isAbsent());
+    var _schema = _interopRequireDefault(require_schema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var rEmail = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
+    var rUrl = /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i;
+    var rUUID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+    var isTrimmed = (value) => (0, _isAbsent.default)(value) || value === value.trim();
+    var objStringTag = {}.toString();
+    function create() {
+      return new StringSchema();
+    }
+    var StringSchema = class extends _schema.default {
+      constructor() {
+        super({
+          type: "string"
+        });
+        this.withMutation(() => {
+          this.transform(function(value) {
+            if (this.isType(value))
+              return value;
+            if (Array.isArray(value))
+              return value;
+            const strValue = value != null && value.toString ? value.toString() : value;
+            if (strValue === objStringTag)
+              return value;
+            return strValue;
+          });
+        });
+      }
+      _typeCheck(value) {
+        if (value instanceof String)
+          value = value.valueOf();
+        return typeof value === "string";
+      }
+      _isPresent(value) {
+        return super._isPresent(value) && !!value.length;
+      }
+      length(length, message = _locale.string.length) {
+        return this.test({
+          message,
+          name: "length",
+          exclusive: true,
+          params: {
+            length
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value.length === this.resolve(length);
+          }
+        });
+      }
+      min(min, message = _locale.string.min) {
+        return this.test({
+          message,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value.length >= this.resolve(min);
+          }
+        });
+      }
+      max(max, message = _locale.string.max) {
+        return this.test({
+          name: "max",
+          exclusive: true,
+          message,
+          params: {
+            max
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value.length <= this.resolve(max);
+          }
+        });
+      }
+      matches(regex, options2) {
+        let excludeEmptyString = false;
+        let message;
+        let name;
+        if (options2) {
+          if (typeof options2 === "object") {
+            ({
+              excludeEmptyString = false,
+              message,
+              name
+            } = options2);
+          } else {
+            message = options2;
+          }
+        }
+        return this.test({
+          name: name || "matches",
+          message: message || _locale.string.matches,
+          params: {
+            regex
+          },
+          test: (value) => (0, _isAbsent.default)(value) || value === "" && excludeEmptyString || value.search(regex) !== -1
+        });
+      }
+      email(message = _locale.string.email) {
+        return this.matches(rEmail, {
+          name: "email",
+          message,
+          excludeEmptyString: true
+        });
+      }
+      url(message = _locale.string.url) {
+        return this.matches(rUrl, {
+          name: "url",
+          message,
+          excludeEmptyString: true
+        });
+      }
+      uuid(message = _locale.string.uuid) {
+        return this.matches(rUUID, {
+          name: "uuid",
+          message,
+          excludeEmptyString: false
+        });
+      }
+      //-- transforms --
+      ensure() {
+        return this.default("").transform((val) => val === null ? "" : val);
+      }
+      trim(message = _locale.string.trim) {
+        return this.transform((val) => val != null ? val.trim() : val).test({
+          message,
+          name: "trim",
+          test: isTrimmed
+        });
+      }
+      lowercase(message = _locale.string.lowercase) {
+        return this.transform((value) => !(0, _isAbsent.default)(value) ? value.toLowerCase() : value).test({
+          message,
+          name: "string_case",
+          exclusive: true,
+          test: (value) => (0, _isAbsent.default)(value) || value === value.toLowerCase()
+        });
+      }
+      uppercase(message = _locale.string.uppercase) {
+        return this.transform((value) => !(0, _isAbsent.default)(value) ? value.toUpperCase() : value).test({
+          message,
+          name: "string_case",
+          exclusive: true,
+          test: (value) => (0, _isAbsent.default)(value) || value === value.toUpperCase()
+        });
+      }
+    };
+    exports.default = StringSchema;
+    create.prototype = StringSchema.prototype;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/number.js
+var require_number = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/number.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _locale = require_locale();
+    var _isAbsent = _interopRequireDefault(require_isAbsent());
+    var _schema = _interopRequireDefault(require_schema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var isNaN2 = (value) => value != +value;
+    function create() {
+      return new NumberSchema();
+    }
+    var NumberSchema = class extends _schema.default {
+      constructor() {
+        super({
+          type: "number"
+        });
+        this.withMutation(() => {
+          this.transform(function(value) {
+            let parsed = value;
+            if (typeof parsed === "string") {
+              parsed = parsed.replace(/\s/g, "");
+              if (parsed === "")
+                return NaN;
+              parsed = +parsed;
+            }
+            if (this.isType(parsed))
+              return parsed;
+            return parseFloat(parsed);
+          });
+        });
+      }
+      _typeCheck(value) {
+        if (value instanceof Number)
+          value = value.valueOf();
+        return typeof value === "number" && !isNaN2(value);
+      }
+      min(min, message = _locale.number.min) {
+        return this.test({
+          message,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value >= this.resolve(min);
+          }
+        });
+      }
+      max(max, message = _locale.number.max) {
+        return this.test({
+          message,
+          name: "max",
+          exclusive: true,
+          params: {
+            max
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value <= this.resolve(max);
+          }
+        });
+      }
+      lessThan(less, message = _locale.number.lessThan) {
+        return this.test({
+          message,
+          name: "max",
+          exclusive: true,
+          params: {
+            less
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value < this.resolve(less);
+          }
+        });
+      }
+      moreThan(more, message = _locale.number.moreThan) {
+        return this.test({
+          message,
+          name: "min",
+          exclusive: true,
+          params: {
+            more
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value > this.resolve(more);
+          }
+        });
+      }
+      positive(msg = _locale.number.positive) {
+        return this.moreThan(0, msg);
+      }
+      negative(msg = _locale.number.negative) {
+        return this.lessThan(0, msg);
+      }
+      integer(message = _locale.number.integer) {
+        return this.test({
+          name: "integer",
+          message,
+          test: (val) => (0, _isAbsent.default)(val) || Number.isInteger(val)
+        });
+      }
+      truncate() {
+        return this.transform((value) => !(0, _isAbsent.default)(value) ? value | 0 : value);
+      }
+      round(method) {
+        var _method;
+        var avail = ["ceil", "floor", "round", "trunc"];
+        method = ((_method = method) == null ? void 0 : _method.toLowerCase()) || "round";
+        if (method === "trunc")
+          return this.truncate();
+        if (avail.indexOf(method.toLowerCase()) === -1)
+          throw new TypeError("Only valid options for round() are: " + avail.join(", "));
+        return this.transform((value) => !(0, _isAbsent.default)(value) ? Math[method](value) : value);
+      }
+    };
+    exports.default = NumberSchema;
+    create.prototype = NumberSchema.prototype;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/isodate.js
+var require_isodate = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/isodate.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = parseIsoDate;
+    var isoReg = /^(\d{4}|[+\-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,\.](\d{1,}))?)?(?:(Z)|([+\-])(\d{2})(?::?(\d{2}))?)?)?$/;
+    function parseIsoDate(date) {
+      var numericKeys = [1, 4, 5, 6, 7, 10, 11], minutesOffset = 0, timestamp, struct;
+      if (struct = isoReg.exec(date)) {
+        for (var i = 0, k; k = numericKeys[i]; ++i)
+          struct[k] = +struct[k] || 0;
+        struct[2] = (+struct[2] || 1) - 1;
+        struct[3] = +struct[3] || 1;
+        struct[7] = struct[7] ? String(struct[7]).substr(0, 3) : 0;
+        if ((struct[8] === void 0 || struct[8] === "") && (struct[9] === void 0 || struct[9] === ""))
+          timestamp = +new Date(struct[1], struct[2], struct[3], struct[4], struct[5], struct[6], struct[7]);
+        else {
+          if (struct[8] !== "Z" && struct[9] !== void 0) {
+            minutesOffset = struct[10] * 60 + struct[11];
+            if (struct[9] === "+")
+              minutesOffset = 0 - minutesOffset;
+          }
+          timestamp = Date.UTC(struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7]);
+        }
+      } else
+        timestamp = Date.parse ? Date.parse(date) : NaN;
+      return timestamp;
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/date.js
+var require_date = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/date.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _isodate = _interopRequireDefault(require_isodate());
+    var _locale = require_locale();
+    var _isAbsent = _interopRequireDefault(require_isAbsent());
+    var _Reference = _interopRequireDefault(require_Reference());
+    var _schema = _interopRequireDefault(require_schema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var invalidDate = /* @__PURE__ */ new Date("");
+    var isDate = (obj) => Object.prototype.toString.call(obj) === "[object Date]";
+    function create() {
+      return new DateSchema();
+    }
+    var DateSchema = class extends _schema.default {
+      constructor() {
+        super({
+          type: "date"
+        });
+        this.withMutation(() => {
+          this.transform(function(value) {
+            if (this.isType(value))
+              return value;
+            value = (0, _isodate.default)(value);
+            return !isNaN(value) ? new Date(value) : invalidDate;
+          });
+        });
+      }
+      _typeCheck(v) {
+        return isDate(v) && !isNaN(v.getTime());
+      }
+      prepareParam(ref, name) {
+        let param2;
+        if (!_Reference.default.isRef(ref)) {
+          let cast = this.cast(ref);
+          if (!this._typeCheck(cast))
+            throw new TypeError(`\`${name}\` must be a Date or a value that can be \`cast()\` to a Date`);
+          param2 = cast;
+        } else {
+          param2 = ref;
+        }
+        return param2;
+      }
+      min(min, message = _locale.date.min) {
+        let limit = this.prepareParam(min, "min");
+        return this.test({
+          message,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value >= this.resolve(limit);
+          }
+        });
+      }
+      max(max, message = _locale.date.max) {
+        var limit = this.prepareParam(max, "max");
+        return this.test({
+          message,
+          name: "max",
+          exclusive: true,
+          params: {
+            max
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value <= this.resolve(limit);
+          }
+        });
+      }
+    };
+    exports.default = DateSchema;
+    DateSchema.INVALID_DATE = invalidDate;
+    create.prototype = DateSchema.prototype;
+    create.INVALID_DATE = invalidDate;
+  }
+});
+
+// ../../node_modules/toposort/index.js
+var require_toposort = __commonJS({
+  "../../node_modules/toposort/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = function(edges) {
+      return toposort(uniqueNodes(edges), edges);
+    };
+    module2.exports.array = toposort;
+    function toposort(nodes, edges) {
+      var cursor = nodes.length, sorted = new Array(cursor), visited = {}, i = cursor, outgoingEdges = makeOutgoingEdges(edges), nodesHash = makeNodesHash(nodes);
+      edges.forEach(function(edge) {
+        if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
+          throw new Error("Unknown node. There is an unknown node in the supplied edges.");
+        }
+      });
+      while (i--) {
+        if (!visited[i])
+          visit(nodes[i], i, /* @__PURE__ */ new Set());
+      }
+      return sorted;
+      function visit(node, i2, predecessors) {
+        if (predecessors.has(node)) {
+          var nodeRep;
+          try {
+            nodeRep = ", node was:" + JSON.stringify(node);
+          } catch (e) {
+            nodeRep = "";
+          }
+          throw new Error("Cyclic dependency" + nodeRep);
+        }
+        if (!nodesHash.has(node)) {
+          throw new Error("Found unknown node. Make sure to provided all involved nodes. Unknown node: " + JSON.stringify(node));
+        }
+        if (visited[i2])
+          return;
+        visited[i2] = true;
+        var outgoing = outgoingEdges.get(node) || /* @__PURE__ */ new Set();
+        outgoing = Array.from(outgoing);
+        if (i2 = outgoing.length) {
+          predecessors.add(node);
+          do {
+            var child = outgoing[--i2];
+            visit(child, nodesHash.get(child), predecessors);
+          } while (i2);
+          predecessors.delete(node);
+        }
+        sorted[--cursor] = node;
+      }
+    }
+    function uniqueNodes(arr) {
+      var res = /* @__PURE__ */ new Set();
+      for (var i = 0, len = arr.length; i < len; i++) {
+        var edge = arr[i];
+        res.add(edge[0]);
+        res.add(edge[1]);
+      }
+      return Array.from(res);
+    }
+    function makeOutgoingEdges(arr) {
+      var edges = /* @__PURE__ */ new Map();
+      for (var i = 0, len = arr.length; i < len; i++) {
+        var edge = arr[i];
+        if (!edges.has(edge[0]))
+          edges.set(edge[0], /* @__PURE__ */ new Set());
+        if (!edges.has(edge[1]))
+          edges.set(edge[1], /* @__PURE__ */ new Set());
+        edges.get(edge[0]).add(edge[1]);
+      }
+      return edges;
+    }
+    function makeNodesHash(arr) {
+      var res = /* @__PURE__ */ new Map();
+      for (var i = 0, len = arr.length; i < len; i++) {
+        res.set(arr[i], i);
+      }
+      return res;
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/sortFields.js
+var require_sortFields = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/sortFields.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = sortFields;
+    var _has = _interopRequireDefault(require("lodash/has"));
+    var _toposort = _interopRequireDefault(require_toposort());
+    var _propertyExpr = require_property_expr();
+    var _Reference = _interopRequireDefault(require_Reference());
+    var _isSchema = _interopRequireDefault(require_isSchema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function sortFields(fields, excludes = []) {
+      let edges = [];
+      let nodes = [];
+      function addNode(depPath, key) {
+        var node = (0, _propertyExpr.split)(depPath)[0];
+        if (!~nodes.indexOf(node))
+          nodes.push(node);
+        if (!~excludes.indexOf(`${key}-${node}`))
+          edges.push([key, node]);
+      }
+      for (const key in fields)
+        if ((0, _has.default)(fields, key)) {
+          let value = fields[key];
+          if (!~nodes.indexOf(key))
+            nodes.push(key);
+          if (_Reference.default.isRef(value) && value.isSibling)
+            addNode(value.path, key);
+          else if ((0, _isSchema.default)(value) && "deps" in value)
+            value.deps.forEach((path2) => addNode(path2, key));
+        }
+      return _toposort.default.array(nodes, edges).reverse();
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/util/sortByKeyOrder.js
+var require_sortByKeyOrder = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/util/sortByKeyOrder.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = sortByKeyOrder;
+    function findIndex(arr, err) {
+      let idx = Infinity;
+      arr.some((key, ii) => {
+        var _err$path;
+        if (((_err$path = err.path) == null ? void 0 : _err$path.indexOf(key)) !== -1) {
+          idx = ii;
+          return true;
+        }
+      });
+      return idx;
+    }
+    function sortByKeyOrder(keys2) {
+      return (a, b) => {
+        return findIndex(keys2, a) - findIndex(keys2, b);
+      };
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/object.js
+var require_object = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/object.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _has = _interopRequireDefault(require("lodash/has"));
+    var _snakeCase = _interopRequireDefault(require("lodash/snakeCase"));
+    var _camelCase = _interopRequireDefault(require("lodash/camelCase"));
+    var _mapKeys = _interopRequireDefault(require("lodash/mapKeys"));
+    var _mapValues = _interopRequireDefault(require("lodash/mapValues"));
+    var _propertyExpr = require_property_expr();
+    var _locale = require_locale();
+    var _sortFields = _interopRequireDefault(require_sortFields());
+    var _sortByKeyOrder = _interopRequireDefault(require_sortByKeyOrder());
+    var _runTests = _interopRequireDefault(require_runTests());
+    var _ValidationError = _interopRequireDefault(require_ValidationError());
+    var _schema = _interopRequireDefault(require_schema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _extends() {
+      _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    var isObject = (obj) => Object.prototype.toString.call(obj) === "[object Object]";
+    function unknown(ctx, value) {
+      let known = Object.keys(ctx.fields);
+      return Object.keys(value).filter((key) => known.indexOf(key) === -1);
+    }
+    var defaultSort = (0, _sortByKeyOrder.default)([]);
+    var ObjectSchema2 = class extends _schema.default {
+      constructor(spec) {
+        super({
+          type: "object"
+        });
+        this.fields = /* @__PURE__ */ Object.create(null);
+        this._sortErrors = defaultSort;
+        this._nodes = [];
+        this._excludedEdges = [];
+        this.withMutation(() => {
+          this.transform(function coerce(value) {
+            if (typeof value === "string") {
+              try {
+                value = JSON.parse(value);
+              } catch (err) {
+                value = null;
+              }
+            }
+            if (this.isType(value))
+              return value;
+            return null;
+          });
+          if (spec) {
+            this.shape(spec);
+          }
+        });
+      }
+      _typeCheck(value) {
+        return isObject(value) || typeof value === "function";
+      }
+      _cast(_value, options2 = {}) {
+        var _options$stripUnknown;
+        let value = super._cast(_value, options2);
+        if (value === void 0)
+          return this.getDefault();
+        if (!this._typeCheck(value))
+          return value;
+        let fields = this.fields;
+        let strip = (_options$stripUnknown = options2.stripUnknown) != null ? _options$stripUnknown : this.spec.noUnknown;
+        let props = this._nodes.concat(Object.keys(value).filter((v) => this._nodes.indexOf(v) === -1));
+        let intermediateValue = {};
+        let innerOptions = _extends({}, options2, {
+          parent: intermediateValue,
+          __validating: options2.__validating || false
+        });
+        let isChanged = false;
+        for (const prop of props) {
+          let field = fields[prop];
+          let exists2 = (0, _has.default)(value, prop);
+          if (field) {
+            let fieldValue;
+            let inputValue = value[prop];
+            innerOptions.path = (options2.path ? `${options2.path}.` : "") + prop;
+            field = field.resolve({
+              value: inputValue,
+              context: options2.context,
+              parent: intermediateValue
+            });
+            let fieldSpec = "spec" in field ? field.spec : void 0;
+            let strict = fieldSpec == null ? void 0 : fieldSpec.strict;
+            if (fieldSpec == null ? void 0 : fieldSpec.strip) {
+              isChanged = isChanged || prop in value;
+              continue;
+            }
+            fieldValue = !options2.__validating || !strict ? (
+              // TODO: use _cast, this is double resolving
+              field.cast(value[prop], innerOptions)
+            ) : value[prop];
+            if (fieldValue !== void 0) {
+              intermediateValue[prop] = fieldValue;
+            }
+          } else if (exists2 && !strip) {
+            intermediateValue[prop] = value[prop];
+          }
+          if (intermediateValue[prop] !== value[prop]) {
+            isChanged = true;
+          }
+        }
+        return isChanged ? intermediateValue : value;
+      }
+      _validate(_value, opts = {}, callback) {
+        let errors = [];
+        let {
+          sync,
+          from = [],
+          originalValue = _value,
+          abortEarly = this.spec.abortEarly,
+          recursive = this.spec.recursive
+        } = opts;
+        from = [{
+          schema: this,
+          value: originalValue
+        }, ...from];
+        opts.__validating = true;
+        opts.originalValue = originalValue;
+        opts.from = from;
+        super._validate(_value, opts, (err, value) => {
+          if (err) {
+            if (!_ValidationError.default.isError(err) || abortEarly) {
+              return void callback(err, value);
+            }
+            errors.push(err);
+          }
+          if (!recursive || !isObject(value)) {
+            callback(errors[0] || null, value);
+            return;
+          }
+          originalValue = originalValue || value;
+          let tests = this._nodes.map((key) => (_2, cb) => {
+            let path2 = key.indexOf(".") === -1 ? (opts.path ? `${opts.path}.` : "") + key : `${opts.path || ""}["${key}"]`;
+            let field = this.fields[key];
+            if (field && "validate" in field) {
+              field.validate(value[key], _extends({}, opts, {
+                // @ts-ignore
+                path: path2,
+                from,
+                // inner fields are always strict:
+                // 1. this isn't strict so the casting will also have cast inner values
+                // 2. this is strict in which case the nested values weren't cast either
+                strict: true,
+                parent: value,
+                originalValue: originalValue[key]
+              }), cb);
+              return;
+            }
+            cb(null);
+          });
+          (0, _runTests.default)({
+            sync,
+            tests,
+            value,
+            errors,
+            endEarly: abortEarly,
+            sort: this._sortErrors,
+            path: opts.path
+          }, callback);
+        });
+      }
+      clone(spec) {
+        const next = super.clone(spec);
+        next.fields = _extends({}, this.fields);
+        next._nodes = this._nodes;
+        next._excludedEdges = this._excludedEdges;
+        next._sortErrors = this._sortErrors;
+        return next;
+      }
+      concat(schema) {
+        let next = super.concat(schema);
+        let nextFields = next.fields;
+        for (let [field, schemaOrRef] of Object.entries(this.fields)) {
+          const target = nextFields[field];
+          if (target === void 0) {
+            nextFields[field] = schemaOrRef;
+          } else if (target instanceof _schema.default && schemaOrRef instanceof _schema.default) {
+            nextFields[field] = schemaOrRef.concat(target);
+          }
+        }
+        return next.withMutation(() => next.shape(nextFields));
+      }
+      getDefaultFromShape() {
+        let dft = {};
+        this._nodes.forEach((key) => {
+          const field = this.fields[key];
+          dft[key] = "default" in field ? field.getDefault() : void 0;
+        });
+        return dft;
+      }
+      _getDefault() {
+        if ("default" in this.spec) {
+          return super._getDefault();
+        }
+        if (!this._nodes.length) {
+          return void 0;
+        }
+        return this.getDefaultFromShape();
+      }
+      shape(additions, excludes = []) {
+        let next = this.clone();
+        let fields = Object.assign(next.fields, additions);
+        next.fields = fields;
+        next._sortErrors = (0, _sortByKeyOrder.default)(Object.keys(fields));
+        if (excludes.length) {
+          if (!Array.isArray(excludes[0]))
+            excludes = [excludes];
+          let keys2 = excludes.map(([first, second]) => `${first}-${second}`);
+          next._excludedEdges = next._excludedEdges.concat(keys2);
+        }
+        next._nodes = (0, _sortFields.default)(fields, next._excludedEdges);
+        return next;
+      }
+      pick(keys2) {
+        const picked = {};
+        for (const key of keys2) {
+          if (this.fields[key])
+            picked[key] = this.fields[key];
+        }
+        return this.clone().withMutation((next) => {
+          next.fields = {};
+          return next.shape(picked);
+        });
+      }
+      omit(keys2) {
+        const next = this.clone();
+        const fields = next.fields;
+        next.fields = {};
+        for (const key of keys2) {
+          delete fields[key];
+        }
+        return next.withMutation(() => next.shape(fields));
+      }
+      from(from, to, alias) {
+        let fromGetter = (0, _propertyExpr.getter)(from, true);
+        return this.transform((obj) => {
+          if (obj == null)
+            return obj;
+          let newObj = obj;
+          if ((0, _has.default)(obj, from)) {
+            newObj = _extends({}, obj);
+            if (!alias)
+              delete newObj[from];
+            newObj[to] = fromGetter(obj);
+          }
+          return newObj;
+        });
+      }
+      noUnknown(noAllow = true, message = _locale.object.noUnknown) {
+        if (typeof noAllow === "string") {
+          message = noAllow;
+          noAllow = true;
+        }
+        let next = this.test({
+          name: "noUnknown",
+          exclusive: true,
+          message,
+          test(value) {
+            if (value == null)
+              return true;
+            const unknownKeys = unknown(this.schema, value);
+            return !noAllow || unknownKeys.length === 0 || this.createError({
+              params: {
+                unknown: unknownKeys.join(", ")
+              }
+            });
+          }
+        });
+        next.spec.noUnknown = noAllow;
+        return next;
+      }
+      unknown(allow = true, message = _locale.object.noUnknown) {
+        return this.noUnknown(!allow, message);
+      }
+      transformKeys(fn) {
+        return this.transform((obj) => obj && (0, _mapKeys.default)(obj, (_2, key) => fn(key)));
+      }
+      camelCase() {
+        return this.transformKeys(_camelCase.default);
+      }
+      snakeCase() {
+        return this.transformKeys(_snakeCase.default);
+      }
+      constantCase() {
+        return this.transformKeys((key) => (0, _snakeCase.default)(key).toUpperCase());
+      }
+      describe() {
+        let base = super.describe();
+        base.fields = (0, _mapValues.default)(this.fields, (value) => value.describe());
+        return base;
+      }
+    };
+    exports.default = ObjectSchema2;
+    function create(spec) {
+      return new ObjectSchema2(spec);
+    }
+    create.prototype = ObjectSchema2.prototype;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/array.js
+var require_array = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/array.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _isAbsent = _interopRequireDefault(require_isAbsent());
+    var _isSchema = _interopRequireDefault(require_isSchema());
+    var _printValue = _interopRequireDefault(require_printValue());
+    var _locale = require_locale();
+    var _runTests = _interopRequireDefault(require_runTests());
+    var _ValidationError = _interopRequireDefault(require_ValidationError());
+    var _schema = _interopRequireDefault(require_schema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _extends() {
+      _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function create(type) {
+      return new ArraySchema(type);
+    }
+    var ArraySchema = class extends _schema.default {
+      constructor(type) {
+        super({
+          type: "array"
+        });
+        this.innerType = type;
+        this.withMutation(() => {
+          this.transform(function(values2) {
+            if (typeof values2 === "string")
+              try {
+                values2 = JSON.parse(values2);
+              } catch (err) {
+                values2 = null;
+              }
+            return this.isType(values2) ? values2 : null;
+          });
+        });
+      }
+      _typeCheck(v) {
+        return Array.isArray(v);
+      }
+      get _subType() {
+        return this.innerType;
+      }
+      _cast(_value, _opts) {
+        const value = super._cast(_value, _opts);
+        if (!this._typeCheck(value) || !this.innerType)
+          return value;
+        let isChanged = false;
+        const castArray = value.map((v, idx) => {
+          const castElement = this.innerType.cast(v, _extends({}, _opts, {
+            path: `${_opts.path || ""}[${idx}]`
+          }));
+          if (castElement !== v) {
+            isChanged = true;
+          }
+          return castElement;
+        });
+        return isChanged ? castArray : value;
+      }
+      _validate(_value, options2 = {}, callback) {
+        var _options$abortEarly, _options$recursive;
+        let errors = [];
+        let sync = options2.sync;
+        let path2 = options2.path;
+        let innerType = this.innerType;
+        let endEarly = (_options$abortEarly = options2.abortEarly) != null ? _options$abortEarly : this.spec.abortEarly;
+        let recursive = (_options$recursive = options2.recursive) != null ? _options$recursive : this.spec.recursive;
+        let originalValue = options2.originalValue != null ? options2.originalValue : _value;
+        super._validate(_value, options2, (err, value) => {
+          if (err) {
+            if (!_ValidationError.default.isError(err) || endEarly) {
+              return void callback(err, value);
+            }
+            errors.push(err);
+          }
+          if (!recursive || !innerType || !this._typeCheck(value)) {
+            callback(errors[0] || null, value);
+            return;
+          }
+          originalValue = originalValue || value;
+          let tests = new Array(value.length);
+          for (let idx = 0; idx < value.length; idx++) {
+            let item = value[idx];
+            let path3 = `${options2.path || ""}[${idx}]`;
+            let innerOptions = _extends({}, options2, {
+              path: path3,
+              strict: true,
+              parent: value,
+              index: idx,
+              originalValue: originalValue[idx]
+            });
+            tests[idx] = (_2, cb) => innerType.validate(item, innerOptions, cb);
+          }
+          (0, _runTests.default)({
+            sync,
+            path: path2,
+            value,
+            errors,
+            endEarly,
+            tests
+          }, callback);
+        });
+      }
+      clone(spec) {
+        const next = super.clone(spec);
+        next.innerType = this.innerType;
+        return next;
+      }
+      concat(schema) {
+        let next = super.concat(schema);
+        next.innerType = this.innerType;
+        if (schema.innerType)
+          next.innerType = next.innerType ? (
+            // @ts-expect-error Lazy doesn't have concat()
+            next.innerType.concat(schema.innerType)
+          ) : schema.innerType;
+        return next;
+      }
+      of(schema) {
+        let next = this.clone();
+        if (!(0, _isSchema.default)(schema))
+          throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + (0, _printValue.default)(schema));
+        next.innerType = schema;
+        return next;
+      }
+      length(length, message = _locale.array.length) {
+        return this.test({
+          message,
+          name: "length",
+          exclusive: true,
+          params: {
+            length
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value.length === this.resolve(length);
+          }
+        });
+      }
+      min(min, message) {
+        message = message || _locale.array.min;
+        return this.test({
+          message,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          // FIXME(ts): Array<typeof T>
+          test(value) {
+            return (0, _isAbsent.default)(value) || value.length >= this.resolve(min);
+          }
+        });
+      }
+      max(max, message) {
+        message = message || _locale.array.max;
+        return this.test({
+          message,
+          name: "max",
+          exclusive: true,
+          params: {
+            max
+          },
+          test(value) {
+            return (0, _isAbsent.default)(value) || value.length <= this.resolve(max);
+          }
+        });
+      }
+      ensure() {
+        return this.default(() => []).transform((val, original) => {
+          if (this._typeCheck(val))
+            return val;
+          return original == null ? [] : [].concat(original);
+        });
+      }
+      compact(rejector) {
+        let reject = !rejector ? (v) => !!v : (v, i, a) => !rejector(v, i, a);
+        return this.transform((values2) => values2 != null ? values2.filter(reject) : values2);
+      }
+      describe() {
+        let base = super.describe();
+        if (this.innerType)
+          base.innerType = this.innerType.describe();
+        return base;
+      }
+      nullable(isNullable = true) {
+        return super.nullable(isNullable);
+      }
+      defined() {
+        return super.defined();
+      }
+      required(msg) {
+        return super.required(msg);
+      }
+    };
+    exports.default = ArraySchema;
+    create.prototype = ArraySchema.prototype;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/Lazy.js
+var require_Lazy = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/Lazy.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.create = create;
+    exports.default = void 0;
+    var _isSchema = _interopRequireDefault(require_isSchema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function create(builder) {
+      return new Lazy(builder);
+    }
+    var Lazy = class {
+      constructor(builder) {
+        this.type = "lazy";
+        this.__isYupSchema__ = true;
+        this._resolve = (value, options2 = {}) => {
+          let schema = this.builder(value, options2);
+          if (!(0, _isSchema.default)(schema))
+            throw new TypeError("lazy() functions must return a valid schema");
+          return schema.resolve(options2);
+        };
+        this.builder = builder;
+      }
+      resolve(options2) {
+        return this._resolve(options2.value, options2);
+      }
+      cast(value, options2) {
+        return this._resolve(value, options2).cast(value, options2);
+      }
+      validate(value, options2, maybeCb) {
+        return this._resolve(value, options2).validate(value, options2, maybeCb);
+      }
+      validateSync(value, options2) {
+        return this._resolve(value, options2).validateSync(value, options2);
+      }
+      validateAt(path2, value, options2) {
+        return this._resolve(value, options2).validateAt(path2, value, options2);
+      }
+      validateSyncAt(path2, value, options2) {
+        return this._resolve(value, options2).validateSyncAt(path2, value, options2);
+      }
+      describe() {
+        return null;
+      }
+      isValid(value, options2) {
+        return this._resolve(value, options2).isValid(value, options2);
+      }
+      isValidSync(value, options2) {
+        return this._resolve(value, options2).isValidSync(value, options2);
+      }
+    };
+    var _default = Lazy;
+    exports.default = _default;
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/setLocale.js
+var require_setLocale = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/setLocale.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = setLocale;
+    var _locale = _interopRequireDefault(require_locale());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function setLocale(custom) {
+      Object.keys(custom).forEach((type) => {
+        Object.keys(custom[type]).forEach((method) => {
+          _locale.default[type][method] = custom[type][method];
+        });
+      });
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/node_modules/yup/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/cron-validate/node_modules/yup/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.addMethod = addMethod;
+    Object.defineProperty(exports, "MixedSchema", {
+      enumerable: true,
+      get: function() {
+        return _mixed.default;
+      }
+    });
+    Object.defineProperty(exports, "mixed", {
+      enumerable: true,
+      get: function() {
+        return _mixed.create;
+      }
+    });
+    Object.defineProperty(exports, "BooleanSchema", {
+      enumerable: true,
+      get: function() {
+        return _boolean.default;
+      }
+    });
+    Object.defineProperty(exports, "bool", {
+      enumerable: true,
+      get: function() {
+        return _boolean.create;
+      }
+    });
+    Object.defineProperty(exports, "boolean", {
+      enumerable: true,
+      get: function() {
+        return _boolean.create;
+      }
+    });
+    Object.defineProperty(exports, "StringSchema", {
+      enumerable: true,
+      get: function() {
+        return _string.default;
+      }
+    });
+    Object.defineProperty(exports, "string", {
+      enumerable: true,
+      get: function() {
+        return _string.create;
+      }
+    });
+    Object.defineProperty(exports, "NumberSchema", {
+      enumerable: true,
+      get: function() {
+        return _number.default;
+      }
+    });
+    Object.defineProperty(exports, "number", {
+      enumerable: true,
+      get: function() {
+        return _number.create;
+      }
+    });
+    Object.defineProperty(exports, "DateSchema", {
+      enumerable: true,
+      get: function() {
+        return _date.default;
+      }
+    });
+    Object.defineProperty(exports, "date", {
+      enumerable: true,
+      get: function() {
+        return _date.create;
+      }
+    });
+    Object.defineProperty(exports, "ObjectSchema", {
+      enumerable: true,
+      get: function() {
+        return _object.default;
+      }
+    });
+    Object.defineProperty(exports, "object", {
+      enumerable: true,
+      get: function() {
+        return _object.create;
+      }
+    });
+    Object.defineProperty(exports, "ArraySchema", {
+      enumerable: true,
+      get: function() {
+        return _array.default;
+      }
+    });
+    Object.defineProperty(exports, "array", {
+      enumerable: true,
+      get: function() {
+        return _array.create;
+      }
+    });
+    Object.defineProperty(exports, "ref", {
+      enumerable: true,
+      get: function() {
+        return _Reference.create;
+      }
+    });
+    Object.defineProperty(exports, "lazy", {
+      enumerable: true,
+      get: function() {
+        return _Lazy.create;
+      }
+    });
+    Object.defineProperty(exports, "ValidationError", {
+      enumerable: true,
+      get: function() {
+        return _ValidationError.default;
+      }
+    });
+    Object.defineProperty(exports, "reach", {
+      enumerable: true,
+      get: function() {
+        return _reach.default;
+      }
+    });
+    Object.defineProperty(exports, "isSchema", {
+      enumerable: true,
+      get: function() {
+        return _isSchema.default;
+      }
+    });
+    Object.defineProperty(exports, "setLocale", {
+      enumerable: true,
+      get: function() {
+        return _setLocale.default;
+      }
+    });
+    Object.defineProperty(exports, "BaseSchema", {
+      enumerable: true,
+      get: function() {
+        return _schema.default;
+      }
+    });
+    var _mixed = _interopRequireWildcard(require_mixed());
+    var _boolean = _interopRequireWildcard(require_boolean());
+    var _string = _interopRequireWildcard(require_string());
+    var _number = _interopRequireWildcard(require_number());
+    var _date = _interopRequireWildcard(require_date());
+    var _object = _interopRequireWildcard(require_object());
+    var _array = _interopRequireWildcard(require_array());
+    var _Reference = require_Reference();
+    var _Lazy = require_Lazy();
+    var _ValidationError = _interopRequireDefault(require_ValidationError());
+    var _reach = _interopRequireDefault(require_reach());
+    var _isSchema = _interopRequireDefault(require_isSchema());
+    var _setLocale = _interopRequireDefault(require_setLocale());
+    var _schema = _interopRequireDefault(require_schema());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _getRequireWildcardCache() {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cache = /* @__PURE__ */ new WeakMap();
+      _getRequireWildcardCache = function() {
+        return cache;
+      };
+      return cache;
+    }
+    function _interopRequireWildcard(obj) {
+      if (obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return { default: obj };
+      }
+      var cache = _getRequireWildcardCache();
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    function addMethod(schemaType, name, fn) {
+      if (!schemaType || !(0, _isSchema.default)(schemaType.prototype))
+        throw new TypeError("You must provide a yup schema constructor function");
+      if (typeof name !== "string")
+        throw new TypeError("A Method name must be provided");
+      if (typeof fn !== "function")
+        throw new TypeError("Method function must be provided");
+      schemaType.prototype[name] = fn;
+    }
+  }
+});
+
+// ../../node_modules/cron-validate/lib/presets.js
+var require_presets = __commonJS({
+  "../../node_modules/cron-validate/lib/presets.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var option_1 = require_option();
+    exports.default = () => {
+      (0, option_1.registerOptionPreset)("npm-node-cron", {
+        // https://github.com/kelektiv/node-cron
+        presetId: "npm-node-cron",
+        useSeconds: true,
+        useYears: false,
+        useAliases: true,
+        useBlankDay: false,
+        allowOnlyOneBlankDayField: false,
+        mustHaveBlankDayField: false,
+        useLastDayOfMonth: false,
+        useLastDayOfWeek: false,
+        useNearestWeekday: false,
+        useNthWeekdayOfMonth: false,
+        seconds: {
+          minValue: 0,
+          maxValue: 59
+        },
+        minutes: {
+          minValue: 0,
+          maxValue: 59
+        },
+        hours: {
+          minValue: 0,
+          maxValue: 23
+        },
+        daysOfMonth: {
+          minValue: 1,
+          maxValue: 31
+        },
+        months: {
+          minValue: 0,
+          maxValue: 11
+        },
+        daysOfWeek: {
+          minValue: 0,
+          maxValue: 6
+        },
+        years: {
+          minValue: 1970,
+          maxValue: 2099
+        }
+      });
+      (0, option_1.registerOptionPreset)("aws-cloud-watch", {
+        // https://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/events/ScheduledEvents.html
+        presetId: "aws-cloud-watch",
+        useSeconds: false,
+        useYears: true,
+        useAliases: true,
+        useBlankDay: true,
+        allowOnlyOneBlankDayField: true,
+        mustHaveBlankDayField: true,
+        useLastDayOfMonth: true,
+        useLastDayOfWeek: true,
+        useNearestWeekday: true,
+        useNthWeekdayOfMonth: true,
+        seconds: {
+          minValue: 0,
+          maxValue: 59
+        },
+        minutes: {
+          minValue: 0,
+          maxValue: 59
+        },
+        hours: {
+          minValue: 0,
+          maxValue: 23
+        },
+        daysOfMonth: {
+          minValue: 1,
+          maxValue: 31
+        },
+        months: {
+          minValue: 1,
+          maxValue: 12
+        },
+        daysOfWeek: {
+          minValue: 1,
+          maxValue: 7
+        },
+        years: {
+          minValue: 1970,
+          maxValue: 2199
+        }
+      });
+      (0, option_1.registerOptionPreset)("npm-cron-schedule", {
+        // https://github.com/P4sca1/cron-schedule
+        presetId: "npm-cron-schedule",
+        useSeconds: true,
+        useYears: false,
+        useAliases: true,
+        useBlankDay: false,
+        allowOnlyOneBlankDayField: false,
+        mustHaveBlankDayField: false,
+        useLastDayOfMonth: false,
+        useLastDayOfWeek: false,
+        useNearestWeekday: false,
+        useNthWeekdayOfMonth: false,
+        seconds: {
+          minValue: 0,
+          maxValue: 59
+        },
+        minutes: {
+          minValue: 0,
+          maxValue: 59
+        },
+        hours: {
+          minValue: 0,
+          maxValue: 23
+        },
+        daysOfMonth: {
+          minValue: 1,
+          maxValue: 31
+        },
+        months: {
+          minValue: 1,
+          maxValue: 12
+        },
+        daysOfWeek: {
+          minValue: 0,
+          maxValue: 7
+        },
+        years: {
+          minValue: 1970,
+          maxValue: 2099
+        }
+      });
+    };
+  }
+});
+
+// ../../node_modules/cron-validate/lib/option.js
+var require_option = __commonJS({
+  "../../node_modules/cron-validate/lib/option.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.validateOptions = exports.registerOptionPreset = exports.getOptionPresets = exports.getOptionPreset = void 0;
+    var yup = __importStar(require_lib());
+    require_lib();
+    var result_1 = require_result();
+    var presets_1 = __importDefault(require_presets());
+    require_types();
+    var optionPresets = {
+      // http://crontab.org/
+      default: {
+        presetId: "default",
+        useSeconds: false,
+        useYears: false,
+        useAliases: false,
+        useBlankDay: false,
+        allowOnlyOneBlankDayField: false,
+        mustHaveBlankDayField: false,
+        useLastDayOfMonth: false,
+        useLastDayOfWeek: false,
+        useNearestWeekday: false,
+        useNthWeekdayOfMonth: false,
+        seconds: {
+          minValue: 0,
+          maxValue: 59
+        },
+        minutes: {
+          minValue: 0,
+          maxValue: 59
+        },
+        hours: {
+          minValue: 0,
+          maxValue: 23
+        },
+        daysOfMonth: {
+          minValue: 0,
+          maxValue: 31
+        },
+        months: {
+          minValue: 0,
+          maxValue: 12
+        },
+        daysOfWeek: {
+          minValue: 0,
+          maxValue: 7
+        },
+        years: {
+          minValue: 1970,
+          maxValue: 2099
+        }
+      }
+    };
+    var optionPresetSchema = yup.object({
+      presetId: yup.string().required(),
+      useSeconds: yup.boolean().required(),
+      useYears: yup.boolean().required(),
+      useAliases: yup.boolean(),
+      useBlankDay: yup.boolean().required(),
+      allowOnlyOneBlankDayField: yup.boolean().required(),
+      mustHaveBlankDayField: yup.boolean(),
+      useLastDayOfMonth: yup.boolean(),
+      useLastDayOfWeek: yup.boolean(),
+      useNearestWeekday: yup.boolean(),
+      useNthWeekdayOfMonth: yup.boolean(),
+      seconds: yup.object({
+        minValue: yup.number().min(0).required(),
+        maxValue: yup.number().min(0).required(),
+        lowerLimit: yup.number().min(0),
+        upperLimit: yup.number().min(0)
+      }).required(),
+      minutes: yup.object({
+        minValue: yup.number().min(0).required(),
+        maxValue: yup.number().min(0).required(),
+        lowerLimit: yup.number().min(0),
+        upperLimit: yup.number().min(0)
+      }).required(),
+      hours: yup.object({
+        minValue: yup.number().min(0).required(),
+        maxValue: yup.number().min(0).required(),
+        lowerLimit: yup.number().min(0),
+        upperLimit: yup.number().min(0)
+      }).required(),
+      daysOfMonth: yup.object({
+        minValue: yup.number().min(0).required(),
+        maxValue: yup.number().min(0).required(),
+        lowerLimit: yup.number().min(0),
+        upperLimit: yup.number().min(0)
+      }).required(),
+      months: yup.object({
+        minValue: yup.number().min(0).required(),
+        maxValue: yup.number().min(0).required(),
+        lowerLimit: yup.number().min(0),
+        upperLimit: yup.number().min(0)
+      }).required(),
+      daysOfWeek: yup.object({
+        minValue: yup.number().min(0).required(),
+        maxValue: yup.number().min(0).required(),
+        lowerLimit: yup.number().min(0),
+        upperLimit: yup.number().min(0)
+      }).required(),
+      years: yup.object({
+        minValue: yup.number().min(0).required(),
+        maxValue: yup.number().min(0).required(),
+        lowerLimit: yup.number().min(0),
+        upperLimit: yup.number().min(0)
+      }).required()
+    }).required();
+    var getOptionPreset = (presetId) => {
+      if (optionPresets[presetId]) {
+        return (0, result_1.valid)(optionPresets[presetId]);
+      }
+      return (0, result_1.err)(`Option preset '${presetId}' not found.`);
+    };
+    exports.getOptionPreset = getOptionPreset;
+    var getOptionPresets = () => optionPresets;
+    exports.getOptionPresets = getOptionPresets;
+    var registerOptionPreset = (presetName, preset) => {
+      optionPresets[presetName] = optionPresetSchema.validateSync(preset, {
+        strict: false,
+        abortEarly: false,
+        stripUnknown: true,
+        recursive: true
+      });
+    };
+    exports.registerOptionPreset = registerOptionPreset;
+    var validateOptions = (inputOptions) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+      try {
+        (0, presets_1.default)();
+        let preset;
+        if (inputOptions.preset) {
+          if (typeof inputOptions.preset === "string") {
+            if (!optionPresets[inputOptions.preset]) {
+              return (0, result_1.err)([`Option preset ${inputOptions.preset} does not exist.`]);
+            }
+            preset = optionPresets[inputOptions.preset];
+          } else {
+            preset = inputOptions.preset;
+          }
+        } else {
+          preset = optionPresets.default;
+        }
+        const unvalidatedConfig = Object.assign(Object.assign({ presetId: preset.presetId, preset }, {
+          useSeconds: preset.useSeconds,
+          useYears: preset.useYears,
+          useAliases: (_a = preset.useAliases) !== null && _a !== void 0 ? _a : false,
+          useBlankDay: preset.useBlankDay,
+          allowOnlyOneBlankDayField: preset.allowOnlyOneBlankDayField,
+          mustHaveBlankDayField: (_b = preset.mustHaveBlankDayField) !== null && _b !== void 0 ? _b : false,
+          useLastDayOfMonth: (_c = preset.useLastDayOfMonth) !== null && _c !== void 0 ? _c : false,
+          useLastDayOfWeek: (_d = preset.useLastDayOfWeek) !== null && _d !== void 0 ? _d : false,
+          useNearestWeekday: (_e = preset.useNearestWeekday) !== null && _e !== void 0 ? _e : false,
+          useNthWeekdayOfMonth: (_f = preset.useNthWeekdayOfMonth) !== null && _f !== void 0 ? _f : false,
+          seconds: {
+            lowerLimit: (_g = preset.seconds.lowerLimit) !== null && _g !== void 0 ? _g : preset.seconds.minValue,
+            upperLimit: (_h = preset.seconds.upperLimit) !== null && _h !== void 0 ? _h : preset.seconds.maxValue
+          },
+          minutes: {
+            lowerLimit: (_j = preset.minutes.lowerLimit) !== null && _j !== void 0 ? _j : preset.minutes.minValue,
+            upperLimit: (_k = preset.minutes.upperLimit) !== null && _k !== void 0 ? _k : preset.minutes.maxValue
+          },
+          hours: {
+            lowerLimit: (_l = preset.hours.lowerLimit) !== null && _l !== void 0 ? _l : preset.hours.minValue,
+            upperLimit: (_m = preset.hours.upperLimit) !== null && _m !== void 0 ? _m : preset.hours.maxValue
+          },
+          daysOfMonth: {
+            lowerLimit: (_o = preset.daysOfMonth.lowerLimit) !== null && _o !== void 0 ? _o : preset.daysOfMonth.minValue,
+            upperLimit: (_p = preset.daysOfMonth.upperLimit) !== null && _p !== void 0 ? _p : preset.daysOfMonth.maxValue
+          },
+          months: {
+            lowerLimit: (_q = preset.months.lowerLimit) !== null && _q !== void 0 ? _q : preset.months.minValue,
+            upperLimit: (_r = preset.months.upperLimit) !== null && _r !== void 0 ? _r : preset.months.maxValue
+          },
+          daysOfWeek: {
+            lowerLimit: (_s = preset.daysOfWeek.lowerLimit) !== null && _s !== void 0 ? _s : preset.daysOfWeek.minValue,
+            upperLimit: (_t = preset.daysOfWeek.upperLimit) !== null && _t !== void 0 ? _t : preset.daysOfWeek.maxValue
+          },
+          years: {
+            lowerLimit: (_u = preset.years.lowerLimit) !== null && _u !== void 0 ? _u : preset.years.minValue,
+            upperLimit: (_v = preset.years.upperLimit) !== null && _v !== void 0 ? _v : preset.years.maxValue
+          }
+        }), inputOptions.override);
+        const optionsSchema = yup.object({
+          presetId: yup.string().required(),
+          preset: optionPresetSchema.required(),
+          useSeconds: yup.boolean().required(),
+          useYears: yup.boolean().required(),
+          useAliases: yup.boolean(),
+          useBlankDay: yup.boolean().required(),
+          allowOnlyOneBlankDayField: yup.boolean().required(),
+          mustHaveBlankDayField: yup.boolean(),
+          useLastDayOfMonth: yup.boolean(),
+          useLastDayOfWeek: yup.boolean(),
+          useNearestWeekday: yup.boolean(),
+          useNthWeekdayOfMonth: yup.boolean(),
+          seconds: yup.object({
+            lowerLimit: yup.number().min(preset.seconds.minValue).max(preset.seconds.maxValue),
+            upperLimit: yup.number().min(preset.seconds.minValue).max(preset.seconds.maxValue)
+          }).required(),
+          minutes: yup.object({
+            lowerLimit: yup.number().min(preset.minutes.minValue).max(preset.minutes.maxValue),
+            upperLimit: yup.number().min(preset.minutes.minValue).max(preset.minutes.maxValue)
+          }).required(),
+          hours: yup.object({
+            lowerLimit: yup.number().min(preset.hours.minValue).max(preset.hours.maxValue),
+            upperLimit: yup.number().min(preset.hours.minValue).max(preset.hours.maxValue)
+          }).required(),
+          daysOfMonth: yup.object({
+            lowerLimit: yup.number().min(preset.daysOfMonth.minValue).max(preset.daysOfMonth.maxValue),
+            upperLimit: yup.number().min(preset.daysOfMonth.minValue).max(preset.daysOfMonth.maxValue)
+          }).required(),
+          months: yup.object({
+            lowerLimit: yup.number().min(preset.months.minValue).max(preset.months.maxValue),
+            upperLimit: yup.number().min(preset.months.minValue).max(preset.months.maxValue)
+          }).required(),
+          daysOfWeek: yup.object({
+            lowerLimit: yup.number().min(preset.daysOfWeek.minValue).max(preset.daysOfWeek.maxValue),
+            upperLimit: yup.number().min(preset.daysOfWeek.minValue).max(preset.daysOfWeek.maxValue)
+          }).required(),
+          years: yup.object({
+            lowerLimit: yup.number().min(preset.years.minValue).max(preset.years.maxValue),
+            upperLimit: yup.number().min(preset.years.minValue).max(preset.years.maxValue)
+          }).required()
+        }).required();
+        const validatedConfig = optionsSchema.validateSync(unvalidatedConfig, {
+          strict: false,
+          abortEarly: false,
+          stripUnknown: true,
+          recursive: true
+        });
+        return (0, result_1.valid)(validatedConfig);
+      } catch (validationError) {
+        return (0, result_1.err)(validationError.errors);
+      }
+    };
+    exports.validateOptions = validateOptions;
+  }
+});
+
+// ../../node_modules/cron-validate/lib/index.js
+var require_lib2 = __commonJS({
+  "../../node_modules/cron-validate/lib/index.js"(exports, module2) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var result_1 = require_result();
+    var secondChecker_1 = __importDefault(require_secondChecker());
+    var minuteChecker_1 = __importDefault(require_minuteChecker());
+    var hourChecker_1 = __importDefault(require_hourChecker());
+    var dayOfMonthChecker_1 = __importDefault(require_dayOfMonthChecker());
+    var monthChecker_1 = __importDefault(require_monthChecker());
+    var dayOfWeekChecker_1 = __importDefault(require_dayOfWeekChecker());
+    var yearChecker_1 = __importDefault(require_yearChecker());
+    var option_1 = require_option();
+    require_types();
+    var splitCronString = (cronString, options2) => {
+      const splittedCronString = cronString.trim().split(" ");
+      if (options2.useSeconds && options2.useYears && splittedCronString.length !== 7) {
+        return (0, result_1.err)(`Expected 7 values, but got ${splittedCronString.length}.`);
+      }
+      if ((options2.useSeconds && !options2.useYears || options2.useYears && !options2.useSeconds) && splittedCronString.length !== 6) {
+        return (0, result_1.err)(`Expected 6 values, but got ${splittedCronString.length}.`);
+      }
+      if (!options2.useSeconds && !options2.useYears && splittedCronString.length !== 5) {
+        return (0, result_1.err)(`Expected 5 values, but got ${splittedCronString.length}.`);
+      }
+      const cronData = {
+        seconds: options2.useSeconds ? splittedCronString[0] : void 0,
+        minutes: splittedCronString[options2.useSeconds ? 1 : 0],
+        hours: splittedCronString[options2.useSeconds ? 2 : 1],
+        daysOfMonth: splittedCronString[options2.useSeconds ? 3 : 2],
+        months: splittedCronString[options2.useSeconds ? 4 : 3],
+        daysOfWeek: splittedCronString[options2.useSeconds ? 5 : 4],
+        years: options2.useYears ? splittedCronString[options2.useSeconds ? 6 : 5] : void 0
+      };
+      return (0, result_1.valid)(cronData);
+    };
+    var cron = (cronString, inputOptions = {}) => {
+      const optionsResult = (0, option_1.validateOptions)(inputOptions);
+      if (optionsResult.isError()) {
+        return optionsResult;
+      }
+      const options2 = optionsResult.getValue();
+      const cronDataResult = splitCronString(cronString, options2);
+      if (cronDataResult.isError()) {
+        return (0, result_1.err)([`${cronDataResult.getError()} (Input cron: '${cronString}')`]);
+      }
+      const cronData = cronDataResult.getValue();
+      const checkResults = [];
+      if (options2.useSeconds) {
+        checkResults.push((0, secondChecker_1.default)(cronData, options2));
+      }
+      checkResults.push((0, minuteChecker_1.default)(cronData, options2));
+      checkResults.push((0, hourChecker_1.default)(cronData, options2));
+      checkResults.push((0, dayOfMonthChecker_1.default)(cronData, options2));
+      checkResults.push((0, monthChecker_1.default)(cronData, options2));
+      checkResults.push((0, dayOfWeekChecker_1.default)(cronData, options2));
+      if (options2.useYears) {
+        checkResults.push((0, yearChecker_1.default)(cronData, options2));
+      }
+      if (checkResults.every((value) => value.isValid())) {
+        return (0, result_1.valid)(cronData);
+      }
+      const errorArray = [];
+      checkResults.forEach((result) => {
+        if (result.isError()) {
+          result.getError().forEach((error) => {
+            errorArray.push(error);
+          });
+        }
+      });
+      errorArray.forEach((error, index2) => {
+        errorArray[index2] = `${error} (Input cron: '${cronString}')`;
+      });
+      return (0, result_1.err)(errorArray);
+    };
+    exports.default = cron;
+    module2.exports = cron;
+    module2.exports.default = cron;
+  }
+});
+
 // ../../node_modules/passport-strategy/lib/strategy.js
 var require_strategy = __commonJS({
   "../../node_modules/passport-strategy/lib/strategy.js"(exports, module2) {
@@ -339,7 +4177,7 @@ var require_strategy = __commonJS({
 });
 
 // ../../node_modules/passport-strategy/lib/index.js
-var require_lib = __commonJS({
+var require_lib3 = __commonJS({
   "../../node_modules/passport-strategy/lib/index.js"(exports, module2) {
     "use strict";
     var Strategy = require_strategy();
@@ -13453,7 +17291,7 @@ var require_errors2 = __commonJS({
 });
 
 // ../../node_modules/asn1/lib/ber/types.js
-var require_types = __commonJS({
+var require_types2 = __commonJS({
   "../../node_modules/asn1/lib/ber/types.js"(exports, module2) {
     "use strict";
     module2.exports = {
@@ -13499,7 +17337,7 @@ var require_reader = __commonJS({
     "use strict";
     var assert = require("assert");
     var Buffer2 = require_safer().Buffer;
-    var ASN1 = require_types();
+    var ASN1 = require_types2();
     var errors = require_errors2();
     var newInvalidAsn1Error = errors.newInvalidAsn1Error;
     function Reader(data) {
@@ -13665,7 +17503,7 @@ var require_writer = __commonJS({
     "use strict";
     var assert = require("assert");
     var Buffer2 = require_safer().Buffer;
-    var ASN1 = require_types();
+    var ASN1 = require_types2();
     var errors = require_errors2();
     var newInvalidAsn1Error = errors.newInvalidAsn1Error;
     var DEFAULT_OPTS = {
@@ -13908,7 +17746,7 @@ var require_ber = __commonJS({
   "../../node_modules/asn1/lib/ber/index.js"(exports, module2) {
     "use strict";
     var errors = require_errors2();
-    var types = require_types();
+    var types = require_types2();
     var Reader = require_reader();
     var Writer = require_writer();
     module2.exports = {
@@ -13929,7 +17767,7 @@ var require_ber = __commonJS({
 });
 
 // ../../node_modules/asn1/lib/index.js
-var require_lib2 = __commonJS({
+var require_lib4 = __commonJS({
   "../../node_modules/asn1/lib/index.js"(exports, module2) {
     "use strict";
     var Ber = require_ber();
@@ -18107,7 +21945,7 @@ var require_utils3 = __commonJS({
     var Key = require_key();
     var crypto2 = require("crypto");
     var algs = require_algs();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var ec = require_ec();
     var jsbn = require_jsbn().BigInteger;
     var nacl = require_nacl_fast();
@@ -18591,7 +22429,7 @@ var require_signature = __commonJS({
     var crypto2 = require("crypto");
     var errs = require_errors();
     var utils = require_utils3();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var SSHBuffer = require_ssh_buffer();
     var InvalidAlgorithmError = errs.InvalidAlgorithmError;
     var SignatureParseError = errs.SignatureParseError;
@@ -19462,7 +23300,7 @@ var require_pkcs8 = __commonJS({
       writeECDSACurve
     };
     var assert = require_assert();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var Buffer2 = require_safer().Buffer;
     var algs = require_algs();
     var utils = require_utils3();
@@ -19972,7 +23810,7 @@ var require_pkcs1 = __commonJS({
       writePkcs1
     };
     var assert = require_assert();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var Buffer2 = require_safer().Buffer;
     var algs = require_algs();
     var utils = require_utils3();
@@ -21679,7 +25517,7 @@ var require_ssh_private = __commonJS({
       write
     };
     var assert = require_assert();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var Buffer2 = require_safer().Buffer;
     var algs = require_algs();
     var utils = require_utils3();
@@ -21925,7 +25763,7 @@ var require_pem = __commonJS({
       write
     };
     var assert = require_assert();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var crypto2 = require("crypto");
     var Buffer2 = require_safer().Buffer;
     var algs = require_algs();
@@ -23013,7 +26851,7 @@ var require_identity = __commonJS({
     var errs = require_errors();
     var util = require("util");
     var utils = require_utils3();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var Buffer2 = require_safer().Buffer;
     var DNS_NAME_RE = /^([*]|[a-z0-9][a-z0-9\-]{0,62})(?:\.([*]|[a-z0-9][a-z0-9\-]{0,62}))*$/i;
     var oids = {};
@@ -23608,7 +27446,7 @@ var require_x509 = __commonJS({
       write
     };
     var assert = require_assert();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var Buffer2 = require_safer().Buffer;
     var algs = require_algs();
     var utils = require_utils3();
@@ -24240,7 +28078,7 @@ var require_x509_pem = __commonJS({
       write
     };
     var assert = require_assert();
-    var asn1 = require_lib2();
+    var asn1 = require_lib4();
     var Buffer2 = require_safer().Buffer;
     var algs = require_algs();
     var utils = require_utils3();
@@ -25107,7 +28945,7 @@ var require_key = __commonJS({
 });
 
 // ../../node_modules/sshpk/lib/index.js
-var require_lib3 = __commonJS({
+var require_lib5 = __commonJS({
   "../../node_modules/sshpk/lib/index.js"(exports, module2) {
     "use strict";
     var Key = require_key();
@@ -25154,7 +28992,7 @@ var require_utils4 = __commonJS({
   "../../node_modules/http-signature/lib/utils.js"(exports, module2) {
     "use strict";
     var assert = require_assert();
-    var sshpk = require_lib3();
+    var sshpk = require_lib5();
     var util = require("util");
     var HASH_ALGOS = {
       "sha1": true,
@@ -26834,7 +30672,7 @@ var require_signer = __commonJS({
     var crypto2 = require("crypto");
     var http = require("http");
     var util = require("util");
-    var sshpk = require_lib3();
+    var sshpk = require_lib5();
     var jsprim = require_jsprim();
     var utils = require_utils4();
     var sprintf = require("util").format;
@@ -27133,7 +30971,7 @@ var require_verify = __commonJS({
     "use strict";
     var assert = require_assert();
     var crypto2 = require("crypto");
-    var sshpk = require_lib3();
+    var sshpk = require_lib5();
     var utils = require_utils4();
     var HASH_ALGOS = utils.HASH_ALGOS;
     var PK_ALGOS = utils.PK_ALGOS;
@@ -27199,7 +31037,7 @@ var require_verify = __commonJS({
 });
 
 // ../../node_modules/http-signature/lib/index.js
-var require_lib4 = __commonJS({
+var require_lib6 = __commonJS({
   "../../node_modules/http-signature/lib/index.js"(exports, module2) {
     "use strict";
     var parser = require_parser();
@@ -37432,7 +41270,7 @@ var require_parse = __commonJS({
 });
 
 // ../../node_modules/request/node_modules/qs/lib/index.js
-var require_lib5 = __commonJS({
+var require_lib7 = __commonJS({
   "../../node_modules/request/node_modules/qs/lib/index.js"(exports, module2) {
     "use strict";
     var stringify = require_stringify2();
@@ -37450,7 +41288,7 @@ var require_lib5 = __commonJS({
 var require_querystring = __commonJS({
   "../../node_modules/request/lib/querystring.js"(exports) {
     "use strict";
-    var qs2 = require_lib5();
+    var qs2 = require_lib7();
     var querystring = require("querystring");
     function Querystring(request) {
       this.request = request;
@@ -44571,7 +48409,7 @@ var require_timings = __commonJS({
 });
 
 // ../../node_modules/har-schema/lib/index.js
-var require_lib6 = __commonJS({
+var require_lib8 = __commonJS({
   "../../node_modules/har-schema/lib/index.js"(exports, module2) {
     "use strict";
     module2.exports = {
@@ -44763,7 +48601,7 @@ var require_promise = __commonJS({
     "use strict";
     var Ajv = require_ajv();
     var HARError = require_error();
-    var schemas = require_lib6();
+    var schemas = require_lib8();
     var ajv;
     function createAjvInstance() {
       var ajv2 = new Ajv({
@@ -45246,7 +49084,7 @@ var require_oauth4 = __commonJS({
   "../../node_modules/request/lib/oauth.js"(exports) {
     "use strict";
     var url = require("url");
-    var qs2 = require_lib5();
+    var qs2 = require_lib7();
     var caseless = require_caseless();
     var uuid2 = require("uuid/v4");
     var oauth = require_oauth_sign();
@@ -46062,7 +49900,7 @@ var require_request2 = __commonJS({
     var zlib3 = require("zlib");
     var aws2 = require_aws_sign2();
     var aws4 = require_aws4();
-    var httpSignature = require_lib4();
+    var httpSignature = require_lib6();
     var mime = require_mime_types();
     var caseless = require_caseless();
     var ForeverAgent = require_forever_agent();
@@ -49789,7 +53627,7 @@ var require_dynamic = __commonJS({
 var require_strategy2 = __commonJS({
   "../../node_modules/@techpass/passport-openidconnect/lib/strategy.js"(exports, module2) {
     "use strict";
-    var passport2 = require_lib();
+    var passport2 = require_lib3();
     var url = require("url");
     var querystring = require("querystring");
     var util = require("util");
@@ -50261,7 +54099,7 @@ var require_strategy2 = __commonJS({
 });
 
 // ../../node_modules/@techpass/passport-openidconnect/lib/index.js
-var require_lib7 = __commonJS({
+var require_lib9 = __commonJS({
   "../../node_modules/@techpass/passport-openidconnect/lib/index.js"(exports, module2) {
     "use strict";
     var Strategy = require_strategy2();
@@ -50925,6 +54763,11 @@ var OperatorOptions = {
 
 // ../shared-core/src/filters.ts
 var import_dayjs = __toESM(require_dayjs_min());
+
+// ../shared-core/src/helpers/cron.ts
+var import_cron_validate = __toESM(require_lib2());
+
+// ../shared-core/src/filters.ts
 var NoEmptyFilterStrings = [
   OperatorOptions.StartsWith.value,
   OperatorOptions.Like.value,
@@ -60822,7 +64665,7 @@ __export(oidc_exports, {
   strategyFactory: () => strategyFactory2
 });
 var import_node_fetch6 = __toESM(require("node-fetch"));
-var OIDCStrategy = require_lib7().Strategy;
+var OIDCStrategy = require_lib9().Strategy;
 function buildVerifyFn2(saveUserFn) {
   return async (issuer, sub, profile, jwtClaims, accessToken, refreshToken, idToken, params2, done) => {
     const details = {