@nattyjs/validation-decorators 0.0.1-beta.0

package/dist/index.cjs

@@ -0,0 +1,1589 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ValidatorNames = {
+  required: "required",
+  allOf: "allOf",
+  alpha: "alpha",
+  alphaNumeric: "alphaNumeric",
+  ascii: "ascii",
+  contains: "contains",
+  creditCard: "creditCard",
+  cusip: "cusip",
+  dataUri: "dataUri",
+  date: "date",
+  different: "different",
+  digit: "digit",
+  email: "email",
+  endsWith: "endsWith",
+  even: "even",
+  extension: "extension",
+  factor: "factor",
+  file: "file",
+  fileSize: "fileSize",
+  greaterThan: "greaterThan",
+  greaterThanEqualTo: "greaterThanEqualTo",
+  grid: "grid",
+  hexColor: "hexColor",
+  iban: "iban",
+  ip: "ip",
+  json: "json",
+  latitude: "latitude",
+  latLong: "latLong",
+  leapYear: "leapYear",
+  lessThanEqualTo: "lessThanEqualTo",
+  lessThan: "lessThan",
+  longitude: "longitude",
+  lowercase: "lowercase",
+  mac: "mac",
+  mask: "mask",
+  maxDate: "maxDate",
+  maxLength: "maxLength",
+  maxNumber: "maxNumber",
+  maxTime: "maxTime",
+  minDate: "minDate",
+  minLength: "minLength",
+  minNumber: "minNumber",
+  minTime: "minTime",
+  noneOf: "noneOf",
+  notEmpty: "notEmpty",
+  numeric: "numeric",
+  odd: "odd",
+  oneOf: "oneOf",
+  password: "password",
+  pattern: "pattern",
+  port: "port",
+  primeNumber: "primeNumber",
+  range: "range",
+  requiredTrue: "requiredTrue",
+  startsWith: "startsWith",
+  time: "time",
+  uppercase: "uppercase",
+  url: "url"
+};
+
+const validationForms = new class {
+  configure(config) {
+    this.formConfig = config;
+  }
+}();
+
+class ValidationMessage {
+  static getValidatorErrorMessage(name) {
+    let message = "";
+    if (validationForms.formConfig)
+      message = validationForms.formConfig.errorMessage.validator[name];
+    return message;
+  }
+  static toJson(key, config, values) {
+    let message = config ? config.message : null;
+    if (!message && config && config.messageKey)
+      config.messageKey;
+    let messageText = message ? message : config.messagekey ? ValidationMessage.getValidatorErrorMessage(config.messageKey) : ValidationMessage.getValidatorErrorMessage(key);
+    messageText = messageText || "";
+    values.forEach((t, index) => {
+      messageText = messageText.replace(`{{${index}}}`, t);
+    });
+    let jObject = {};
+    jObject[key] = {
+      message: messageText,
+      refValues: values
+    };
+    return jObject;
+  }
+  static null() {
+    return null;
+  }
+}
+
+function getConfigObject(config) {
+  return config || {};
+}
+
+const RegExRule = {
+  alpha: /^[a-zA-Z]+$/,
+  alphaExits: /[a-zA-Z]/,
+  alphaWithSpace: /^[a-zA-Z\s]+$/,
+  macId: /^([0-9a-fA-F][0-9a-fA-F]:){5}([0-9a-fA-F][0-9a-fA-F])$/,
+  onlyDigit: /^[0-9]+$/,
+  isDigitExits: /[0-9]/,
+  lowerCase: /[a-z]/,
+  upperCase: /[A-Z]/,
+  specialCharacter: /[!@#$%^&*(),.?":{}|<>]/,
+  advancedEmail: /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,
+  basicEmail: /^(([^<>()\[\]\\.,,:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+  alphaNumeric: /^[0-9a-zA-Z]+$/,
+  alphaNumericWithSpace: /^[0-9a-zA-Z\s]+$/,
+  hexColor: /^#?([0-9A-F]{3}|[0-9A-F]{6})$/i,
+  strictHexColor: /^#?([0-9A-F]{3}|[0-9A-F]{6})$/i,
+  float: /^(?:[-+]?(?:[0-9]+))?(?:\.[0-9]*)?(?:[eE][\+\-]?(?:[0-9]+))?$/,
+  decimal: /^[-+]?([0-9]+|\.[0-9]+|[0-9]+\.[0-9]+)$/,
+  hexaDecimal: /^[0-9A-F]+$/i,
+  date: /^(?:(?:31(\/|-|\.)(?:0?[13578]|1[02]))\1|(?:(?:29|30)(\/|-|\.)(?:0?[1,3-9]|1[0-2])\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})$|^(?:29(\/|-|\.)0?2\3(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\d|2[0-8])(\/|-|\.)(?:(?:0?[1-9])|(?:1[0-2]))\4(?:(?:1[6-9]|[2-9]\d)?\d{2})$/,
+  time: /^([01]?[0-9]|2[0-3]):[0-5][0-9]$/,
+  timeWithSeconds: /^([01]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/,
+  url: /^(https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|www\.[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9]\.[^\s]{2,}|www\.[a-zA-Z0-9]\.[^\s]{2,})$/,
+  ascii: /^[\x00-\x7F]+$/,
+  dataUri: /^data:([a-z]+\/[a-z0-9-+.]+(;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}|~`]+)*)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s]*?)$/i,
+  lat: /^\(?[+-]?(90(\.0+)?|[1-8]?\d(\.\d+)?)$/,
+  long: /^\s?[+-]?(180(\.0+)?|1[0-7]\d(\.\d+)?|\d{1,2}(\.\d+)?)\)?$/,
+  ipV4: /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/,
+  ipV6: /^((?:[a-fA-F\d]{1,4}:){7}(?:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(:[a-fA-F\d]{1,4}){1,2}|:)|(?:[a-fA-F\d]{1,4}:){4}(?:(:[a-fA-F\d]{1,4}){0,1}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(:[a-fA-F\d]{1,4}){1,3}|:)|(?:[a-fA-F\d]{1,4}:){3}(?:(:[a-fA-F\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(:[a-fA-F\d]{1,4}){1,4}|:)|(?:[a-fA-F\d]{1,4}:){2}(?:(:[a-fA-F\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(:[a-fA-F\d]{1,4}){1,5}|:)|(?:[a-fA-F\d]{1,4}:){1}(?:(:[a-fA-F\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(:[a-fA-F\d]{1,4}){1,6}|:)|(?::((?::[a-fA-F\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,7}|:)))(%[0-9a-zA-Z]{1,})?$/,
+  cidrV4: /^(3[0-2]|[12]?[0-9])$/,
+  cidrV6: /^(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  cusip: /^[0-9A-Z]{9}$/,
+  grid: /^[GRID:]*([0-9A-Z]{2})[-\s]*([0-9A-Z]{5})[-\s]*([0-9A-Z]{10})[-\s]*([0-9A-Z]{1})$/g
+};
+
+const ALPHABET = "alphabet";
+const DIGIT = "digit";
+const CONTAINS = "contains";
+const LOWERCASE = "lowerCase";
+const UPPERCASE = "upperCase";
+const SPECIAL_CHARACTER = "specialCharacter";
+const MIN_LENGTH = "minLength";
+const MAX_LENGTH = "maxLength";
+class RegexValidator {
+  static isExits(value, regex) {
+    return value.match(regex) != null;
+  }
+  static isValid(value, regex) {
+    return regex.test(value);
+  }
+  static isNotBlank(value, isRemoveSpace = false) {
+    return !isRemoveSpace ? value === 0 || value !== void 0 && value !== null && value !== "" : value === 0 || value !== void 0 && value !== null && String(value).trim() !== "";
+  }
+  static isValidPassword(passwordValidation, value) {
+    let isValid = false;
+    let keyName = "status";
+    let objectProperties = Object.getOwnPropertyNames(passwordValidation);
+    for (let propertyName of objectProperties) {
+      switch (propertyName) {
+        case ALPHABET:
+          isValid = RegexValidator.isExits(value, RegExRule.alphaExits);
+          keyName = ALPHABET;
+          break;
+        case DIGIT:
+          isValid = RegexValidator.isValid(value, RegExRule.isDigitExits);
+          keyName = DIGIT;
+          break;
+        case CONTAINS:
+          isValid = value.indexOf(passwordValidation[CONTAINS]) != -1;
+          keyName = CONTAINS;
+          break;
+        case LOWERCASE:
+          isValid = RegexValidator.isValid(value, RegExRule.lowerCase);
+          keyName = LOWERCASE;
+          break;
+        case UPPERCASE:
+          isValid = RegexValidator.isValid(value, RegExRule.upperCase);
+          keyName = UPPERCASE;
+          break;
+        case SPECIAL_CHARACTER:
+          isValid = RegexValidator.isExits(value, RegExRule.specialCharacter);
+          keyName = SPECIAL_CHARACTER;
+          break;
+        case MIN_LENGTH:
+          isValid = value.length >= passwordValidation[propertyName];
+          keyName = MIN_LENGTH;
+          break;
+        case MAX_LENGTH:
+          isValid = value.length <= passwordValidation[propertyName];
+          keyName = MAX_LENGTH;
+          break;
+      }
+      if (!isValid)
+        break;
+    }
+    return { isValid, keyName };
+  }
+  static isZero(value) {
+    return value == 0;
+  }
+  static commaRegex() {
+    return new RegExp(",", "g");
+  }
+}
+
+class Linq {
+  static execute(config, params) {
+    if (config.conditionalExpression) {
+      return config.conditionalExpression.bind(params.current).call(params.current, params.current, params.root);
+    }
+    return true;
+  }
+}
+
+class ValidatorValueChecker {
+  static pass(params, config) {
+    if (Linq.execute(config, params))
+      return RegexValidator.isNotBlank(params.value);
+    else
+      return false;
+  }
+  static passArrayValue(params, config) {
+    if (Linq.execute(config, params))
+      return params.value instanceof Array;
+    else
+      return false;
+  }
+}
+
+function alphaValidation(configModel, params, regExps, key) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(params, config)) {
+    var isValid = !config || !config.allowWhiteSpace ? RegexValidator.isValid(params.value, regExps[0]) : RegexValidator.isValid(params.value, regExps[1]);
+    if (!isValid)
+      return ValidationMessage.toJson(key, config, [params.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function alphaValidator(configModel, params) {
+  return alphaValidation(configModel, params, [RegExRule.alpha, RegExRule.alphaWithSpace], ValidatorNames.alpha);
+}
+
+function alphaNumericValidator(configModel, control) {
+  return alphaValidation(configModel, control, [RegExRule.alphaNumeric, RegExRule.alphaNumericWithSpace], ValidatorNames.alphaNumeric);
+}
+
+function containsValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (control.value.indexOf(config.value) == -1)
+      return ValidationMessage.toJson(ValidatorNames.contains, config, [control.value, config.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function calculate(numbers) {
+  let numberSum = 0;
+  for (var i = 0; i < numbers.length; i++)
+    numberSum += parseInt(numbers.substring(i, i + 1));
+  let deltas = new Array(0, 1, 2, 3, 4, -4, -3, -2, -1, 0);
+  for (var i = numbers.length - 1; i >= 0; i -= 2) {
+    numberSum += deltas[parseInt(numbers.substring(i, i + 1))];
+  }
+  let mod = numberSum % 10;
+  mod = 10 - mod;
+  if (mod == 10)
+    mod = 0;
+  return mod;
+}
+
+function checkLength(length, checks) {
+  let isPassed = false;
+  for (let check of checks) {
+    isPassed = check == length;
+    if (isPassed)
+      break;
+  }
+  return isPassed;
+}
+
+function creditCardValidator(configModel, control) {
+  let cardDigits = {
+    AmericanExpress: [15],
+    DinersClub: [14, 16, 19],
+    Discover: [16, 19],
+    JCB: [16, 19],
+    Maestro: [12, 16, 19],
+    MasterCard: [16],
+    Visa: [13, 16, 19]
+  };
+  function validate(creditCardNumber) {
+    var digit = parseInt(creditCardNumber.substring(creditCardNumber.length - 1, creditCardNumber.length));
+    return calculate(creditCardNumber.substring(0, creditCardNumber.length - 1)) == parseInt(String(digit)) ? true : false;
+  }
+  function getCardProviderName(cardNumber) {
+    var cardProviderName = "";
+    return /^(5018|5020|5038|5612|5893|6304|6759|6761|6762|6763|0604|6390)\d+$/.test(cardNumber) ? cardProviderName = "Maestro" : /^5[1-5]/.test(cardNumber) ? cardProviderName = "MasterCard" : /^4/.test(cardNumber) ? cardProviderName = "Visa" : /^3[47]/.test(cardNumber) ? cardProviderName = "AmericanExpress" : /^(?:2131|1800|35)/.test(cardNumber) ? cardProviderName = "JCB" : /^3(?:0[0-5]|[68])/.test(cardNumber) ? cardProviderName = "DinersClub" : /^6(?:011|5)/.test(cardNumber) && (cardProviderName = "Discover"), cardProviderName;
+  }
+  const controlValue = control.value;
+  let config = getConfigObject(configModel);
+  const parentObject = control.current;
+  if (Linq.execute(config, control)) {
+    if (RegexValidator.isNotBlank(controlValue)) {
+      let isValid = false;
+      let cardTypes = config.fieldName && parentObject[config.fieldName] ? [parentObject[config.fieldName]] : config.creditCardTypes;
+      let cardType = "";
+      for (let creditCardType of cardTypes) {
+        isValid = checkLength(controlValue.length, cardDigits[creditCardType]) && getCardProviderName(controlValue) == creditCardType && validate(controlValue);
+        cardType = creditCardType;
+        if (isValid)
+          break;
+      }
+      if (!isValid)
+        return ValidationMessage.toJson(ValidatorNames.creditCard, config, [controlValue, cardType]);
+    }
+  }
+  return ValidationMessage.null();
+}
+
+function regexValidation(configModel, control, regExp, key) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!RegexValidator.isValid(control.value, regExp))
+      return ValidationMessage.toJson(key, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function digitValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.onlyDigit, ValidatorNames.digit);
+}
+
+function emailValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.basicEmail, ValidatorNames.email);
+}
+
+function hexColorValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.strictHexColor, ValidatorNames.hexColor);
+}
+
+function lowercaseValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(control.value === control.value.toLowerCase()))
+      return ValidationMessage.toJson(ValidatorNames.lowercase, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+const OPERATORS = {
+  lessThan: "<",
+  greaterThan: ">",
+  lessThanEqualTo: "<=",
+  greaterThanEqualTo: ">="
+};
+
+const ISO_DATE_REGEX = /^(?:[\+-]?\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24\:?00)(?:[\.,]\d+(?!:))?)?(?:\2[0-5]\d(?:[\.,]\d+)?)?(?:[zZ]|(?:[\+-])(?:[01]\d|2[0-3]):?(?:[0-5]\d)?)?)?)?$/;
+class DateProvider {
+  isDate(value) {
+    return value instanceof Date && !isNaN(value.valueOf());
+  }
+  getRegex(dateFormat) {
+    var regExp;
+    switch (dateFormat) {
+      case "ymd":
+        regExp = "^(?:[0-9]{4})-(1[0-2]|0?[1-9])-(3[01]|[12][0-9]|0?[1-9])$";
+        break;
+      case "dmy":
+        regExp = "^(3[01]|[12][0-9]|0?[1-9])-(1[0-2]|0?[1-9])-(?:[0-9]{2})?[0-9]{2}$";
+        break;
+      case "mdy":
+        regExp = "^(1[0-2]|0?[1-9])-(3[01]|[12][0-9]|0?[1-9])-(?:[0-9]{2})?[0-9]{2}$";
+        break;
+    }
+    return new RegExp(regExp);
+  }
+  regex(config) {
+    const regExp = this.getRegex(config.dateFormat || validationForms.formConfig.dateConfig.format);
+    return regExp;
+  }
+  getDate(value, configDateFormat = void 0, isBaseFormat = false) {
+    let year, month, day;
+    if (!this.isDate(value)) {
+      let seperator;
+      let dateFormat;
+      if (ISO_DATE_REGEX.test(value)) {
+        return new Date(value);
+      } else {
+        seperator = validationForms.formConfig.dateConfig.seperator;
+        dateFormat = configDateFormat || validationForms.formConfig.dateConfig.format;
+      }
+      switch (dateFormat) {
+        case "ymd":
+          [year, month, day] = value.split(seperator).map((val) => +val);
+          break;
+        case "dmy":
+          [day, month, year] = value.split(seperator).map((val) => +val);
+          break;
+        case "mdy":
+          [month, day, year] = value.split(seperator).map((val) => +val);
+          break;
+      }
+      return new Date(year, month - 1, day);
+    } else
+      return value;
+  }
+  isValid(value, config) {
+    if (config && config.isValid)
+      return config.isValid(value);
+    if (typeof value == "string") {
+      if (config && config.allowISODate && ISO_DATE_REGEX.test(value))
+        return true;
+      let seperator = validationForms.formConfig.dateConfig.seperator;
+      if (value.split(seperator).length !== 3)
+        return false;
+      value = value.replace(seperator, "-").replace(seperator, "-");
+      return this.regex(config).test(value);
+    } else
+      return this.isDate(value);
+  }
+  getConfigDateValue(config) {
+    let date = config.value;
+    if (config.value && typeof config.value == "string") {
+      date = this.getDate(config.value, config.dateFormat, true);
+    }
+    return date;
+  }
+  getCompareDate(config, control) {
+    let date = this.getConfigDateValue(config);
+    if (config.fieldName) {
+      let checkControlValue = control.current[config.fieldName];
+      if (checkControlValue) {
+        date = this.getDate(checkControlValue, config.dateFormat);
+      }
+    }
+    return date;
+  }
+}
+
+function runCondition$1(leftValue, rightValue, operator) {
+  let result = false;
+  switch (operator) {
+    case OPERATORS.lessThan:
+    case OPERATORS.greaterThan:
+      result = leftValue > rightValue;
+      break;
+    case OPERATORS.lessThanEqualTo:
+    case OPERATORS.greaterThanEqualTo:
+      result = leftValue >= rightValue;
+      break;
+  }
+  return result;
+}
+function dateChecker(control, config, operationType) {
+  config = getConfigObject(config);
+  var dateProvider = new DateProvider();
+  if (Linq.execute(config, control)) {
+    if (RegexValidator.isNotBlank(control.value)) {
+      if (dateProvider.isDate(control.value) || dateProvider.isValid(control.value, config)) {
+        let checkDate = dateProvider.getCompareDate(config, control);
+        let currentControlValue = dateProvider.getDate(control.value);
+        let isValid = operationType == ValidatorNames.minDate ? runCondition$1(currentControlValue, checkDate, config.operator || OPERATORS.greaterThanEqualTo) : runCondition$1(checkDate, currentControlValue, config.operator || OPERATORS.lessThanEqualTo);
+        if (!isValid)
+          return ValidationMessage.toJson(operationType, config, [control.value]);
+      } else
+        return ValidationMessage.toJson(operationType, config, [control.value]);
+    }
+  }
+  return ValidationMessage.null();
+}
+function validateDate(control, config, operationType) {
+  config = getConfigObject(config);
+  var dateProvider = new DateProvider();
+  if (Linq.execute(config, control)) {
+    if (RegexValidator.isNotBlank(control.value)) {
+      if (!dateProvider.isDate(control.value) && !dateProvider.isValid(control.value, config)) {
+        return ValidationMessage.toJson(operationType, config, [control.value]);
+      }
+    }
+  }
+  return ValidationMessage.null();
+}
+
+function maxDateValidator(configModel, control) {
+  return dateChecker(control, configModel, ValidatorNames.maxDate);
+}
+
+function maxLengthValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(control.value.length <= config.value))
+      return ValidationMessage.toJson(ValidatorNames.maxLength, config, [control.value, config.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function maxNumberValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(parseFloat(control.value) <= config.value))
+      return ValidationMessage.toJson(ValidatorNames.maxNumber, config, [control.value, config.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function minDateValidator(configModel, control) {
+  return dateChecker(control, configModel, ValidatorNames.minDate);
+}
+
+function minLengthValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(String(control.value).length >= config.value))
+      return ValidationMessage.toJson(ValidatorNames.minLength, config, [control.value, config.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function minNumberValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(parseFloat(control.value) >= config.value))
+      return ValidationMessage.toJson(ValidatorNames.minNumber, config, [control.value, config.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function passwordValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  let controlValue = control.value;
+  if (RegexValidator.isNotBlank(controlValue)) {
+    let validation = RegexValidator.isValidPassword(config.validation, controlValue);
+    if (!validation.isValid)
+      return ValidationMessage.toJson(ValidatorNames.password, config, [controlValue]);
+  }
+  return ValidationMessage.null();
+}
+
+function rangeValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(String(control.value).indexOf(".") == -1 && parseInt(control.value) >= config.minimumNumber && parseInt(control.value) <= config.maximumNumber))
+      return ValidationMessage.toJson(ValidatorNames.range, config, [control.value, config.minimumNumber, config.maximumNumber]);
+  }
+  return ValidationMessage.null();
+}
+
+function uppercaseValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(control.value === control.value.toUpperCase()))
+      return ValidationMessage.toJson(ValidatorNames.uppercase, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+class Utils {
+  static isNotBlank(value, isRemoveSpace = false) {
+    return !isRemoveSpace ? value === 0 || value !== void 0 && value !== null && value !== "" : value === 0 || value !== void 0 && value !== null && String(value).trim() !== "";
+  }
+}
+
+function requiredValidator(config, params) {
+  if (Linq.execute(config, params)) {
+    if (!Utils.isNotBlank(params.value))
+      return ValidationMessage.toJson(ValidatorNames.required, config, []);
+  }
+  return ValidationMessage.null();
+}
+
+function patternValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    for (var pattern in config.expression)
+      if (!RegexValidator.isValid(control.value, config.expression[pattern]))
+        return ValidationMessage.toJson(pattern, { ...config }, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function urlValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.url, ValidatorNames.url);
+}
+
+function jsonValidator(configModel, control) {
+  function process(value) {
+    var result = false;
+    try {
+      var json = JSON.parse(value);
+      result = !!json && typeof json === "object";
+    } catch (ex) {
+      result = false;
+    }
+    return result;
+  }
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (process(control.value))
+      return ValidationMessage.toJson(ValidatorNames.json, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function relationalCheck(control, config, relationalOperatorName) {
+  config = getConfigObject(config);
+  const matchControlValue = config.fieldName ? control.current[config.fieldName] : config.value !== void 0 ? config.value : "";
+  if (Linq.execute(config, control)) {
+    if (isValid$1(control, matchControlValue, relationalOperatorName) === false)
+      return ValidationMessage.toJson(relationalOperatorName, config, [control.value, matchControlValue]);
+  }
+  return ValidationMessage.null();
+}
+function isValid$1(control, matchControlValue, relationalOperatorName) {
+  if (RegexValidator.isNotBlank(control.value) && RegexValidator.isNotBlank(matchControlValue)) {
+    let isValid2 = false;
+    switch (relationalOperatorName) {
+      case ValidatorNames.greaterThan:
+        isValid2 = parseFloat(control.value) > parseFloat(matchControlValue);
+        break;
+      case ValidatorNames.lessThan:
+        isValid2 = parseFloat(control.value) < parseFloat(matchControlValue);
+        break;
+      case ValidatorNames.greaterThanEqualTo:
+        isValid2 = parseFloat(control.value) >= parseFloat(matchControlValue);
+        break;
+      case ValidatorNames.lessThanEqualTo:
+        isValid2 = parseFloat(control.value) <= parseFloat(matchControlValue);
+        break;
+    }
+    return isValid2;
+  }
+  return null;
+}
+
+function greaterThanValidator(configModel, control) {
+  return relationalCheck(control, configModel, ValidatorNames.greaterThan);
+}
+
+function greaterThanEqualToValidator(configModel, control) {
+  return relationalCheck(control, configModel, ValidatorNames.greaterThanEqualTo);
+}
+
+function lessThanEqualToValidator(configModel, control) {
+  return relationalCheck(control, configModel, ValidatorNames.lessThanEqualTo);
+}
+
+function lessThanValidator(configModel, control) {
+  return relationalCheck(control, configModel, ValidatorNames.lessThan);
+}
+
+function differentValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    const differentControlValue = control.current[config.fieldName];
+    if (!(differentControlValue != control.value))
+      return ValidationMessage.toJson(ValidatorNames.different, config, [control.value, differentControlValue]);
+  }
+  return ValidationMessage.null();
+}
+
+var NumericValueType = /* @__PURE__ */ ((NumericValueType2) => {
+  NumericValueType2[NumericValueType2["PositiveNumber"] = 1] = "PositiveNumber";
+  NumericValueType2[NumericValueType2["NegativeNumber"] = 2] = "NegativeNumber";
+  NumericValueType2[NumericValueType2["Both"] = 3] = "Both";
+  return NumericValueType2;
+})(NumericValueType || {});
+
+class ApplicationUtil {
+  static toLower(value) {
+    if (value)
+      return String(value).toLowerCase().trim();
+    return value;
+  }
+  static isNumeric(value) {
+    return value - parseFloat(value) + 1 >= 0;
+  }
+  static notEqualTo(primaryValue, secondaryValue) {
+    let firstValue = primaryValue === void 0 || primaryValue === null ? "" : primaryValue;
+    let secondValue = secondaryValue === void 0 || secondaryValue === null ? "" : secondaryValue;
+    if (firstValue instanceof Date && secondValue instanceof Date)
+      return +firstValue != +secondValue;
+    return firstValue != secondValue;
+  }
+  static numericValidation(allowDecimal, acceptValue) {
+    acceptValue = acceptValue == void 0 ? NumericValueType.PositiveNumber : acceptValue;
+    let regex = /^[0-9]+$/;
+    switch (acceptValue) {
+      case NumericValueType.PositiveNumber:
+        regex = !allowDecimal ? /^[0-9]+$/ : /^[0-9\.]+$/ ;
+        break;
+      case NumericValueType.NegativeNumber:
+        regex = !allowDecimal ? /^[-][0-9]+$/ : /^[-][0-9\.]+$/ ;
+        break;
+      case NumericValueType.Both:
+        regex = !allowDecimal ? /^[-|+]?[0-9]+$/ : /^[-|+]?[0-9\.]+$/ ;
+        break;
+    }
+    return regex;
+  }
+  static lowerCaseWithTrim(value) {
+    return typeof value === "string" ? value.toLowerCase().trim() : String(value).toLowerCase().trim();
+  }
+  static isObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+  }
+  static isArray(value) {
+    return Array.isArray(value);
+  }
+  static cloneValue(value) {
+    return ApplicationUtil.isObject(value) ? ApplicationUtil.isArray(value) ? [...value] : { ...value } : value;
+  }
+}
+
+function numericValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!RegexValidator.isValid(control.value, ApplicationUtil.numericValidation(config.allowDecimal, config.acceptValue)))
+      return ValidationMessage.toJson(ValidatorNames.numeric, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function evenValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!(control.value % 2 == 0))
+      return ValidationMessage.toJson(ValidatorNames.even, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function oddValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!!(control.value % 2 == 0) || !ApplicationUtil.isNumeric(control.value))
+      return ValidationMessage.toJson(ValidatorNames.odd, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function factorValidator(configModel, control) {
+  function positiveFactors(dividend2, value) {
+    let isPositive = false;
+    for (var index = 1; index <= Math.floor(Math.sqrt(dividend2)); index += 1) {
+      if (dividend2 % index === 0) {
+        if (index == value)
+          isPositive = true;
+        if (dividend2 / index !== index) {
+          if (dividend2 / index == value)
+            isPositive = true;
+        }
+        if (isPositive)
+          break;
+      }
+    }
+    return isPositive;
+  }
+  let config = getConfigObject(configModel);
+  const dividend = config.fieldName ? control.current[config.fieldName] : config.dividend;
+  if (Linq.execute(config, control)) {
+    if (RegexValidator.isNotBlank(control.value) && dividend > 0) {
+      if (!RegexValidator.isValid(control.value, RegExRule.onlyDigit) || !positiveFactors(dividend, parseInt(control.value)))
+        return ValidationMessage.toJson(ValidatorNames.factor, config, [control.value]);
+    }
+  }
+  return ValidationMessage.null();
+}
+
+function leapYearValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    var isValid = control.value % 100 === 0 ? control.value % 400 === 0 : control.value % 4 === 0;
+    if (!isValid)
+      return ValidationMessage.toJson(ValidatorNames.leapYear, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function allOfValidator(configModel, params) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.passArrayValue(params, configModel)) {
+    var testResult = false;
+    for (let value of config.matchValues) {
+      testResult = params.value.some((y) => y == value);
+      if (!testResult)
+        break;
+    }
+    if (!testResult)
+      return ValidationMessage.toJson(ValidatorNames.allOf, config, [params.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function oneOfValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.passArrayValue(control, config)) {
+    var testResult = false;
+    for (let value of config.matchValues) {
+      testResult = control.value.some((y) => y == value);
+      if (testResult)
+        break;
+    }
+    if (!testResult)
+      return ValidationMessage.toJson(ValidatorNames.oneOf, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function noneOfValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (Linq.execute(config, control)) {
+    var testResult = false;
+    for (let value of config.matchValues) {
+      let matchValue = ApplicationUtil.lowerCaseWithTrim(value);
+      testResult = Array.isArray(control.value) ? control.value.some((y) => ApplicationUtil.lowerCaseWithTrim(y) === matchValue) : ApplicationUtil.lowerCaseWithTrim(control.value) === matchValue;
+      if (testResult)
+        break;
+    }
+    if (testResult)
+      return ValidationMessage.toJson(ValidatorNames.noneOf, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function macValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.macId, ValidatorNames.mac);
+}
+
+function asciiValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.ascii, ValidatorNames.ascii);
+}
+
+function dataUriValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.dataUri, ValidatorNames.dataUri);
+}
+
+function portValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    let isValid = RegexValidator.isValid(control.value, RegExRule.onlyDigit) && (control.value >= 0 && control.value <= 65535);
+    if (!isValid)
+      return ValidationMessage.toJson(ValidatorNames.port, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function latLongValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    let splitText = control.value.split(",");
+    if (!(splitText.length > 1 && RegexValidator.isValid(splitText[0], RegExRule.lat) && RegexValidator.isValid(splitText[1], RegExRule.long)))
+      return ValidationMessage.toJson(ValidatorNames.latLong, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function extensionValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (Linq.execute(config, control)) {
+    if (RegexValidator.isNotBlank(control.value)) {
+      let testResult = true;
+      let extension = "";
+      let splitText = control.value.split(".");
+      extension = splitText[splitText.length - 1];
+      let result = config.extensions.filter((t) => {
+        return extension.toLowerCase() == t.toLowerCase();
+      })[0];
+      if (!result)
+        testResult = false;
+      if (!testResult)
+        return ValidationMessage.toJson(ValidatorNames.extension, config, [extension, config.extensions.join(",")]);
+    }
+  }
+  return ValidationMessage.null();
+}
+
+function endsWithValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    var endString = String(control.value).substr(control.value.length - config.value.length, config.value.length);
+    if (endString != config.value)
+      return ValidationMessage.toJson(ValidatorNames.endsWith, config, [control.value, config.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function startsWithValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    var startString = String(control.value).substr(0, config.value.length);
+    if (startString != config.value)
+      return ValidationMessage.toJson(ValidatorNames.startsWith, config, [control.value, config.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function primeNumberValidator(configModel, control) {
+  function isPrime(value) {
+    let isPrimeNumber = value != 1;
+    for (var i = 2; i < value; i++) {
+      if (value % i == 0) {
+        isPrimeNumber = false;
+        break;
+      }
+    }
+    return isPrimeNumber;
+  }
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    if (!ApplicationUtil.isNumeric(control.value) || !isPrime(control.value))
+      return ValidationMessage.toJson(ValidatorNames.primeNumber, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function latitudeValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.lat, ValidatorNames.latitude);
+}
+
+function longitudeValidator(configModel, control) {
+  return regexValidation(configModel, control, RegExRule.long, ValidatorNames.longitude);
+}
+
+function notEmptyValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (Linq.execute(config, control)) {
+    if (!RegexValidator.isNotBlank(control.value, true)) {
+      return ValidationMessage.toJson(ValidatorNames.notEmpty, config, []);
+    }
+  }
+  return ValidationMessage.null();
+}
+
+var IpVersion = /* @__PURE__ */ ((IpVersion2) => {
+  IpVersion2[IpVersion2["V4"] = 1] = "V4";
+  IpVersion2[IpVersion2["V6"] = 2] = "V6";
+  IpVersion2[IpVersion2["AnyOne"] = 3] = "AnyOne";
+  return IpVersion2;
+})(IpVersion || {});
+
+function checkIpV4(value) {
+  let isValid = RegexValidator.isValid(value, RegExRule.ipV4);
+  if (isValid) {
+    const splitDots = value.split(".");
+    for (let ipNum of splitDots) {
+      isValid = ipNum <= 255;
+      if (!isValid)
+        break;
+    }
+  }
+  return isValid;
+}
+function checkIpV6(value) {
+  return RegexValidator.isValid(value, RegExRule.ipV6);
+}
+
+function ipValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    let values = config.isCidr ? control.value.split("/") : [control.value];
+    var isValid = config.version == IpVersion.V4 ? checkIpV4(values[0]) : config.version == IpVersion.V6 ? checkIpV6(values[0]) : checkIpV4(values[0]) || checkIpV6(values[0]);
+    if (config.isCidr && isValid) {
+      isValid = values.length > 1 ? config.version == IpVersion.V4 ? RegexValidator.isValid(values[1], RegExRule.cidrV4) : config.version == IpVersion.V6 ? RegexValidator.isValid(values[1], RegExRule.cidrV6) : RegexValidator.isValid(values[1], RegExRule.cidrV4) || RegexValidator.isValid(values[1], RegExRule.cidrV6) : false;
+    }
+    if (!isValid)
+      return ValidationMessage.toJson(ValidatorNames.ip, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function cusipValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (ValidatorValueChecker.pass(control, config)) {
+    var controlValue = control.value.toUpperCase();
+    let isValid = RegexValidator.isValid(controlValue, RegExRule.cusip);
+    if (isValid) {
+      let numericValues = controlValue.split("").map((value) => {
+        var charCode = value.charCodeAt(0);
+        return charCode >= "A".charCodeAt(0) && charCode <= "Z".charCodeAt(0) ? charCode - "A".charCodeAt(0) + 10 : value;
+      });
+      let totalCount = 0;
+      for (var i = 0; i < numericValues.length - 1; i++) {
+        var numericValue = parseInt(numericValues[i], 10);
+        if (i % 2 !== 0) {
+          numericValue *= 2;
+        }
+        if (numericValue > 9) {
+          numericValue -= 9;
+        }
+        totalCount += numericValue;
+      }
+      totalCount = (10 - totalCount % 10) % 10;
+      isValid = totalCount == numericValues[numericValues.length - 1];
+    }
+    if (!isValid)
+      return ValidationMessage.toJson(ValidatorNames.cusip, config, [control.value]);
+  }
+  return ValidationMessage.null();
+}
+
+function dateValidator(configModel, control) {
+  return validateDate(control, configModel, ValidatorNames.date);
+}
+
+function runCondition(leftValue, rightValue, operator) {
+  let result = false;
+  switch (operator) {
+    case OPERATORS.lessThan:
+    case OPERATORS.greaterThan:
+      result = leftValue > rightValue;
+      break;
+    case OPERATORS.lessThanEqualTo:
+    case OPERATORS.greaterThanEqualTo:
+      result = leftValue >= rightValue;
+      break;
+  }
+  return result;
+}
+function isValid(control, config) {
+  return config.allowSeconds ? RegexValidator.isValid(control.value, RegExRule.timeWithSeconds) : RegexValidator.isValid(control.value, RegExRule.time);
+}
+function getTime(value) {
+  let splitTime = value ? value.split(":") : [];
+  return new Date(1970, 0, 1, splitTime[0] ? splitTime[0] : 0, splitTime[1] ? splitTime[1] : 0, splitTime[2] ? splitTime[2] : 0).getTime();
+}
+function timeChecker(control, config, operationType) {
+  config = getConfigObject(config);
+  if (Linq.execute(config, control)) {
+    if (RegexValidator.isNotBlank(control.value)) {
+      if (isValid(control, config)) {
+        let crossControlValue = config.fieldName ? getTime(control.current[config.fieldName]) : getTime(config.value);
+        let currentControlValue = getTime(control.value);
+        let isValid2 = operationType == ValidatorNames.minTime ? runCondition(currentControlValue, crossControlValue, config.operator || OPERATORS.greaterThanEqualTo) : runCondition(crossControlValue, currentControlValue, config.operator || OPERATORS.lessThanEqualTo);
+        if (!isValid2)
+          return ValidationMessage.toJson(operationType, config, [control.value]);
+      } else
+        return ValidationMessage.toJson(operationType, config, [control.value]);
+    }
+  }
+  return ValidationMessage.null();
+}
+
+function minTimeValidator(configModel, control) {
+  return timeChecker(control, configModel, ValidatorNames.minTime);
+}
+
+function maxTimeValidator(configModel, control) {
+  return timeChecker(control, configModel, ValidatorNames.maxTime);
+}
+
+const decoratorRegistrationCaller = new class {
+  constructor() {
+    this.register = void 0;
+  }
+}();
+
+function registerDecorator(config) {
+  if (decoratorRegistrationCaller.register)
+    decoratorRegistrationCaller.register(config);
+}
+
+function baseDecoratorFunction(validatorName, config, validator) {
+  return function(target, propertyKey, parameterIndex) {
+    registerDecorator({
+      decoratorParams: {
+        target,
+        propertyKey,
+        descriptor: parameterIndex
+      },
+      validatorConfig: {
+        name: validatorName,
+        config,
+        validator
+      }
+    });
+  };
+}
+
+function allOf(config) {
+  return baseDecoratorFunction(ValidatorNames.allOf, config || {}, allOfValidator);
+}
+
+function required(config) {
+  return baseDecoratorFunction(ValidatorNames.required, config || {}, requiredValidator);
+}
+
+function numeric(config) {
+  return baseDecoratorFunction(ValidatorNames.numeric, config || {}, numericValidator);
+}
+
+function alpha(config) {
+  return baseDecoratorFunction(ValidatorNames.alpha, config || {}, alphaValidator);
+}
+
+function alphaNumeric(config) {
+  return baseDecoratorFunction(ValidatorNames.alphaNumeric, config || {}, alphaNumericValidator);
+}
+
+function ascii(config) {
+  return baseDecoratorFunction(ValidatorNames.ascii, config || {}, asciiValidator);
+}
+
+function contains(config) {
+  return baseDecoratorFunction(ValidatorNames.contains, config || {}, containsValidator);
+}
+
+function creditCard(config) {
+  return baseDecoratorFunction(ValidatorNames.creditCard, config || {}, creditCardValidator);
+}
+
+function cusip(config) {
+  return baseDecoratorFunction(ValidatorNames.cusip, config || {}, cusipValidator);
+}
+
+function dataUri(config) {
+  return baseDecoratorFunction(ValidatorNames.dataUri, config || {}, dataUriValidator);
+}
+
+function date(config) {
+  return baseDecoratorFunction(ValidatorNames.date, config || {}, dateValidator);
+}
+
+function different(config) {
+  return baseDecoratorFunction(ValidatorNames.different, config || {}, differentValidator);
+}
+
+function digit(config) {
+  return baseDecoratorFunction(ValidatorNames.digit, config || {}, digitValidator);
+}
+
+function email(config) {
+  return baseDecoratorFunction(ValidatorNames.email, config || {}, emailValidator);
+}
+
+function endsWith(config) {
+  return baseDecoratorFunction(ValidatorNames.endsWith, config || {}, endsWithValidator);
+}
+
+function even(config) {
+  return baseDecoratorFunction(ValidatorNames.even, config || {}, evenValidator);
+}
+
+function extension(config) {
+  return baseDecoratorFunction(ValidatorNames.extension, config || {}, extensionValidator);
+}
+
+function factor(config) {
+  return baseDecoratorFunction(ValidatorNames.factor, config || {}, factorValidator);
+}
+
+function greaterThanEqualTo(config) {
+  return baseDecoratorFunction(ValidatorNames.greaterThanEqualTo, config || {}, greaterThanEqualToValidator);
+}
+
+function greaterThan(config) {
+  return baseDecoratorFunction(ValidatorNames.greaterThan, config || {}, greaterThanValidator);
+}
+
+function hexColor(config) {
+  return baseDecoratorFunction(ValidatorNames.hexColor, config || {}, hexColorValidator);
+}
+
+function ip(config) {
+  return baseDecoratorFunction(ValidatorNames.ip, config || {}, ipValidator);
+}
+
+function json(config) {
+  return baseDecoratorFunction(ValidatorNames.json, config || {}, jsonValidator);
+}
+
+function latitude(config) {
+  return baseDecoratorFunction(ValidatorNames.latitude, config || {}, latitudeValidator);
+}
+
+function latLong(config) {
+  return baseDecoratorFunction(ValidatorNames.latLong, config || {}, latLongValidator);
+}
+
+function leapYear(config) {
+  return baseDecoratorFunction(ValidatorNames.leapYear, config || {}, leapYearValidator);
+}
+
+function lessThanEqualTo(config) {
+  return baseDecoratorFunction(ValidatorNames.lessThanEqualTo, config || {}, lessThanEqualToValidator);
+}
+
+function lessThan(config) {
+  return baseDecoratorFunction(ValidatorNames.lessThan, config || {}, lessThanValidator);
+}
+
+function longitude(config) {
+  return baseDecoratorFunction(ValidatorNames.longitude, config || {}, longitudeValidator);
+}
+
+function lowerCase(config) {
+  return baseDecoratorFunction(ValidatorNames.lowercase, config || {}, lowercaseValidator);
+}
+
+function mac(config) {
+  return baseDecoratorFunction(ValidatorNames.mac, config || {}, macValidator);
+}
+
+function maxDate(config) {
+  return baseDecoratorFunction(ValidatorNames.maxDate, config || {}, maxDateValidator);
+}
+
+function maxLength(config) {
+  return baseDecoratorFunction(ValidatorNames.maxLength, config || {}, maxLengthValidator);
+}
+
+function maxNumber(config) {
+  return baseDecoratorFunction(ValidatorNames.maxNumber, config || {}, maxNumberValidator);
+}
+
+function maxTime(config) {
+  return baseDecoratorFunction(ValidatorNames.maxTime, config || {}, maxTimeValidator);
+}
+
+function minDate(config) {
+  return baseDecoratorFunction(ValidatorNames.minDate, config || {}, minDateValidator);
+}
+
+function minLength(config) {
+  return baseDecoratorFunction(ValidatorNames.minLength, config || {}, minLengthValidator);
+}
+
+function minNumber(config) {
+  return baseDecoratorFunction(ValidatorNames.minNumber, config || {}, minNumberValidator);
+}
+
+function minTime(config) {
+  return baseDecoratorFunction(ValidatorNames.minTime, config || {}, minTimeValidator);
+}
+
+function noneOf(config) {
+  return baseDecoratorFunction(ValidatorNames.noneOf, config || {}, noneOfValidator);
+}
+
+function notEmpty(config) {
+  return baseDecoratorFunction(ValidatorNames.notEmpty, config || {}, notEmptyValidator);
+}
+
+function odd(config) {
+  return baseDecoratorFunction(ValidatorNames.odd, config || {}, oddValidator);
+}
+
+function oneOf(config) {
+  return baseDecoratorFunction(ValidatorNames.oneOf, config || {}, oneOfValidator);
+}
+
+function password(config) {
+  return baseDecoratorFunction(ValidatorNames.password, config || {}, passwordValidator);
+}
+
+function pattern(config) {
+  return baseDecoratorFunction(ValidatorNames.pattern, config || {}, patternValidator);
+}
+
+function port(config) {
+  return baseDecoratorFunction(ValidatorNames.port, config || {}, portValidator);
+}
+
+function primeNumber(config) {
+  return baseDecoratorFunction(ValidatorNames.primeNumber, config || {}, primeNumberValidator);
+}
+
+function range(config) {
+  return baseDecoratorFunction(ValidatorNames.range, config || {}, rangeValidator);
+}
+
+function requiredTrueValidator(configModel, control) {
+  let config = getConfigObject(configModel);
+  if (Linq.execute(config, control)) {
+    if (control.value !== true) {
+      return ValidationMessage.toJson(ValidatorNames.requiredTrue, config, []);
+    }
+  }
+  return ValidationMessage.null();
+}
+
+function requiredTrue(config) {
+  return baseDecoratorFunction(ValidatorNames.requiredTrue, config || {}, requiredTrueValidator);
+}
+
+function startsWith(config) {
+  return baseDecoratorFunction(ValidatorNames.startsWith, config || {}, startsWithValidator);
+}
+
+function upperCase(config) {
+  return baseDecoratorFunction(ValidatorNames.uppercase, config || {}, uppercaseValidator);
+}
+
+function url(config) {
+  return baseDecoratorFunction(ValidatorNames.url, config || {}, urlValidator);
+}
+
+function baseSanitizerDecoratorFunction(sanitizerName, config, func) {
+  return function(target, propertyKey, parameterIndex) {
+    registerDecorator({
+      decoratorParams: {
+        target,
+        propertyKey,
+        descriptor: parameterIndex
+      },
+      sanitizerConfig: {
+        name: sanitizerName,
+        config,
+        sanitizer: func
+      }
+    });
+  };
+}
+
+const SanitizerNames = {
+  blacklist: "blacklist",
+  escape: "escape",
+  ltrim: "ltrim",
+  prefix: "prefix",
+  rtrim: "rtrim",
+  sanitize: "sanitize",
+  stripLow: "stripLow",
+  suffix: "suffix",
+  toBoolean: "toBoolean",
+  toDate: "toDate",
+  toInt: "toInt",
+  toString: "toString",
+  trim: "trim",
+  whitelist: "whitelist"
+};
+
+function isNumeric(value) {
+  return value - parseFloat(value) + 1 >= 0;
+}
+function isNotBlank(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+function trim$1(value) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.trim();
+  }
+  return value;
+}
+function ltrim$1(value) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(/^\s+/g, "");
+  }
+  return value;
+}
+function rtrim$1(value) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(/\s+$/g, "");
+  }
+  return value;
+}
+function blacklist$1(value, chars) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(new RegExp("[$" + chars + "]+", "g"), "");
+  }
+  return value;
+}
+function stripLow$1(value, keepNewLines) {
+  let chars = keepNewLines === true ? "\0-	\v\f-\x7F" : "\0-\x7F";
+  return blacklist$1(value, chars);
+}
+function toBoolean$1(value, strict) {
+  if (isNotBlank(value)) {
+    if (strict) {
+      return value === "1" || value === "true";
+    }
+    return value !== "0" && value !== "false" && value !== "";
+  }
+  return value;
+}
+function toInt$1(value, radix) {
+  if (isNotBlank(value)) {
+    if (isNumeric(value))
+      return parseInt(value, radix || 10);
+  }
+  return null;
+}
+function toString$1(value, radix) {
+  if (isNotBlank(value))
+    return String(value);
+  return value;
+}
+function whitelist$1(value, chars) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(new RegExp(`[^${chars}]+`, "g"), "");
+  }
+  return value;
+}
+function toDate$1(value, config) {
+  var dateProvider = new DateProvider();
+  if (isNotBlank(value)) {
+    if (typeof value === "string" && dateProvider.isValid(value, config || {})) {
+      value = dateProvider.getDate(value);
+      return value;
+    }
+  }
+  return null;
+}
+function escape$1(value) {
+  if (isNotBlank(value))
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\//g, "&#x2F;").replace(/\\/g, "&#x5C;").replace(/`/g, "&#96;");
+  return value;
+}
+function prefix$1(value, text) {
+  if (isNotBlank(value))
+    return `${text}${value}`;
+  return value;
+}
+function suffix$1(value, text) {
+  if (isNotBlank(value))
+    return `${value}${text}`;
+  return value;
+}
+function sanitize$1(value, config) {
+  return config.custom(value);
+}
+const SANITIZERS = {
+  trim: trim$1,
+  ltrim: ltrim$1,
+  rtrim: rtrim$1,
+  blacklist: blacklist$1,
+  stripLow: stripLow$1,
+  toBoolean: toBoolean$1,
+  toInt: toInt$1,
+  "toString": toString$1,
+  whitelist: whitelist$1,
+  toDate: toDate$1,
+  escape: escape$1,
+  prefix: prefix$1,
+  suffix: suffix$1,
+  sanitize: sanitize$1
+};
+
+function blacklist(chars) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.blacklist, chars, SANITIZERS.blacklist);
+}
+
+function escape() {
+  return baseSanitizerDecoratorFunction(SanitizerNames.blacklist, void 0, SANITIZERS.escape);
+}
+
+function ltrim() {
+  return baseSanitizerDecoratorFunction(SanitizerNames.ltrim, void 0, SANITIZERS.ltrim);
+}
+
+function prefix(text) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.blacklist, text, SANITIZERS.escape);
+}
+
+function rtrim() {
+  return baseSanitizerDecoratorFunction(SanitizerNames.rtrim, void 0, SANITIZERS.rtrim);
+}
+
+function stripLow(keepNewLines) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.stripLow, keepNewLines, SANITIZERS.stripLow);
+}
+
+function suffix(text) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.suffix, text, SANITIZERS.suffix);
+}
+
+function toBoolean(strict) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.blacklist, strict, SANITIZERS.toBoolean);
+}
+
+function toDate() {
+  return baseSanitizerDecoratorFunction(SanitizerNames.toDate, void 0, SANITIZERS.toDate);
+}
+
+function toInt(radix) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.toInt, radix, SANITIZERS.toInt);
+}
+
+function toString() {
+  return baseSanitizerDecoratorFunction(SanitizerNames.toString, void 0, SANITIZERS.toString);
+}
+
+function trim() {
+  return baseSanitizerDecoratorFunction(SanitizerNames.trim, void 0, SANITIZERS.trim);
+}
+
+function whitelist(chars) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.blacklist, chars, SANITIZERS.whitelist);
+}
+
+function sanitize(config) {
+  return baseSanitizerDecoratorFunction(SanitizerNames.sanitize, config, SANITIZERS.sanitize);
+}
+
+function prop(config) {
+  return function(target, propertyKey, parameterIndex) {
+    registerDecorator({
+      decoratorParams: {
+        target,
+        propertyKey,
+        descriptor: parameterIndex
+      },
+      propConfig: config || {}
+    });
+  };
+}
+
+const ControlValidators = {
+  required: requiredValidator
+};
+
+exports.ControlValidators = ControlValidators;
+exports.NumericValueType = NumericValueType;
+exports.decoratorAllOfValidation = allOf;
+exports.decoratorAlphaNumericValidation = alphaNumeric;
+exports.decoratorAlphaValidation = alpha;
+exports.decoratorAsciiValidation = ascii;
+exports.decoratorBlacklistSanitizer = blacklist;
+exports.decoratorContainsValidation = contains;
+exports.decoratorCreditCardValidation = creditCard;
+exports.decoratorCusipValidation = cusip;
+exports.decoratorDataUriValidation = dataUri;
+exports.decoratorDateValidation = date;
+exports.decoratorDifferentValdiation = different;
+exports.decoratorDigitValidation = digit;
+exports.decoratorEmailValidation = email;
+exports.decoratorEndsWithValidation = endsWith;
+exports.decoratorEscapeSanitizer = escape;
+exports.decoratorEvenValidation = even;
+exports.decoratorExtensionValidation = extension;
+exports.decoratorFactorValidation = factor;
+exports.decoratorGreaterThanEqualToValidation = greaterThanEqualTo;
+exports.decoratorGreaterThanValidation = greaterThan;
+exports.decoratorHexColorValidation = hexColor;
+exports.decoratorIpValidation = ip;
+exports.decoratorJsonValidation = json;
+exports.decoratorLatLongValidation = latLong;
+exports.decoratorLatitudeValdiation = latitude;
+exports.decoratorLeapYearValidation = leapYear;
+exports.decoratorLessThanEqualToValidation = lessThanEqualTo;
+exports.decoratorLessThanValidation = lessThan;
+exports.decoratorLongitudeValidation = longitude;
+exports.decoratorLowercaseValidation = lowerCase;
+exports.decoratorLtrimSanitizer = ltrim;
+exports.decoratorMacValidation = mac;
+exports.decoratorMaxDateValidation = maxDate;
+exports.decoratorMaxLengthValidation = maxLength;
+exports.decoratorMaxNumberValidation = maxNumber;
+exports.decoratorMaxTimeValidation = maxTime;
+exports.decoratorMinDateValidation = minDate;
+exports.decoratorMinLengthValidation = minLength;
+exports.decoratorMinNumberValidation = minNumber;
+exports.decoratorMinTimeValidation = minTime;
+exports.decoratorNoneOfValidation = noneOf;
+exports.decoratorNotEmptyValidation = notEmpty;
+exports.decoratorNumericValidation = numeric;
+exports.decoratorOddValidation = odd;
+exports.decoratorOneOfValidation = oneOf;
+exports.decoratorPasswordValdiation = password;
+exports.decoratorPatternValidation = pattern;
+exports.decoratorPortValidation = port;
+exports.decoratorPrefixSanitizer = prefix;
+exports.decoratorPrimeNumberValidation = primeNumber;
+exports.decoratorRangeValidation = range;
+exports.decoratorRegistrationCaller = decoratorRegistrationCaller;
+exports.decoratorRequiredTrueValidation = requiredTrue;
+exports.decoratorRequiredValidation = required;
+exports.decoratorRtrimSanitizer = rtrim;
+exports.decoratorSanitizeSanitizer = sanitize;
+exports.decoratorStartsWithValidation = startsWith;
+exports.decoratorStripLowSanitizer = stripLow;
+exports.decoratorSuffixSanitizer = suffix;
+exports.decoratorToBooleanSanitizer = toBoolean;
+exports.decoratorToDateSanitizer = toDate;
+exports.decoratorToIntSanitizer = toInt;
+exports.decoratorToStringSanitizer = toString;
+exports.decoratorTrimSanitizer = trim;
+exports.decoratorUpperCaseValidation = upperCase;
+exports.decoratorUrlValidation = url;
+exports.decoratorWhitelistSanitizer = whitelist;
+exports.prop = prop;
+exports.validationForms = validationForms;