koatty_validation 1.3.4 → 1.4.0

package/dist/index.js

@@ -1,16 +1,17 @@
 /*!
 * @Author: richen
-* @Date: 2024-10-31 17:02:42
+* @Date: 2025-06-10 23:32:27
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
 'use strict';
 
-var classValidator = require('class-validator');
 var helper = require('koatty_lib');
-var koatty_container = require('koatty_container');
 require('reflect-metadata');
+var koatty_container = require('koatty_container');
+var classValidator = require('class-validator');
+var lruCache = require('lru-cache');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -38,6 +39,8 @@ var helper__namespace = /*#__PURE__*/_interopNamespaceDefault(helper);
  * @ version: 2020-03-20 11:34:38
  */
 // tslint:disable-next-line: no-import-side-effect
+// 参数类型键常量
+const PARAM_TYPE_KEY = 'PARAM_TYPE_KEY';
 /**
  * Set property as included in the process of transformation.
  *
@@ -206,7 +209,7 @@ function convertParamsType(param, type) {
         }
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
-    catch (err) {
+    catch (_err) {
         return param;
     }
 }
@@ -354,10 +357,9 @@ function plateNumber(value) {
  * @Usage:
  * @Author: richen
  * @Date: 2021-11-25 10:47:04
- * @LastEditTime: 2024-10-31 16:57:28
+ * @LastEditTime: 2024-01-03 14:32:49
  */
 // 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";
@@ -413,10 +415,20 @@ class ValidateClass {
      * @memberof ValidateClass
      */
     async valid(Clazz, data, convert = false) {
-        const obj = data instanceof Clazz ? data : plainToClass(Clazz, data, convert);
-        const errors = convert
-            ? await classValidator.validate(obj)
-            : await classValidator.validate(obj, { skipMissingProperties: true });
+        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]);
         }
