koatty_validation 1.0.12 → 1.2.2

package/dist/index.js

@@ -1,21 +1,1379 @@
-"use strict";
-/**
- * @ author: richen
- * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
- * @ license: MIT
- * @ version: 2020-03-20 11:31:09
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOriginMetadata = exports.plainToClass = exports.convertDtoParamsType = exports.convertParamsType = exports.checkParamsType = void 0;
-const tslib_1 = require("tslib");
-// export for manual verification
-(0, tslib_1.__exportStar)(require("./rule"), exports);
-(0, tslib_1.__exportStar)(require("./decorator"), exports);
-var util_1 = require("./util");
-Object.defineProperty(exports, "checkParamsType", { enumerable: true, get: function () { return util_1.checkParamsType; } });
-Object.defineProperty(exports, "convertParamsType", { enumerable: true, get: function () { return util_1.convertParamsType; } });
-Object.defineProperty(exports, "convertDtoParamsType", { enumerable: true, get: function () { return util_1.convertDtoParamsType; } });
-Object.defineProperty(exports, "plainToClass", { enumerable: true, get: function () { return util_1.plainToClass; } });
-Object.defineProperty(exports, "getOriginMetadata", { enumerable: true, get: function () { return util_1.getOriginMetadata; } });
-// export decorators from class-validator
-//# sourceMappingURL=index.js.map
+/*!
+* @Author: richen
+* @Date: 2022-02-25 10:58:54
+* @License: BSD (3-Clause)
+* @Copyright (c) - <richenlin(at)gmail.com>
+* @HomePage: https://koatty.org/
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helper = require('koatty_lib');
+require('reflect-metadata');
+var koatty_container = require('koatty_container');
+var classValidator = require('class-validator');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var helper__namespace = /*#__PURE__*/_interopNamespace(helper);
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: MIT
+ * @ version: 2020-03-20 11:34:38
+ */
+/**
+ * Set property as included in the process of transformation.
+ *
+ * @export
+ * @param {Object} object
+ * @param {(string | symbol)} propertyName
+ */
+function setExpose(object, propertyName) {
+    const types = Reflect.getMetadata("design:type", object, propertyName);
+    if (types) {
+        const originMap = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, object);
+        originMap.set(propertyName, types.name);
+    }
+}
+/**
+ *
+ *
+ * @export
+ * @param {*} clazz
+ * @param {*} data
+ * @param {boolean} [convert=false]
+ * @returns
+ */
+function plainToClass(clazz, data, convert = false) {
+    if (helper__namespace.isClass(clazz)) {
+        let cls;
+        if (!helper__namespace.isObject(data)) {
+            data = {};
+        }
+        if (data instanceof clazz) {
+            cls = data;
+        }
+        else {
+            cls = Reflect.construct(clazz, []);
+        }
+        if (convert) {
+            return convertDtoParamsType(clazz, cls, data);
+        }
+        return Object.assign(cls, data);
+    }
+    return data;
+}
+/**
+ * convertDtoParamsType
+ *
+ * @param {*} clazz
+ * @param {*} cls
+ * @param {*} data
+ * @returns {*}
+ */
+function convertDtoParamsType(clazz, cls, data) {
+    if (Object.prototype.hasOwnProperty.call(cls, "_typeDef")) {
+        for (const key in cls) {
+            if (Object.prototype.hasOwnProperty.call(data, key)
+                && Object.prototype.hasOwnProperty.call(cls._typeDef, key)) {
+                data[key] = convertParamsType(data[key], cls._typeDef[key]);
+            }
+        }
+    }
+    else {
+        const originMap = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, clazz);
+        for (const [key, type] of originMap) {
+            if (key && Object.prototype.hasOwnProperty.call(data, key)) {
+                cls[key] = convertParamsType(data[key], type);
+            }
+        }
+    }
+    return cls;
+}
+/**
+ * 绑定参数类型转换
+ *
+ * @param {*} param
+ * @param {string} type
+ * @returns {*}
+ */
+function convertParamsType(param, type) {
+    try {
+        switch (type) {
+            case "Number":
+            case "number":
+                if (helper__namespace.isNaN(param)) {
+                    return NaN;
+                }
+                if (helper__namespace.isNumber(param)) {
+                    return param;
+                }
+                if (helper__namespace.isNumberString(param)) {
+                    return helper__namespace.toNumber(param);
+                }
+                return NaN;
+            case "Boolean":
+            case "boolean":
+                return !!param;
+            case "Array":
+            case "array":
+            case "Tuple":
+            case "tuple":
+                if (helper__namespace.isArray(param)) {
+                    return param;
+                }
+                return helper__namespace.toArray(param);
+            case "String":
+            case "string":
+                if (helper__namespace.isString(param)) {
+                    return param;
+                }
+                return helper__namespace.toString(param);
+            case "Null":
+            case "null":
+                return null;
+            case "Undefined":
+            case "undefined":
+                return undefined;
+            case "Bigint":
+            case "bigint":
+                if (typeof param === 'bigint') {
+                    return param;
+                }
+                return BigInt(param);
+            // case "object":
+            // case "enum":
+            default: //any
+                return param;
+        }
+    }
+    catch (err) {
+        return param;
+    }
+}
+/**
+ * Check the base types.
+ *
+ * @param {*} value
+ * @param {string} type
+ * @returns {*}
+ */
+function checkParamsType(value, type) {
+    switch (type) {
+        case "Number":
+        case "number":
+            if (!helper__namespace.isNumber(value) || helper__namespace.isNaN(value)) {
+                return false;
+            }
+            return true;
+        case "Boolean":
+        case "boolean":
+            if (!helper__namespace.isBoolean(value)) {
+                return false;
+            }
+            return true;
+        case "Array":
+        case "array":
+        case "Tuple":
+        case "tuple":
+            if (!helper__namespace.isArray(value)) {
+                return false;
+            }
+            return true;
+        case "String":
+        case "string":
+            if (!helper__namespace.isString(value)) {
+                return false;
+            }
+            return true;
+        case "Object":
+        case "object":
+        case "Enum":
+        case "enum":
+            if (helper__namespace.isTrueEmpty(value)) {
+                return false;
+            }
+            return true;
+        case "Null":
+        case "null":
+            if (!helper__namespace.isNull(value)) {
+                return false;
+            }
+            return true;
+        case "Undefined":
+        case "undefined":
+            if (!helper__namespace.isUndefined(value)) {
+                return false;
+            }
+            return true;
+        case "Bigint":
+        case "bigint":
+            if (typeof value !== 'bigint') {
+                return false;
+            }
+            return true;
+        default: //any
+            return true;
+    }
+}
+/**
+ * Checks if value is a chinese name.
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+function cnName(value) {
+    const reg = /^([a-zA-Z0-9\u4e00-\u9fa5\·]{1,10})$/;
+    return reg.test(value);
+}
+/**
+ * Checks if value is a idCard number.
+ *
+ * @param {string} value
+ * @returns
+ */
+function idNumber(value) {
+    if (/^\d{15}$/.test(value)) {
+        return true;
+    }
+    if ((/^\d{17}[0-9X]$/).test(value)) {
+        const vs = '1,0,x,9,8,7,6,5,4,3,2'.split(',');
+        const ps = '7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2'.split(',');
+        const ss = value.toLowerCase().split('');
+        let r = 0;
+        for (let i = 0; i < 17; i++) {
+            r += ps[i] * ss[i];
+        }
+        const isOk = (vs[r % 11] === ss[17]);
+        return isOk;
+    }
+    return false;
+}
+/**
+ * Checks if value is a mobile phone number.
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+function mobile(value) {
+    const reg = /^(13|14|15|16|17|18|19)\d{9}$/;
+    return reg.test(value);
+}
+/**
+ * Checks if value is a zipCode.
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+function zipCode(value) {
+    const reg = /^\d{6}$/;
+    return reg.test(value);
+}
+/**
+ * Checks if value is a plateNumber.
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+function plateNumber(value) {
+    // let reg = new RegExp('^(([\u4e00-\u9fa5][a-zA-Z]|[\u4e00-\u9fa5]{2}\d{2}|[\u4e00-\u9fa5]{2}[a-zA-Z])[-]?|([wW][Jj][\u4e00-\u9fa5]{1}[-]?)|([a-zA-Z]{2}))([A-Za-z0-9]{5}|[DdFf][A-HJ-NP-Za-hj-np-z0-9][0-9]{4}|[0-9]{5}[DdFf])$');
+    // let xReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
+    const xReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
+    // let cReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
+    const cReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
+    if (value.length === 7) {
+        return cReg.test(value);
+    }
+    else {
+        //新能源车牌
+        return xReg.test(value);
+    }
+}
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-11-25 10:47:04
+ * @LastEditTime: 2022-02-25 10:33:20
+ */
+// constant
+const PARAM_TYPE_KEY = 'PARAM_TYPE_KEY';
+const PARAM_RULE_KEY = 'PARAM_RULE_KEY';
+const PARAM_CHECK_KEY = 'PARAM_CHECK_KEY';
+const ENABLE_VALIDATED = "ENABLE_VALIDATED";
+/**
+ * paramterTypes
+ *
+ * @export
+ * @enum {number}
+ */
+exports.paramterTypes = void 0;
+(function (paramterTypes) {
+    paramterTypes[paramterTypes["Number"] = 0] = "Number";
+    paramterTypes[paramterTypes["number"] = 1] = "number";
+    paramterTypes[paramterTypes["String"] = 2] = "String";
+    paramterTypes[paramterTypes["string"] = 3] = "string";
+    paramterTypes[paramterTypes["Boolean"] = 4] = "Boolean";
+    paramterTypes[paramterTypes["boolean"] = 5] = "boolean";
+    paramterTypes[paramterTypes["Array"] = 6] = "Array";
+    paramterTypes[paramterTypes["array"] = 7] = "array";
+    paramterTypes[paramterTypes["Tuple"] = 8] = "Tuple";
+    paramterTypes[paramterTypes["tuple"] = 9] = "tuple";
+    paramterTypes[paramterTypes["Object"] = 10] = "Object";
+    paramterTypes[paramterTypes["object"] = 11] = "object";
+    paramterTypes[paramterTypes["Enum"] = 12] = "Enum";
+    paramterTypes[paramterTypes["enum"] = 13] = "enum";
+    paramterTypes[paramterTypes["Bigint"] = 14] = "Bigint";
+    paramterTypes[paramterTypes["bigint"] = 15] = "bigint";
+    paramterTypes[paramterTypes["Null"] = 16] = "Null";
+    paramterTypes[paramterTypes["null"] = 17] = "null";
+    paramterTypes[paramterTypes["Undefined"] = 18] = "Undefined";
+    paramterTypes[paramterTypes["undefined"] = 19] = "undefined";
+})(exports.paramterTypes || (exports.paramterTypes = {}));
+class ValidateClass {
+    constructor() {
+    }
+    /**
+     *
+     *
+     * @static
+     * @returns
+     * @memberof ValidateUtil
+     */
+    static getInstance() {
+        return this.instance || (this.instance = new ValidateClass());
+    }
+    /**
+     * validated data vs dto class
+     *
+     * @param {*} Clazz
+     * @param {*} data
+     * @param {boolean} [convert=false] auto convert parameters type
+     * @returns {Promise<any>}
+     * @memberof ValidateClass
+     */
+    async valid(Clazz, data, convert = false) {
+        let obj = {};
+        if (data instanceof Clazz) {
+            obj = data;
+        }
+        else {
+            obj = plainToClass(Clazz, data, convert);
+        }
+        let errors = [];
+        if (convert) {
+            errors = await classValidator.validate(obj);
+        }
+        else {
+            errors = await classValidator.validate(obj, { skipMissingProperties: true });
+        }
+        if (errors.length > 0) {
+            throw new Error(Object.values(errors[0].constraints)[0]);
+        }
+        return obj;
+    }
+}
+/**
+ * ClassValidator for manual
+ */
+const ClassValidator = ValidateClass.getInstance();
+/**
+ * Validator Functions
+ */
+const ValidFuncs = {
+    /**
+     * Checks value is not empty, undefined, null, '', NaN, [], {} and any empty string(including spaces,
+     * tabs, formfeeds, etc.), returns false
+     */
+    IsNotEmpty: (value) => {
+        return !helper__namespace.isEmpty(value);
+    },
+    /**
+     * Checks if a given value is a real date.
+     */
+    IsDate: (value) => {
+        return helper__namespace.isDate(value);
+    },
+    /**
+     * Checks if the string is an email. If given value is not a string, then it returns false.
+     */
+    IsEmail: (value, options) => {
+        return classValidator.isEmail(value, options);
+    },
+    /**
+     * Checks if the string is an IP (version 4 or 6). If given value is not a string, then it returns false.
+     */
+    IsIP: (value, version) => {
+        return classValidator.isIP(value, version);
+    },
+    /**
+     * Checks if the string is a valid phone number.
+     * @param value — the potential phone number string to test
+     * @param region 2 characters uppercase country code (e.g. DE, US, CH). If users must enter the intl.
+     * prefix (e.g. +41), then you may pass "ZZ" or null as region.
+     * See [google-libphonenumber, metadata.js:countryCodeToRegionCodeMap on github]
+     * {@link https://github.com/ruimarinho/google-libphonenumber/blob/1e46138878cff479aafe2ce62175c6c49cb58720/src/metadata.js#L33}
+     */
+    IsPhoneNumber: (value, region) => {
+        return classValidator.isPhoneNumber(value, region);
+    },
+    /**
+     * Checks if the string is an url. If given value is not a string, then it returns false.
+     */
+    IsUrl: (value, options) => {
+        return classValidator.isURL(value, options);
+    },
+    /**
+     * check if the string is a hash of type algorithm. Algorithm is one of
+     * ['md4', 'md5', 'sha1', 'sha256', 'sha384', 'sha512', 'ripemd128', 'ripemd160', 'tiger128', 'tiger160', 'tiger192', 'crc32', 'crc32b']
+     */
+    IsHash: (value, algorithm) => {
+        return classValidator.isHash(value, algorithm);
+    },
+    /**
+     * Checks if value is a chinese name.
+     */
+    IsCnName: (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return cnName(value);
+    },
+    /**
+     * Checks if value is a idcard number.
+     */
+    IsIdNumber: (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return idNumber(value);
+    },
+    /**
+     * Checks if value is a zipCode.
+     */
+    IsZipCode: (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return zipCode(value);
+    },
+    /**
+     * Checks if value is a mobile phone number.
+     */
+    IsMobile: (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return mobile(value);
+    },
+    /**
+     * Checks if value is a plateNumber.
+     */
+    IsPlateNumber: (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return plateNumber(value);
+    },
+    /**
+     * Checks if value matches ("===") the comparison.
+     */
+    Equals: (value, comparison) => {
+        return classValidator.equals(value, comparison);
+    },
+    /**
+     * Checks if value does not match ("!==") the comparison.
+     */
+    NotEquals: (value, comparison) => {
+        return classValidator.notEquals(value, comparison);
+    },
+    /**
+     * Checks if the string contains the seed. If given value is not a string, then it returns false.
+     */
+    Contains: (value, seed) => {
+        return classValidator.contains(value, seed);
+    },
+    /**
+     * Checks if given value is in a array of allowed values.
+     */
+    IsIn: (value, possibleValues) => {
+        return classValidator.isIn(value, possibleValues);
+    },
+    /**
+     * Checks if given value not in a array of allowed values.
+     */
+    IsNotIn: (value, possibleValues) => {
+        return classValidator.isNotIn(value, possibleValues);
+    },
+    /**
+     * Checks if the first number is greater than or equal to the second.
+     */
+    Gt: (num, min) => {
+        return helper__namespace.toNumber(num) > min;
+    },
+    /**
+     * Checks if the first number is less than or equal to the second.
+     */
+    Lt: (num, max) => {
+        return helper__namespace.toNumber(num) < max;
+    },
+    /**
+     * Checks if the first number is greater than or equal to the second.
+     */
+    Gte: (num, min) => {
+        return helper__namespace.toNumber(num) >= min;
+    },
+    /**
+     * Checks if the first number is less than or equal to the second.
+     */
+    Lte: (num, max) => {
+        return helper__namespace.toNumber(num) <= max;
+    },
+};
+/**
+ * Use functions or built-in rules for validation.
+ *
+ * @export
+ * @param {ValidRules} rule
+ * @param {unknown} value
+ * @param {(string | ValidOtpions)} [options]
+ * @returns {*}
+ */
+const FunctionValidator = {
+    IsNotEmpty: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsDate: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsEmail: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsIP: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsPhoneNumber: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsUrl: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsHash: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsCnName: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsIdNumber: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsZipCode: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsMobile: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsPlateNumber: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    Equals: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    NotEquals: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    Contains: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsIn: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    IsNotIn: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    Gt: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    Lt: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    Gte: function (value, options) {
+        throw new Error("Function not implemented.");
+    },
+    Lte: function (value, options) {
+        throw new Error("Function not implemented.");
+    }
+};
+Object.keys(ValidFuncs).forEach((key) => {
+    FunctionValidator[key] = (value, options) => {
+        if (helper__namespace.isString(options)) {
+            options = { message: options, value: null };
+        }
+        if (!ValidFuncs[key](value, options)) {
+            throw new Error(options.message || `ValidatorError: invalid arguments.`);
+        }
+    };
+});
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-11-25 10:46:57
+ * @LastEditTime: 2022-02-24 15:33:34
+ */
+/**
+ * Validation parameter's type and values.
+ *
+ * @export
+ * @param {(ValidRules | ValidRules[] | Function)} rule
+ * @param {*} [options] If the options type is a string, the value is the error message of the validation rule.
+ * Some validation rules require additional parameters, ext: @Valid("Gte", {message:"Requires value greater than or equal to 100", value: 100})
+ * @returns {*}  {ParameterDecorator}
+ */
+function Valid(rule, options) {
+    let rules = [];
+    if (helper__namespace.isString(rule)) {
+        rules = rule.split(",");
+    }
+    else {
+        rules = rule;
+    }
+    return (target, propertyKey, descriptor) => {
+        // 获取成员参数类型
+        const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey);
+        const type = (paramTypes[descriptor] && paramTypes[descriptor].name) ? paramTypes[descriptor].name : "object";
+        if (helper__namespace.isString(options)) {
+            options = { message: options, value: null };
+        }
+        koatty_container.IOCContainer.attachPropertyData(PARAM_RULE_KEY, {
+            name: propertyKey,
+            rule: rules,
+            options,
+            index: descriptor,
+            type
+        }, target, propertyKey);
+    };
+}
+/**
+ * Validation parameter's type and values from DTO class.
+ *
+ * @export
+ * @returns {MethodDecorator}
+ */
+function Validated() {
+    return (target, propertyKey, descriptor) => {
+        //
+        koatty_container.IOCContainer.savePropertyData(PARAM_CHECK_KEY, {
+            dtoCheck: 1
+        }, target, propertyKey);
+        // 获取成员参数类型
+        // const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
+        // const { value, configurable, enumerable } = descriptor;
+        // descriptor = {
+        //     configurable,
+        //     enumerable,
+        //     writable: true,
+        //     value: async function valid(...props: any[]) {
+        //         const ps: any[] = [];
+        //         // tslint:disable-next-line: no-unused-expression
+        //         (props || []).map((value: any, index: number) => {
+        //             const type = (paramTypes[index] && paramTypes[index].name) ? paramTypes[index].name : "any";
+        //             if (!paramterTypes[type]) {
+        //                 ps.push(ClassValidator.valid(paramTypes[index], value, true));
+        //             } else {
+        //                 ps.push(Promise.resolve(value));
+        //             }
+        //         });
+        //         if (ps.length > 0) {
+        //             props = await Promise.all(ps);
+        //         }
+        //         // tslint:disable-next-line: no-invalid-this
+        //         return value.apply(this, props);
+        //     }
+        // };
+        // return descriptor;
+    };
+}
+/**
+ * Marks property as included in the process of transformation.
+ *
+ * @export
+ * @returns {PropertyDecorator}
+ */
+function Expose() {
+    return function (object, propertyName) {
+        const types = Reflect.getMetadata("design:type", object, propertyName);
+        if (types) {
+            const originMap = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, object);
+            originMap.set(propertyName, types.name);
+        }
+    };
+}
+/**
+ * Identifies that the field needs to be defined
+ *
+ * @export
+ * @returns {PropertyDecorator}
+ */
+function IsDefined() {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+    };
+}
+/**
+ * Checks if value is a chinese name.
+ *
+ * @export
+ * @param {string} property
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsCnName(validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "IsCnName",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return cnName(value);
+                },
+                defaultMessage(args) {
+                    return "invalid parameter ($property).";
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if value is a idCard number(chinese).
+ *
+ * @export
+ * @param {string} property
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsIdNumber(validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "IsIdNumber",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return idNumber(value);
+                },
+                defaultMessage(args) {
+                    return "invalid parameter ($property).";
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if value is a zipCode(chinese).
+ *
+ * @export
+ * @param {string} property
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsZipCode(validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "IsZipCode",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return zipCode(value);
+                },
+                defaultMessage(args) {
+                    return "invalid parameter ($property).";
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if value is a mobile phone number(chinese).
+ *
+ * @export
+ * @param {string} property
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsMobile(validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "IsMobile",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return mobile(value);
+                },
+                defaultMessage(args) {
+                    return "invalid parameter ($property).";
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if value is a plate number(chinese).
+ *
+ * @export
+ * @param {string} property
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsPlateNumber(validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "IsPlateNumber",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return plateNumber(value);
+                },
+                defaultMessage(args) {
+                    return "invalid parameter ($property).";
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks value is not empty, undefined, null, '', NaN, [], {} and any empty string(including spaces, tabs, formfeeds, etc.), returns false.
+ *
+ * @export
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsNotEmpty(validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "IsNotEmpty",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return !helper__namespace.isEmpty(value);
+                },
+                defaultMessage(args) {
+                    return "invalid parameter ($property).";
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if value matches ("===") the comparison.
+ *
+ * @export
+ * @param {*} comparison
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function Equals(comparison, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vEquals",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.equals(value, comparison);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter, ($property) must be equals ${comparison}.`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if value does not match ("!==") the comparison.
+ *
+ * @export
+ * @param {*} comparison
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function NotEquals(comparison, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vNotEquals",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.notEquals(value, comparison);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter, ($property) must be not equals ${comparison}.`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the string contains the seed.
+ *
+ * @export
+ * @param {string} seed
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function Contains(seed, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vContains",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.contains(value, seed);
+                    // return typeof value === "string" && (value.indexOf(seed) > -1);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter, ($property) must be contains ${seed}.`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if given value is in a array of allowed values.
+ *
+ * @export
+ * @param {any[]} possibleValues
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsIn(possibleValues, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsIn",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isIn(value, possibleValues);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if given value not in a array of allowed values.
+ *
+ * @export
+ * @param {any[]} possibleValues
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsNotIn(possibleValues, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsNotIn",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isNotIn(value, possibleValues);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if a given value is a real date.
+ *
+ * @export
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsDate(validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsDate",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isDate(value);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the first number is greater than or equal to the min value.
+ *
+ * @export
+ * @param {number} min
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function Gt(min, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vMin",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return helper__namespace.toNumber(value) > min;
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the first number is less than or equal to the max value.
+ *
+ * @export
+ * @param {number} max
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function Lt(max, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vMax",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return helper__namespace.toNumber(value) < max;
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the first number is greater than or equal to the min value.
+ *
+ * @export
+ * @param {number} min
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function Gte(min, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vMin",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return helper__namespace.toNumber(value) >= min;
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the first number is less than or equal to the max value.
+ *
+ * @export
+ * @param {number} max
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function Lte(max, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vMax",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return helper__namespace.toNumber(value) <= max;
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the string's length falls in a range. Note: this function takes into account surrogate pairs.
+ * If given value is not a string, then it returns false.
+ *
+ * @export
+ * @param {number} min
+ * @param {number} [max]
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function Length(min, max, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vLength",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.length(value, min, max);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the string is an email. If given value is not a string, then it returns false.
+ *
+ * @export
+ * @param {IsEmailOptions} [options]
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsEmail(options, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsEmail",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isEmail(value);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the string is an IP (version 4 or 6). If given value is not a string, then it returns false.
+ *
+ * @export
+ * @param {number} [version]
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsIP(version, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsIP",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isIP(value, version);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the string is a valid phone number.
+ *
+ * @export
+ * @param {string} {string} region 2 characters uppercase country code (e.g. DE, US, CH).
+ * If users must enter the intl. prefix (e.g. +41), then you may pass "ZZ" or null as region.
+ * See [google-libphonenumber, metadata.js:countryCodeToRegionCodeMap on github]
+ * {@link https://github.com/ruimarinho/google-libphonenumber/blob/1e46138878cff479aafe2ce62175c6c49cb58720/src/metadata.js#L33}
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsPhoneNumber(region, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsPhoneNumber",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isPhoneNumber(value, region);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * Checks if the string is an url.
+ *
+ * @export
+ * @param {IsURLOptions} [options]
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsUrl(options, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsUrl",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isURL(value, options);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter ($property).`;
+                }
+            }
+        });
+    };
+}
+/**
+ * check if the string is a hash of type algorithm. Algorithm is one of ['md4', 'md5', 'sha1', 'sha256',
+ * 'sha384', 'sha512', 'ripemd128', 'ripemd160', 'tiger128', 'tiger160', 'tiger192', 'crc32', 'crc32b']
+ *
+ * @export
+ * @param {HashAlgorithm} algorithm
+ * @param {ValidationOptions} [validationOptions]
+ * @returns {PropertyDecorator}
+ */
+function IsHash(algorithm, validationOptions) {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+        classValidator.registerDecorator({
+            name: "vIsHash",
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    return classValidator.isHash(value, algorithm);
+                },
+                defaultMessage(args) {
+                    return `invalid parameter, ($property) must be is an ${algorithm} Hash string.`;
+                }
+            }
+        });
+    };
+}
+
+exports.ClassValidator = ClassValidator;
+exports.Contains = Contains;
+exports.ENABLE_VALIDATED = ENABLE_VALIDATED;
+exports.Equals = Equals;
+exports.Expose = Expose;
+exports.FunctionValidator = FunctionValidator;
+exports.Gt = Gt;
+exports.Gte = Gte;
+exports.IsCnName = IsCnName;
+exports.IsDate = IsDate;
+exports.IsDefined = IsDefined;
+exports.IsEmail = IsEmail;
+exports.IsHash = IsHash;
+exports.IsIP = IsIP;
+exports.IsIdNumber = IsIdNumber;
+exports.IsIn = IsIn;
+exports.IsMobile = IsMobile;
+exports.IsNotEmpty = IsNotEmpty;
+exports.IsNotIn = IsNotIn;
+exports.IsPhoneNumber = IsPhoneNumber;
+exports.IsPlateNumber = IsPlateNumber;
+exports.IsUrl = IsUrl;
+exports.IsZipCode = IsZipCode;
+exports.Length = Length;
+exports.Lt = Lt;
+exports.Lte = Lte;
+exports.NotEquals = NotEquals;
+exports.PARAM_CHECK_KEY = PARAM_CHECK_KEY;
+exports.PARAM_RULE_KEY = PARAM_RULE_KEY;
+exports.PARAM_TYPE_KEY = PARAM_TYPE_KEY;
+exports.Valid = Valid;
+exports.Validated = Validated;
+exports.checkParamsType = checkParamsType;
+exports.convertDtoParamsType = convertDtoParamsType;
+exports.convertParamsType = convertParamsType;
+exports.plainToClass = plainToClass;