ddan-js 1.2.3 → 1.2.4

package/bin/lib/modules/rule/async-validator/validator/method.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const method = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (value !== undefined) {
+            rule_1.default.type(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = method;

package/bin/lib/modules/rule/async-validator/validator/number.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const number = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if (value === '') {
+            value = undefined;
+        }
+        if ((0, util_1.isEmptyValue)(value) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (value !== undefined) {
+            rule_1.default.type(rule, value, source, errors, options);
+            rule_1.default.range(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = number;

package/bin/lib/modules/rule/async-validator/validator/object.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const object = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (value !== undefined) {
+            rule_1.default.type(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = object;

package/bin/lib/modules/rule/async-validator/validator/pattern.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const pattern = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value, 'string') && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (!(0, util_1.isEmptyValue)(value, 'string')) {
+            rule_1.default.pattern(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = pattern;

package/bin/lib/modules/rule/async-validator/validator/regexp.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const regexp = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (!(0, util_1.isEmptyValue)(value)) {
+            rule_1.default.type(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = regexp;

package/bin/lib/modules/rule/async-validator/validator/required.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const required = (rule, value, callback, source, options) => {
+    const errors = [];
+    const type = Array.isArray(value) ? 'array' : typeof value;
+    rule_1.default.required(rule, value, source, errors, options, type);
+    callback(errors);
+};
+exports.default = required;

package/bin/lib/modules/rule/async-validator/validator/string.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const string = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field || ""));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value, 'string') && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options, 'string');
+        if (!(0, util_1.isEmptyValue)(value, 'string')) {
+            rule_1.default.type(rule, value, source, errors, options);
+            rule_1.default.range(rule, value, source, errors, options);
+            rule_1.default.pattern(rule, value, source, errors, options);
+            if (rule.whitespace === true) {
+                rule_1.default.whitespace(rule, value, source, errors, options);
+            }
+        }
+    }
+    callback(errors);
+};
+exports.default = string;

package/bin/lib/modules/rule/async-validator/validator/type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const type = (rule, value, callback, source, options) => {
+    const ruleType = rule.type;
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value, ruleType) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options, ruleType);
+        if (!(0, util_1.isEmptyValue)(value, ruleType)) {
+            rule_1.default.type(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = type;

package/bin/lib/modules/rule/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const hook_1 = require("../hook");
+const async_validator_1 = require("./async-validator");
 function validateId(content) {
     if (!content)
         return false;
@@ -20,34 +22,10 @@ function validatePhone(content) {
     }
     return true;
 }
-// function validate(ob, rules, cb = (valid, rule) => {}) {
-//   if (!ob) return false;
-//   for (const rule of rules) {
-//     if (!rule || !rule.name || !rule.rules) continue;
-//     const val = ob[rule.name];
-//     let invalid = !val;
-//     if (!invalid && Array.isArray(val)) {
-//       invalid = val.length <= 0 || !val.every((e) => !!e);
-//     }
-//     if (Array.isArray(rule.rules)) {
-//       for (const item of rule.rules) {
-//         if (invalid && item.required) {
-//           cb && cb(rule, item);
-//           return false;
-//         }
-//       }
-//     } else {
-//       if (invalid && rule.rules.required) {
-//         cb && cb(rule, rule.rules);
-//         return false;
-//       } else if (rule.rules.validator) {
-//         if (!rule.rules.validator(rule, val)) {
-//           cb && cb(rule, rule.rules);
-//           return false;
-//         }
-//       }
-//     }
-//   }
-//   return true;
-// }
-exports.default = { validateId, validatePhone };
+function validator(rules) {
+    return new async_validator_1.default(rules);
+}
+function validate(rules, source_, o = {}, oc = () => { }) {
+    return hook_1.default.run(validator(rules).validate(source_, o, oc));
+}
+exports.default = { validateId, validatePhone, validator, validate };

package/bin/lib/modules/url/index.js

@@ -2,4 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const decode_1 = require("./decode");
 const encode_1 = require("./encode");
-exports.default = { parse: decode_1.default, decode: decode_1.default, stringify: encode_1.default, encode: encode_1.default };
+function useHttps(url) {
+    if (!url)
+        return url;
+    const tUrl = url.trim();
+    if (typeof url !== "string")
+        return url;
+    if (tUrl.indexOf("https") < 0) {
+        return tUrl.replace("http", "https");
+    }
+    return tUrl;
+}
+exports.default = { parse: decode_1.default, decode: decode_1.default, stringify: encode_1.default, encode: encode_1.default, useHttps };

package/bin/lib/util/index.js

@@ -3,4 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = require("./is");
 const _object_1 = require("../common/_object");
 const includes_1 = require("./includes");
-exports.default = Object.assign(Object.assign(Object.assign({}, is_1.default), _object_1.default), { includes: includes_1.default });
+function compareArray(arr1, arr2) {
+    if (!Array.isArray(arr1) || !Array.isArray(arr2))
+        return false;
+    if (arr1.length !== arr2.length)
+        return false;
+    for (let i = 0, len = arr1.length; i < len; i++) {
+        if (arr1[i] !== arr2[i])
+            return false;
+    }
+    return true;
+}
+function merge(target, source) {
+    if (!source)
+        return target;
+    if (!target)
+        return source;
+    Object.keys(source).forEach((key) => {
+        if (Array.isArray(target[key]) && Array.isArray(source[key])) {
+            target[key] = target[key].concat(source[key]);
+        }
+        else if (typeof target[key] === "object" && typeof source[key] === "object") {
+            target[key] = Object.assign(target[key], source[key]);
+        }
+        else {
+            target[key] = source[key];
+        }
+    });
+    return target;
+}
+exports.default = Object.assign(Object.assign(Object.assign({}, is_1.default), _object_1.default), { includes: includes_1.default, merge, compareArray });

package/bin/types/index.d.ts

@@ -37,6 +37,8 @@ declare const _default: {
     };
     util: {
         includes: typeof import("./util/includes").default;
+        merge: (target: any, source: any) => any;
+        compareArray: (arr1: any, arr2: any) => boolean;
         getTag: (value: any) => string;
         getType: (value: any) => string;
         toString: () => string;
@@ -96,10 +98,13 @@ declare const _default: {
             name?: null | undefined;
             multiple?: boolean | undefined;
         }) => string;
+        useHttps: (url: string) => string;
     };
     rule: {
         validateId: (content: any) => boolean;
         validatePhone: (content: any) => boolean;
+        validator: (rules: import("./modules/rule/async-validator").Rules) => import("./modules/rule/async-validator").default;
+        validate: (rules: import("./modules/rule/async-validator").Rules, source_: import("./modules/rule/async-validator").Values, o?: any, oc?: any) => Promise<import("./modules/rule/async-validator").Values>;
     };
     DEvent: typeof DEvent;
     store: typeof store;

package/bin/types/modules/rule/async-validator/index.d.ts

@@ -0,0 +1,43 @@
+import { InternalRuleItem, InternalValidateMessages, RuleItem, Rules, ValidateCallback, ValidateMessages, ValidateOption, Values, SyncErrorType } from './interface';
+export * from './interface';
+/**
+ *  Encapsulates a validation schema.
+ *
+ *  @param descriptor An object declaring validation rules
+ *  for this schema.
+ */
+declare class Schema {
+    static register: (type: string, validator: any) => void;
+    static warning: (type: string, errors: SyncErrorType[]) => void;
+    static messages: InternalValidateMessages;
+    static validators: {
+        string: import("./interface").ExecuteValidator;
+        method: import("./interface").ExecuteValidator;
+        number: import("./interface").ExecuteValidator;
+        boolean: import("./interface").ExecuteValidator;
+        regexp: import("./interface").ExecuteValidator;
+        integer: import("./interface").ExecuteValidator;
+        float: import("./interface").ExecuteValidator;
+        array: import("./interface").ExecuteValidator;
+        object: import("./interface").ExecuteValidator;
+        enum: import("./interface").ExecuteValidator;
+        pattern: import("./interface").ExecuteValidator;
+        date: import("./interface").ExecuteValidator;
+        url: import("./interface").ExecuteValidator;
+        hex: import("./interface").ExecuteValidator;
+        email: import("./interface").ExecuteValidator;
+        required: import("./interface").ExecuteValidator;
+        any: import("./interface").ExecuteValidator;
+    };
+    rules: Record<string, RuleItem[]>;
+    _messages: InternalValidateMessages;
+    constructor(descriptor: Rules);
+    define(rules: Rules): void;
+    messages(messages?: ValidateMessages): InternalValidateMessages;
+    validate(source: Values, option?: ValidateOption, callback?: ValidateCallback): Promise<Values>;
+    validate(source: Values, callback: ValidateCallback): Promise<Values>;
+    validate(source: Values): Promise<Values>;
+    getType(rule: InternalRuleItem): import("./interface").RuleType;
+    getValidationMethod(rule: InternalRuleItem): import("./interface").ExecuteValidator | ((rule: InternalRuleItem, value: any, callback: (error?: string | Error | undefined) => void, source: Values, options: ValidateOption) => void | import("./interface").SyncValidateResult);
+}
+export default Schema;

package/bin/types/modules/rule/async-validator/interface.d.ts

@@ -0,0 +1,135 @@
+export type RuleType = 'string' | 'number' | 'boolean' | 'method' | 'regexp' | 'integer' | 'float' | 'array' | 'object' | 'enum' | 'date' | 'url' | 'hex' | 'email' | 'pattern' | 'any';
+export interface ValidateOption {
+    suppressWarning?: boolean;
+    suppressValidatorError?: boolean;
+    first?: boolean;
+    firstFields?: boolean | string[];
+    messages?: Partial<ValidateMessages>;
+    /** The name of rules need to be trigger. Will validate all rules if leave empty */
+    keys?: string[];
+    error?: (rule: InternalRuleItem, message: string) => ValidateError;
+}
+export type SyncErrorType = Error | string;
+export type SyncValidateResult = boolean | SyncErrorType | SyncErrorType[];
+export type ValidateResult = void | Promise<void> | SyncValidateResult;
+export interface RuleItem {
+    type?: RuleType;
+    required?: boolean;
+    pattern?: RegExp | string;
+    min?: number;
+    max?: number;
+    len?: number;
+    enum?: Array<string | number | boolean | null | undefined>;
+    whitespace?: boolean;
+    fields?: Record<string, Rule>;
+    options?: ValidateOption;
+    defaultField?: Rule;
+    transform?: (value: Value) => Value;
+    message?: string | ((a?: string) => string);
+    asyncValidator?: (rule: InternalRuleItem, value: Value, callback: (error?: string | Error) => void, source: Values, options: ValidateOption) => void | Promise<void>;
+    validator?: (rule: InternalRuleItem, value: Value, callback: (error?: string | Error) => void, source: Values, options: ValidateOption) => SyncValidateResult | void;
+}
+export type Rule = RuleItem | RuleItem[];
+export type Rules = Record<string, Rule>;
+/**
+ *  Rule for validating a value exists in an enumerable list.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param source The source object being validated.
+ *  @param errors An array of errors that this rule may add
+ *  validation errors to.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ *  @param type Rule type
+ */
+export type ExecuteRule = (rule: InternalRuleItem, value: Value, source: Values, errors: string[], options: ValidateOption, type?: string) => void;
+/**
+ *  Performs validation for any type.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param callback The callback function.
+ *  @param source The source object being validated.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+export type ExecuteValidator = (rule: InternalRuleItem, value: Value, callback: (error?: string[]) => void, source: Values, options: ValidateOption) => void;
+type ValidateMessage<T extends any[] = unknown[]> = string | ((...args: T) => string);
+type FullField = string | undefined;
+type EnumString = string | undefined;
+type Pattern = string | RegExp | undefined;
+type Range = number | undefined;
+type Type = string | undefined;
+export interface ValidateMessages {
+    default?: ValidateMessage;
+    required?: ValidateMessage<[FullField]>;
+    enum?: ValidateMessage<[FullField, EnumString]>;
+    whitespace?: ValidateMessage<[FullField]>;
+    date?: {
+        format?: ValidateMessage;
+        parse?: ValidateMessage;
+        invalid?: ValidateMessage;
+    };
+    types?: {
+        string?: ValidateMessage<[FullField, Type]>;
+        method?: ValidateMessage<[FullField, Type]>;
+        array?: ValidateMessage<[FullField, Type]>;
+        object?: ValidateMessage<[FullField, Type]>;
+        number?: ValidateMessage<[FullField, Type]>;
+        date?: ValidateMessage<[FullField, Type]>;
+        boolean?: ValidateMessage<[FullField, Type]>;
+        integer?: ValidateMessage<[FullField, Type]>;
+        float?: ValidateMessage<[FullField, Type]>;
+        regexp?: ValidateMessage<[FullField, Type]>;
+        email?: ValidateMessage<[FullField, Type]>;
+        url?: ValidateMessage<[FullField, Type]>;
+        hex?: ValidateMessage<[FullField, Type]>;
+    };
+    string?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    number?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    array?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    pattern?: {
+        mismatch?: ValidateMessage<[FullField, Value, Pattern]>;
+    };
+}
+export interface InternalValidateMessages extends ValidateMessages {
+    clone: () => InternalValidateMessages;
+}
+export type Value = any;
+export type Values = Record<string, Value>;
+export interface ValidateError {
+    message?: string;
+    fieldValue?: Value;
+    field?: string;
+}
+export type ValidateFieldsError = Record<string, ValidateError[]>;
+export type ValidateCallback = (errors: ValidateError[] | null, fields: ValidateFieldsError | Values) => void;
+export interface RuleValuePackage {
+    rule: InternalRuleItem;
+    value: Value;
+    source: Values;
+    field: string;
+}
+export interface InternalRuleItem extends Omit<RuleItem, 'validator'> {
+    field?: string;
+    fullField?: string;
+    fullFields?: string[];
+    validator?: RuleItem['validator'] | ExecuteValidator;
+}
+export {};

package/bin/types/modules/rule/async-validator/messages.d.ts

@@ -0,0 +1,3 @@
+import { InternalValidateMessages } from './interface';
+export declare function newMessages(): InternalValidateMessages;
+export declare const messages: InternalValidateMessages;

package/bin/types/modules/rule/async-validator/rule/enum.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const enumerable: ExecuteRule;
+export default enumerable;

package/bin/types/modules/rule/async-validator/rule/index.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    required: import("..").ExecuteRule;
+    whitespace: import("..").ExecuteRule;
+    type: import("..").ExecuteRule;
+    range: import("..").ExecuteRule;
+    enum: import("..").ExecuteRule;
+    pattern: import("..").ExecuteRule;
+};
+export default _default;

package/bin/types/modules/rule/async-validator/rule/pattern.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const pattern: ExecuteRule;
+export default pattern;

package/bin/types/modules/rule/async-validator/rule/range.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const range: ExecuteRule;
+export default range;

package/bin/types/modules/rule/async-validator/rule/required.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const required: ExecuteRule;
+export default required;

package/bin/types/modules/rule/async-validator/rule/type.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const type: ExecuteRule;
+export default type;

package/bin/types/modules/rule/async-validator/rule/url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => RegExp;
+export default _default;

package/bin/types/modules/rule/async-validator/rule/whitespace.d.ts

@@ -0,0 +1,14 @@
+import { ExecuteRule } from '../interface';
+/**
+ *  Rule for validating whitespace.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param source The source object being validated.
+ *  @param errors An array of errors that this rule may add
+ *  validation errors to.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+declare const whitespace: ExecuteRule;
+export default whitespace;

package/bin/types/modules/rule/async-validator/util.d.ts

@@ -0,0 +1,16 @@
+import { ValidateError, ValidateOption, RuleValuePackage, InternalRuleItem, SyncErrorType, Value, Values } from './interface';
+export declare let warning: (type: string, errors: SyncErrorType[]) => void;
+export declare function convertFieldsError(errors: ValidateError[]): Record<string, ValidateError[]> | null;
+export declare function format(template: ((...args: any[]) => string) | string, ...args: any[]): string;
+export declare function isEmptyValue(value: Value, type?: string): boolean;
+export declare function isEmptyObject(obj: object): boolean;
+export declare class AsyncValidationError extends Error {
+    errors: ValidateError[];
+    fields: Record<string, ValidateError[]>;
+    constructor(errors: ValidateError[], fields: Record<string, ValidateError[]>);
+}
+type ValidateFunc = (data: RuleValuePackage, doIt: (errors: ValidateError[]) => void) => void;
+export declare function asyncMap(objArr: Record<string, RuleValuePackage[]>, option: ValidateOption, func: ValidateFunc, callback: (errors: ValidateError[]) => void, source: Values): Promise<Values>;
+export declare function complementError(rule: InternalRuleItem, source: Values): (oe: ValidateError | (() => string) | string) => ValidateError;
+export declare function deepMerge<T extends object>(target: T, source: Partial<T>): T;
+export {};

package/bin/types/modules/rule/async-validator/validator/any.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const any: ExecuteValidator;
+export default any;

package/bin/types/modules/rule/async-validator/validator/array.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const array: ExecuteValidator;
+export default array;

package/bin/types/modules/rule/async-validator/validator/boolean.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const boolean: ExecuteValidator;
+export default boolean;

package/bin/types/modules/rule/async-validator/validator/date.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const date: ExecuteValidator;
+export default date;

package/bin/types/modules/rule/async-validator/validator/enum.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const enumerable: ExecuteValidator;
+export default enumerable;

package/bin/types/modules/rule/async-validator/validator/float.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const floatFn: ExecuteValidator;
+export default floatFn;

package/bin/types/modules/rule/async-validator/validator/index.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    string: import("..").ExecuteValidator;
+    method: import("..").ExecuteValidator;
+    number: import("..").ExecuteValidator;
+    boolean: import("..").ExecuteValidator;
+    regexp: import("..").ExecuteValidator;
+    integer: import("..").ExecuteValidator;
+    float: import("..").ExecuteValidator;
+    array: import("..").ExecuteValidator;
+    object: import("..").ExecuteValidator;
+    enum: import("..").ExecuteValidator;
+    pattern: import("..").ExecuteValidator;
+    date: import("..").ExecuteValidator;
+    url: import("..").ExecuteValidator;
+    hex: import("..").ExecuteValidator;
+    email: import("..").ExecuteValidator;
+    required: import("..").ExecuteValidator;
+    any: import("..").ExecuteValidator;
+};
+export default _default;

package/bin/types/modules/rule/async-validator/validator/integer.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const integer: ExecuteValidator;
+export default integer;

package/bin/types/modules/rule/async-validator/validator/method.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const method: ExecuteValidator;
+export default method;

package/bin/types/modules/rule/async-validator/validator/number.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const number: ExecuteValidator;
+export default number;

package/bin/types/modules/rule/async-validator/validator/object.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const object: ExecuteValidator;
+export default object;

package/bin/types/modules/rule/async-validator/validator/pattern.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const pattern: ExecuteValidator;
+export default pattern;

package/bin/types/modules/rule/async-validator/validator/regexp.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const regexp: ExecuteValidator;
+export default regexp;

package/bin/types/modules/rule/async-validator/validator/required.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const required: ExecuteValidator;
+export default required;

package/bin/types/modules/rule/async-validator/validator/string.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteValidator } from '../interface';
+declare const string: ExecuteValidator;
+export default string;