@@ -589,751 +601,858 @@ const ValidFuncs = {
  * @param {(string | ValidOtpions)} [options]
  * @returns {*}
  */
-const FunctionValidator = {};
+/* eslint-disable @typescript-eslint/no-unused-vars */
+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.");
+    }
+};
+/* eslint-enable @typescript-eslint/no-unused-vars */
 Object.keys(ValidFuncs).forEach((key) => {
     FunctionValidator[key] = (value, options) => {
-        if (helper__namespace.isString(options)) {
-            options = { message: options, value: null };
+        let validOptions;
+        if (typeof options === 'string') {
+            validOptions = { message: options, value: null };
+        }
+        else {
+            validOptions = options || { message: `ValidatorError: invalid arguments.`, value: null };
         }
-        if (!ValidFuncs[key](value, options.value)) {
-            throw new Error(options.message || `ValidatorError: invalid arguments.`);
+        if (!ValidFuncs[key](value, validOptions.value)) {
+            throw new Error(validOptions.message || `ValidatorError: invalid arguments.`);
         }
     };
 });
 
-/*
- * @Description:
- * @Usage:
- * @Author: richen
- * @Date: 2021-11-25 10:46:57
- * @LastEditTime: 2024-10-31 16:49:26
- */
 /**
- * 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}
+ * 装饰器工厂 - 消除装饰器代码重复
+ * @author richen
  */
-function Valid(rule, options) {
-    let rules = [];
-    if (helper__namespace.isString(rule)) {
-        rules = rule.split(",");
-    }
-    else {
-        rules = rule;
-    }
-    return (target, propertyKey, descriptor) => {
-        var _a;
-        // 获取成员参数类型
-        const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey);
-        const type = ((_a = paramTypes[descriptor]) === null || _a === void 0 ? void 0 : _a.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}
+ * 创建验证装饰器的工厂函数
+ * @param options 装饰器配置选项
+ * @returns 装饰器工厂函数
  */
-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;
+function createValidationDecorator(options) {
+    const { name, validator, defaultMessage, requiresValue = false } = options;
+    return function decoratorFactory(...args) {
+        // 处理参数：最后一个参数是ValidationOptions，前面是验证函数的参数
+        const validationOptions = args[args.length - 1];
+        const validatorArgs = requiresValue ? args.slice(0, -1) : [];
+        return function propertyDecorator(object, propertyName) {
+            // 设置属性为可导出
+            setExpose(object, propertyName);
+            // 注册验证装饰器
+            classValidator.registerDecorator({
+                name,
+                target: object.constructor,
+                propertyName,
+                options: validationOptions,
+                constraints: validatorArgs,
+                validator: {
+                    validate(value) {
+                        try {
+                            return validator(value, ...validatorArgs);
+                        }
+                        catch {
+                            return false;
+                        }
+                    },
+                    defaultMessage(validationArguments) {
+                        const property = validationArguments.property;
+                        return defaultMessage
+                            ? defaultMessage.replace('$property', property)
+                            : `Invalid value for ${property}`;
+                    }
+                }
+            });
+        };
     };
 }
 /**
- * Marks property as included in the process of transformation.
- *
- * @export
- * @returns {PropertyDecorator}
+ * 创建简单验证装饰器（不需要额外参数）
+ * @param name 装饰器名称
+ * @param validator 验证函数
+ * @param defaultMessage 默认错误信息
+ * @returns 装饰器函数
  */
-function Expose() {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-    };
+function createSimpleDecorator(name, validator, defaultMessage) {
+    return createValidationDecorator({
+        name,
+        validator,
+        defaultMessage,
+        requiresValue: false
+    });
 }
 /**
- * Alias of Expose
- *
- * @export
- * @returns {PropertyDecorator}
+ * 创建带参数的验证装饰器
+ * @param name 装饰器名称
+ * @param validator 验证函数
+ * @param defaultMessage 默认错误信息
+ * @returns 装饰器工厂函数
  */
-function IsDefined() {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-    };
+function createParameterizedDecorator(name, validator, defaultMessage) {
+    return createValidationDecorator({
+        name,
+        validator,
+        defaultMessage,
+        requiresValue: true
+    });
 }
+
 /**
- * Checks if value is a chinese name.
- *
- * @export
- * @param {string} property
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 重构后的装饰器定义 - 使用工厂函数消除重复
+ * @author richen
  */
-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).";
-                }
-            }
-        });
-    };
+// 中国本土化验证装饰器
+const IsCnName = createSimpleDecorator('IsCnName', (value) => helper__namespace.isString(value) && cnName(value), 'must be a valid Chinese name');
+const IsIdNumber = createSimpleDecorator('IsIdNumber', (value) => helper__namespace.isString(value) && idNumber(value), 'must be a valid ID number');
+const IsZipCode = createSimpleDecorator('IsZipCode', (value) => helper__namespace.isString(value) && zipCode(value), 'must be a valid zip code');
+const IsMobile = createSimpleDecorator('IsMobile', (value) => helper__namespace.isString(value) && mobile(value), 'must be a valid mobile number');
+const IsPlateNumber = createSimpleDecorator('IsPlateNumber', (value) => helper__namespace.isString(value) && plateNumber(value), 'must be a valid plate number');
+// 基础验证装饰器
+const IsNotEmpty = createSimpleDecorator('IsNotEmpty', (value) => !helper__namespace.isEmpty(value), 'should not be empty');
+const IsDate = createSimpleDecorator('IsDate', (value) => helper__namespace.isDate(value), 'must be a valid date');
+// 带参数的验证装饰器
+const Equals = createParameterizedDecorator('Equals', (value, comparison) => value === comparison, 'must equal to $constraint1');
+const NotEquals = createParameterizedDecorator('NotEquals', (value, comparison) => value !== comparison, 'should not equal to $constraint1');
+const Contains = createParameterizedDecorator('Contains', (value, seed) => helper__namespace.isString(value) && value.includes(seed), 'must contain $constraint1');
+const IsIn = createParameterizedDecorator('IsIn', (value, possibleValues) => possibleValues.includes(value), 'must be one of the following values: $constraint1');
+const IsNotIn = createParameterizedDecorator('IsNotIn', (value, possibleValues) => !possibleValues.includes(value), 'should not be one of the following values: $constraint1');
+// 数值比较装饰器
+const Gt = createParameterizedDecorator('Gt', (value, min) => helper__namespace.toNumber(value) > min, 'must be greater than $constraint1');
+const Gte = createParameterizedDecorator('Gte', (value, min) => helper__namespace.toNumber(value) >= min, 'must be greater than or equal to $constraint1');
+const Lt = createParameterizedDecorator('Lt', (value, max) => helper__namespace.toNumber(value) < max, 'must be less than $constraint1');
+const Lte = createParameterizedDecorator('Lte', (value, max) => helper__namespace.toNumber(value) <= max, 'must be less than or equal to $constraint1');
+// 复杂验证装饰器（需要特殊处理）
+function IsEmail(options, validationOptions) {
+    return createParameterizedDecorator('IsEmail', (value) => classValidator.isEmail(value, options), 'must be a valid email')(validationOptions);
+}
+function IsIP(version, validationOptions) {
+    return createParameterizedDecorator('IsIP', (value) => classValidator.isIP(value, version), 'must be a valid IP address')(validationOptions);
+}
+function IsPhoneNumber(region, validationOptions) {
+    return createParameterizedDecorator('IsPhoneNumber', (value) => classValidator.isPhoneNumber(value, region), 'must be a valid phone number')(validationOptions);
+}
+function IsUrl(options, validationOptions) {
+    return createParameterizedDecorator('IsUrl', (value) => classValidator.isURL(value, options), 'must be a valid URL')(validationOptions);
 }
+function IsHash(algorithm, validationOptions) {
+    return createParameterizedDecorator('IsHash', (value) => classValidator.isHash(value, algorithm), 'must be a valid hash')(validationOptions);
+}
+// 基础工具装饰器（从原始decorator.ts移植）
 /**
- * Checks if value is a idCard number(chinese).
- *
- * @export
- * @param {string} property
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 标记属性为可导出
  */
-function IsIdNumber(validationOptions) {
+function Expose() {
     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}
+ * Expose的别名
  */
-function IsZipCode(validationOptions) {
+function IsDefined() {
     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).";
-                }
-            }
-        });
+function Valid(rule, options) {
+    return function (object, propertyName, parameterIndex) {
+        // 这里保持与原始实现一致
+        const existingRules = Reflect.getOwnMetadata("validate", object, propertyName) || {};
+        existingRules[parameterIndex] = { rule, options };
+        Reflect.defineMetadata("validate", existingRules, object, propertyName);
     };
 }
 /**
- * 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).";
-                }
-            }
-        });
+function Validated() {
+    return function (object, propertyName, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            // 这里可以添加验证逻辑
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
     };
 }
+
 /**
- * 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}
+ * 改进的错误处理机制
+ * @author richen
  */
-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}.`;
-                }
-            }
-        });
-    };
-}
+const ERROR_MESSAGES = {
+    zh: {
+        // 中国本土化验证
+        IsCnName: '必须是有效的中文姓名',
+        IsIdNumber: '必须是有效的身份证号码',
+        IsZipCode: '必须是有效的邮政编码',
+        IsMobile: '必须是有效的手机号码',
+        IsPlateNumber: '必须是有效的车牌号码',
+        // 基础验证
+        IsNotEmpty: '不能为空',
+        IsDate: '必须是有效的日期',
+        IsEmail: '必须是有效的邮箱地址',
+        IsIP: '必须是有效的IP地址',
+        IsPhoneNumber: '必须是有效的电话号码',
+        IsUrl: '必须是有效的URL地址',
+        IsHash: '必须是有效的哈希值',
+        // 比较验证
+        Equals: '必须等于 {comparison}',
+        NotEquals: '不能等于 {comparison}',
+        Contains: '必须包含 {seed}',
+        IsIn: '必须是以下值之一: {possibleValues}',
+        IsNotIn: '不能是以下值之一: {possibleValues}',
+        Gt: '必须大于 {min}',
+        Gte: '必须大于或等于 {min}',
+        Lt: '必须小于 {max}',
+        Lte: '必须小于或等于 {max}',
+        // 通用错误
+        invalidParameter: '参数 {field} 无效',
+        validationFailed: '验证失败',
+    },
+    en: {
+        // Chinese localization validators
+        IsCnName: 'must be a valid Chinese name',
+        IsIdNumber: 'must be a valid ID number',
+        IsZipCode: 'must be a valid zip code',
+        IsMobile: 'must be a valid mobile number',
+        IsPlateNumber: 'must be a valid plate number',
+        // Basic validators
+        IsNotEmpty: 'should not be empty',
+        IsDate: 'must be a valid date',
+        IsEmail: 'must be a valid email',
+        IsIP: 'must be a valid IP address',
+        IsPhoneNumber: 'must be a valid phone number',
+        IsUrl: 'must be a valid URL',
+        IsHash: 'must be a valid hash',
+        // Comparison validators
+        Equals: 'must equal to {comparison}',
+        NotEquals: 'should not equal to {comparison}',
+        Contains: 'must contain {seed}',
+        IsIn: 'must be one of the following values: {possibleValues}',
+        IsNotIn: 'should not be one of the following values: {possibleValues}',
+        Gt: 'must be greater than {min}',
+        Gte: 'must be greater than or equal to {min}',
+        Lt: 'must be less than {max}',
+        Lte: 'must be less than or equal to {max}',
+        // Common errors
+        invalidParameter: 'invalid parameter {field}',
+        validationFailed: 'validation failed',
+    }
+};
 /**
- * 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}.`;
-                }
-            }
-        });
-    };
+class KoattyValidationError extends Error {
+    constructor(errors, message) {
+        const errorMessage = message || 'Validation failed';
+        super(errorMessage);
+        this.name = 'KoattyValidationError';
+        this.errors = errors;
+        this.statusCode = 400;
+        this.timestamp = new Date();
+        // 确保正确的原型链
+        Object.setPrototypeOf(this, KoattyValidationError.prototype);
+    }
+    /**
+     * 获取第一个错误信息
+     */
+    getFirstError() {
+        return this.errors[0];
+    }
+    /**
+     * 获取指定字段的错误
+     */
+    getFieldErrors(field) {
+        return this.errors.filter(error => error.field === field);
+    }
+    /**
+     * 转换为JSON格式
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this.statusCode,
+            timestamp: this.timestamp,
+            errors: this.errors
+        };
+    }
 }
 /**
- * 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}.`;
-                }
+class ErrorMessageFormatter {
+    constructor(language = 'zh') {
+        this.language = 'zh';
+        this.language = language;
+    }
+    /**
+     * 设置语言
+     */
+    setLanguage(language) {
+        this.language = language;
+    }
+    /**
+     * 格式化错误消息
+     */
+    formatMessage(constraint, field, value, context) {
+        const messages = ERROR_MESSAGES[this.language];
+        let template = messages[constraint] || messages.invalidParameter;
+        // 替换占位符
+        template = template.replace('{field}', field);
+        // 优先使用上下文中的值，然后是传入的value
+        if (context) {
+            Object.entries(context).forEach(([key, val]) => {
+                template = template.replace(`{${key}}`, this.formatValue(val));
+            });
+        }
+        // 如果还有{value}占位符且传入了value，则替换
+        if (value !== undefined && template.includes('{value}')) {
+            template = template.replace('{value}', this.formatValue(value));
+        }
+        return template;
+    }
+    /**
+     * 格式化值用于消息显示
+     * @private
+     */
+    formatValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'string')
+            return `"${value}"`;
+        if (Array.isArray(value))
+            return `[${value.map(v => this.formatValue(v)).join(', ')}]`;
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
             }
-        });
-    };
+            catch {
+                // 处理循环引用
+                return '[Circular Reference]';
+            }
+        }
+        return String(value);
+    }
 }
 /**
- * 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).`;
-                }
-            }
-        });
-    };
-}
+const errorFormatter = new ErrorMessageFormatter();
 /**
- * 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).`;
-                }
-            }
-        });
-    };
+function setValidationLanguage(language) {
+    errorFormatter.setLanguage(language);
 }
 /**
- * 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).`;
-                }
-            }
-        });
+function createValidationError(field, value, constraint, customMessage, context) {
+    const message = customMessage || errorFormatter.formatMessage(constraint, field, value, context);
+    return {
+        field,
+        value,
+        constraint,
+        message,
+        context
     };
 }
 /**
- * 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).`;
-                }
-            }
-        });
-    };
+function createValidationErrors(errors) {
+    const validationErrors = errors.map(error => createValidationError(error.field, error.value, error.constraint, error.message, error.context));
+    return new KoattyValidationError(validationErrors);
 }
+
 /**
- * Checks if the first number is less than or equal to the max value.
- *
- * @export
- * @param {number} max
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 性能缓存模块 - 提供多层次缓存和性能监控
+ * @author richen
  */
-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).`;
-                }
-            }
-        });
-    };
+class MetadataCache {
+    constructor() {
+        this.cache = new WeakMap();
+    }
+    static getInstance() {
+        if (!MetadataCache.instance) {
+            MetadataCache.instance = new MetadataCache();
+        }
+        return MetadataCache.instance;
+    }
+    /**
+     * 获取类的元数据缓存
+     */
+    getClassCache(target) {
+        if (!this.cache.has(target)) {
+            this.cache.set(target, new Map());
+        }
+        return this.cache.get(target);
+    }
+    /**
+     * 缓存元数据
+     */
+    setMetadata(target, key, value) {
+        const classCache = this.getClassCache(target);
+        classCache.set(key, value);
+    }
+    /**
+     * 获取缓存的元数据
+     */
+    getMetadata(target, key) {
+        const classCache = this.getClassCache(target);
+        return classCache.get(key);
+    }
+    /**
+     * 检查是否已缓存
+     */
+    hasMetadata(target, key) {
+        const classCache = this.getClassCache(target);
+        return classCache.has(key);
+    }
+    /**
+     * 清空指定类的缓存
+     */
+    clearClassCache(target) {
+        if (this.cache.has(target)) {
+            this.cache.delete(target);
+        }
+    }
 }
 /**
- * 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).`;
-                }
-            }
+class ValidationCache {
+    constructor(options) {
+        this.cache = new lruCache.LRUCache({
+            max: (options === null || options === void 0 ? void 0 : options.max) || 5000,
+            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 10, // 10分钟
+            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
+            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
         });
-    };
+    }
+    static getInstance(options) {
+        if (!ValidationCache.instance) {
+            ValidationCache.instance = new ValidationCache(options);
+        }
+        return ValidationCache.instance;
+    }
+    /**
+     * 生成缓存键
+     */
+    generateKey(validator, value, ...args) {
+        const valueStr = this.serializeValue(value);
+        const argsStr = args.length > 0 ? JSON.stringify(args) : '';
+        return `${validator}:${valueStr}:${argsStr}`;
+    }
+    /**
+     * 序列化值用于缓存键
+     */
+    serializeValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string')
+            return `s:${value}`;
+        if (typeof value === 'number')
+            return `n:${value}`;
+        if (typeof value === 'boolean')
+            return `b:${value}`;
+        if (Array.isArray(value))
+            return `a:${JSON.stringify(value)}`;
+        if (typeof value === 'object')
+            return `o:${JSON.stringify(value)}`;
+        return String(value);
+    }
+    /**
+     * 获取缓存的验证结果
+     */
+    get(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        return this.cache.get(key);
+    }
+    /**
+     * 缓存验证结果
+     */
+    set(validator, value, result, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        this.cache.set(key, result);
+    }
+    /**
+     * 检查是否存在缓存
+     */
+    has(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        return this.cache.has(key);
+    }
+    /**
+     * 删除特定缓存
+     */
+    delete(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        return this.cache.delete(key);
+    }
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * 获取缓存统计
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            max: this.cache.max,
+            calculatedSize: this.cache.calculatedSize,
+            keyCount: this.cache.size,
+        };
+    }
+    /**
+     * 设置缓存TTL
+     */
+    setTTL(validator, value, ttl, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        const existingValue = this.cache.get(key);
+        if (existingValue !== undefined) {
+            this.cache.set(key, existingValue, { ttl });
+        }
+    }
 }
 /**
- * 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).`;
-                }
+class RegexCache {
+    constructor(options) {
+        this.cache = new lruCache.LRUCache({
+            max: (options === null || options === void 0 ? void 0 : options.max) || 200,
+            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 30, // 30分钟
+            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
+            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
+        });
+    }
+    static getInstance(options) {
+        if (!RegexCache.instance) {
+            RegexCache.instance = new RegexCache(options);
+        }
+        return RegexCache.instance;
+    }
+    /**
+     * 获取缓存的正则表达式
+     */
+    get(pattern, flags) {
+        const key = flags ? `${pattern}:::${flags}` : pattern;
+        let regex = this.cache.get(key);
+        if (!regex) {
+            try {
+                regex = new RegExp(pattern, flags);
+                this.cache.set(key, regex);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (_error) {
+                // 如果正则表达式无效，抛出错误
+                throw new Error(`Invalid regex pattern: ${pattern}`);
+            }
+        }
+        return regex;
+    }
+    /**
+     * 预编译常用正则表达式
+     */
+    precompile(patterns) {
+        patterns.forEach(({ pattern, flags }) => {
+            try {
+                this.get(pattern, flags);
+            }
+            catch (error) {
+                console.warn(`Failed to precompile regex: ${pattern}`, error);
             }
         });
-    };
+    }
+    /**
+     * 获取缓存统计
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            max: this.cache.max,
+            calculatedSize: this.cache.calculatedSize,
+        };
+    }
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
+    }
 }
 /**
- * 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).`;
-                }
-            }
-        });
-    };
+class PerformanceMonitor {
+    constructor() {
+        this.metrics = new Map();
+    }
+    static getInstance() {
+        if (!PerformanceMonitor.instance) {
+            PerformanceMonitor.instance = new PerformanceMonitor();
+        }
+        return PerformanceMonitor.instance;
+    }
+    /**
+     * 开始计时
+     */
+    startTimer(name) {
+        const start = performance.now();
+        return () => {
+            const duration = performance.now() - start;
+            this.recordMetric(name, duration);
+        };
+    }
+    /**
+     * 记录性能指标
+     */
+    recordMetric(name, duration) {
+        if (!this.metrics.has(name)) {
+            this.metrics.set(name, {
+                count: 0,
+                totalTime: 0,
+                avgTime: 0,
+                maxTime: 0,
+                minTime: Infinity,
+                lastExecutionTime: new Date(),
+            });
+        }
+        const metric = this.metrics.get(name);
+        metric.count++;
+        metric.totalTime += duration;
+        metric.avgTime = metric.totalTime / metric.count;
+        metric.maxTime = Math.max(metric.maxTime, duration);
+        metric.minTime = Math.min(metric.minTime, duration);
+        metric.lastExecutionTime = new Date();
+    }
+    /**
+     * 获取性能报告
+     */
+    getReport() {
+        const report = {};
+        for (const [name, metric] of this.metrics) {
+            report[name] = {
+                ...metric,
+                minTime: metric.minTime === Infinity ? 0 : metric.minTime,
+                avgTimeFormatted: `${metric.avgTime.toFixed(2)}ms`,
+                totalTimeFormatted: `${metric.totalTime.toFixed(2)}ms`,
+            };
+        }
+        return report;
+    }
+    /**
+     * 获取热点分析（执行时间最长的操作）
+     */
+    getHotspots(limit = 10) {
+        return Array.from(this.metrics.entries())
+            .map(([name, metric]) => ({
+            name,
+            avgTime: metric.avgTime,
+            count: metric.count,
+        }))
+            .sort((a, b) => b.avgTime - a.avgTime)
+            .slice(0, limit);
+    }
+    /**
+     * 清空指标
+     */
+    clear() {
+        this.metrics.clear();
+    }
+    /**
+     * 导出性能数据为CSV格式
+     */
+    exportToCSV() {
+        const headers = ['Name', 'Count', 'Total Time (ms)', 'Avg Time (ms)', 'Max Time (ms)', 'Min Time (ms)', 'Last Execution'];
+        const rows = [headers.join(',')];
+        for (const [name, metric] of this.metrics) {
+            const row = [
+                name,
+                metric.count.toString(),
+                metric.totalTime.toFixed(2),
+                metric.avgTime.toFixed(2),
+                metric.maxTime.toFixed(2),
+                (metric.minTime === Infinity ? 0 : metric.minTime).toFixed(2),
+                metric.lastExecutionTime.toISOString(),
+            ];
+            rows.push(row.join(','));
+        }
+        return rows.join('\n');
+    }
 }
+// 导出单例实例
+const metadataCache = MetadataCache.getInstance();
+const validationCache = ValidationCache.getInstance();
+const regexCache = RegexCache.getInstance();
+const performanceMonitor = PerformanceMonitor.getInstance();
 /**
- * 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).`;
+function cached(validator, ttl) {
+    return function (target, propertyName, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const value = args[0];
+            const additionalArgs = args.slice(1);
+            // 尝试从缓存获取结果
+            const cachedResult = validationCache.get(validator, value, ...additionalArgs);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            // 执行验证并缓存结果
+            const endTimer = performanceMonitor.startTimer(validator);
+            try {
+                const result = originalMethod.apply(this, args);
+                validationCache.set(validator, value, result, ...additionalArgs);
+                // 如果指定了TTL，设置过期时间
+                if (ttl && ttl > 0) {
+                    validationCache.setTTL(validator, value, ttl, ...additionalArgs);
                 }
+                return result;
             }
-        });
+            finally {
+                endTimer();
+            }
+        };
+        return descriptor;
     };
 }
 /**
- * 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).`;
-                }
-            }
-        });
+function getAllCacheStats() {
+    return {
+        validation: validationCache.getStats(),
+        regex: regexCache.getStats(),
+        performance: performanceMonitor.getReport(),
+        hotspots: performanceMonitor.getHotspots(),
     };
 }
 /**
- * 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).`;
-                }
-            }
-        });
-    };
+function warmupCaches() {
+    // 预编译中文验证相关的正则表达式
+    const commonPatterns = [
+        { pattern: '^[\u4e00-\u9fa5]{2,8}$' }, // 中文姓名
+        { pattern: '^1[3-9]\\d{9}$' }, // 手机号
+        { pattern: '^\\d{6}$' }, // 邮政编码
+        { pattern: '^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼]' }, // 车牌号开头
+    ];
+    regexCache.precompile(commonPatterns);
 }
 /**
- * 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.`;
-                }
-            }
-        });
-    };
+function clearAllCaches() {
+    validationCache.clear();
+    regexCache.clear();
+    performanceMonitor.clear();
 }
 /**
- * Use a custom function for validation
- * @param func
- * @param validationOptions
- * @returns
+ * 配置缓存设置
  */
-function CheckFunc(func, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vCheckFunc",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return func(value);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
+function configureCaches(options) {
+    if (options.validation) {
+        // 重新创建验证缓存实例
+        ValidationCache.instance = new ValidationCache(options.validation);
+    }
+    if (options.regex) {
+        // 重新创建正则缓存实例
+        RegexCache.instance = new RegexCache(options.regex);
+    }
 }
 
-exports.CheckFunc = CheckFunc;
 exports.ClassValidator = ClassValidator;
 exports.Contains = Contains;
 exports.ENABLE_VALIDATED = ENABLE_VALIDATED;
+exports.ERROR_MESSAGES = ERROR_MESSAGES;
 exports.Equals = Equals;
+exports.ErrorMessageFormatter = ErrorMessageFormatter;
 exports.Expose = Expose;
 exports.FunctionValidator = FunctionValidator;
 exports.Gt = Gt;
@@ -1353,17 +1472,32 @@ exports.IsPhoneNumber = IsPhoneNumber;
 exports.IsPlateNumber = IsPlateNumber;
 exports.IsUrl = IsUrl;
 exports.IsZipCode = IsZipCode;
-exports.Length = Length;
+exports.KoattyValidationError = KoattyValidationError;
 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.ValidFuncs = ValidFuncs;
 exports.Validated = Validated;
+exports.cached = cached;
 exports.checkParamsType = checkParamsType;
+exports.clearAllCaches = clearAllCaches;
+exports.configureCaches = configureCaches;
 exports.convertDtoParamsType = convertDtoParamsType;
 exports.convertParamsType = convertParamsType;
+exports.createParameterizedDecorator = createParameterizedDecorator;
+exports.createSimpleDecorator = createSimpleDecorator;
+exports.createValidationDecorator = createValidationDecorator;
+exports.createValidationError = createValidationError;
+exports.createValidationErrors = createValidationErrors;
+exports.errorFormatter = errorFormatter;
+exports.getAllCacheStats = getAllCacheStats;
+exports.metadataCache = metadataCache;
+exports.performanceMonitor = performanceMonitor;
 exports.plainToClass = plainToClass;
+exports.regexCache = regexCache;
+exports.setValidationLanguage = setValidationLanguage;
+exports.validationCache = validationCache;
+exports.warmupCaches = warmupCaches;