@warlock.js/core 2.0.5 → 2.1.1

package/esm/validator/v/schema.js

@@ -1,7 +1,28 @@
-import {trans}from'@mongez/localization';import {clone}from'@mongez/reinforcements';import {isPlainObject}from'@mongez/supportive-is';import {stripUnknownMutator,objectTrimMutator,flipArrayMutator,uniqueArrayMutator,sortArrayMutator,stringMutator,lowercaseMutator,uppercaseMutator,dateMutator,numberMutator}from'./mutators.js';import {requiredRule,requiredWithRule,requiredIfAbsentRule,requiredIfEmptyRule,requiredIfFieldRule,objectRule,unknownKeyRule,arrayRule,minLengthRule,maxLengthRule,lengthRule,uniqueArrayRule,stringRule,emailRule,urlRule,matchesRule,patternRule,enumRule,equalRule,uniqueRule,existsRule,dateRule,intRule,floatRule,booleanRule,scalarRule,fileRile,imageRule,minFileSizeRule,maxFileSizeRule,minWidthRule,maxWidthRule,minHeightRule,numberRule,minRule,maxRule,positiveRule}from'./rules.js';import {setKeyPath}from'./utils.js';class BaseValidator {
+import {trans}from'@mongez/localization';import {clone}from'@mongez/reinforcements';import {isPlainObject}from'@mongez/supportive-is';import {stripUnknownMutator,objectTrimMutator,flipArrayMutator,uniqueArrayMutator,sortArrayMutator,stringMutator,lowercaseMutator,uppercaseMutator,capitalizeMutator,dateMutator,numberMutator}from'./mutators.js';import {equalRule,requiredRule,requiredWithRule,requiredIfAbsentRule,requiredIfSiblingFieldAllAbsentRule,requiredIfEmptyRule,requiredIfSiblingFieldEmptyRule,requiredIfFieldRule,requiredIfSiblingFieldRule,requiredUnlessSiblingFieldRule,forbiddenRule,whenRule,objectRule,unknownKeyRule,arrayRule,minLengthRule,maxLengthRule,lengthRule,uniqueArrayRule,stringRule,emailRule,urlRule,matchesRule,withoutWhitespaceRule,patternRule,uploadableRule,wordsRule,minWordsRule,maxWordsRule,alphaRule,alphaNumericRule,isNumericRule,startsWithRule,endsWithRule,containsRule,notContainsRule,ipRule,ip4Rule,ip6Rule,isCreditCardRule,colorRule,hexColorRule,hslColorRule,rgbColorRule,rgbaColorRule,lightColorRule,darkColorRule,dateRule,maxDateRule,minDateRule,intRule,floatRule,booleanRule,scalarRule,uniqueRule,existsRule,enumRule,inRule,allowedValuesRule,notAllowedValuesRule,fileRule,imageRule,fileExtensionRule,fileTypeRule,minFileSizeRule,maxFileSizeRule,minWidthRule,maxWidthRule,minHeightRule,maxHeightRule,numberRule,minRule,maxRule,moduloRule,positiveRule}from'./rules.js';import {setKeyPath}from'./utils.js';/* eslint-disable @typescript-eslint/no-this-alias */
+// TODO: Allow developer to extend the validator with custom rules and custom validators
+class BaseValidator {
     rules = [];
     mutators = [];
     defaultValue;
+    description;
+    /**
+     * Add description to the validator
+     */
+    describe(description) {
+        this.description = description;
+        return this;
+    }
+    /**
+     * Value must be equal to the given value
+     */
+    equal(value, errorMessage) {
+        const rule = this.addRule(equalRule, errorMessage);
+        rule.context.options.value = value;
+        return this;
+    }
+    /**
+     * Add rule to the schema
+     */
     addRule(rule, errorMessage) {
         const newRule = {
             ...clone(rule),
@@ -19,6 +40,18 @@ import {trans}from'@mongez/localization';import {clone}from'@mongez/reinforcemen
         this.rules.push(newRule);
         return newRule;
     }
+    /**
+     * Define custom rule
+     */
+    refine(rule) {
+        this.addRule(rule);
+        return this;
+    }
+    /**
+     * Add mutator to the schema
+     *
+     * A mutator is a function that mutates the value of the field before validation
+     */
     addMutator(mutator, options = {}) {
         this.mutators.push({
             mutate: mutator,
@@ -29,39 +62,104 @@ import {trans}from'@mongez/localization';import {clone}from'@mongez/reinforcemen
         });
         return this;
     }
+    /**
+     * Set default value for the field
+     */
     default(value) {
         this.defaultValue = value;
         return this;
     }
+    /**
+     * Value must be present but not necessarily has a value
+     */
     present(errorMessage) {
         this.addRule(requiredRule, errorMessage);
         return this;
     }
+    /**
+     * This value must be present and has a value
+     */
     required(errorMessage) {
         this.addRule(requiredRule, errorMessage);
         return this;
     }
+    /**
+     * This value must be present if the given input is present
+     */
     requiredWith(input, errorMessage) {
         const rule = this.addRule(requiredWithRule, errorMessage);
-        rule.context.options.input = input;
+        rule.context.options.field = input;
         return this;
     }
+    /**
+     * Mark this field as required if the given input field is absent
+     */
     requiredIfAbsent(input, errorMessage) {
         const rule = this.addRule(requiredIfAbsentRule, errorMessage);
-        rule.context.options.input = input;
+        rule.context.options.field = input;
+        return this;
+    }
+    /**
+     * Value is required if all given input fields in same parent context are absent
+     */
+    requiredIfSiblingFieldAllAbsent(fields, errorMessage) {
+        const rule = this.addRule(requiredIfSiblingFieldAllAbsentRule, errorMessage);
+        rule.context.options.fields = fields;
         return this;
     }
+    /**
+     * @alias requiredIfAbsent
+     */
+    requiredIfMissing(input, errorMessage) {
+        return this.requiredIfAbsent(input, errorMessage);
+    }
+    /**
+     * Value is required if and only if the given input field is empty
+     */
     requiredIfEmpty(input, errorMessage) {
         const rule = this.addRule(requiredIfEmptyRule, errorMessage);
-        rule.context.options.input = input;
+        rule.context.options.field = input;
+        return this;
+    }
+    /**
+     * Value is required if and only if the given input field in same parent context is empty
+     */
+    requiredIfSiblingFieldEmpty(input, errorMessage) {
+        const rule = this.addRule(requiredIfSiblingFieldEmptyRule, errorMessage);
+        rule.context.options.field = input;
         return this;
     }
+    /**
+     * Value is required if and only if the given input field has the given value
+     */
     requiredIfField(input, value, errorMessage) {
         const rule = this.addRule(requiredIfFieldRule, errorMessage);
         rule.context.options.field = input;
         rule.context.options.value = value;
         return this;
     }
+    /**
+     * Value is required if and only if the given input field in same parent context has the given value
+     */
+    requiredIfSiblingField(input, value, errorMessage) {
+        const rule = this.addRule(requiredIfSiblingFieldRule, errorMessage);
+        rule.context.options.field = input;
+        rule.context.options.value = value;
+        return this;
+    }
+    /**
+     * Value is required unless the given input field in same parent context has the given value
+     */
+    requiredUnlessSiblingField(input, value, errorMessage) {
+        const rule = this.addRule(requiredUnlessSiblingFieldRule, errorMessage);
+        rule.context.options.field = input;
+        rule.context.options.value = value;
+        return this;
+    }
+    /**
+     * Mutate the data
+     * Please note this method should not be called directly, as it is used internally by the `validate` method
+     */
     async mutate(data, context) {
         let mutatedData = data;
         for (const mutator of this.mutators) {
@@ -70,6 +168,39 @@ import {trans}from'@mongez/localization';import {clone}from'@mongez/reinforcemen
         }
         return mutatedData;
     }
+    /**
+     * Value is forbidden to be present
+     */
+    forbidden(errorMessage) {
+        this.addRule(forbiddenRule, errorMessage);
+        return this;
+    }
+    /**
+     * Apply conditional validation rules based on another field value
+     *
+     * @example
+     * ```ts
+     * v.object({
+     *   status: v.when("type", {
+     *     is: {
+     *       post: v.string().required().in(["active", "inactive"]),
+     *       news: v.string().required().in(["published", "draft"]),
+     *     },
+     *     otherwise: v.forbidden(),
+     *   }),
+     * })
+     * ```
+     */
+    when(field, options) {
+        const rule = this.addRule(whenRule);
+        rule.context.options.field = field;
+        rule.context.options.is = options.is;
+        rule.context.options.otherwise = options.otherwise;
+        return this;
+    }
+    /**
+     * Validate the data
+     */
     async validate(data, context) {
         const mutatedData = await this.mutate(data ?? this.defaultValue, context);
         const errors = [];
@@ -117,10 +248,16 @@ class ObjectValidator extends BaseValidator {
         this.schema = schema;
         this.addRule(objectRule, errorMessage);
     }
+    /**
+     * Strip unknown keys from the data
+     *
+     * @mutate
+     */
     stripUnknown() {
+        const validator = this;
         this.addMutator(stripUnknownMutator, {
             get allowedKeys() {
-                return this.allowedKeys;
+                return validator.allowedKeys;
             },
         });
         return this;
@@ -139,15 +276,28 @@ class ObjectValidator extends BaseValidator {
         this.addMutator(objectTrimMutator, { recursive });
         return this;
     }
+    /**
+     * Whether to allow unknown properties
+     *
+     * @default false
+     */
     allowUnknown(allow = true) {
         this.shouldAllowUnknown = allow;
         return this;
     }
+    /**
+     * Mutate the data
+     *
+     * Please note this method should not be called directly, as it is used internally by the `validate` method
+     */
     mutate(data, context) {
         if (!isPlainObject(data))
             return data;
         return super.mutate({ ...data }, context);
     }
+    /**
+     * Validate the data
+     */
     async validate(data, context) {
         context.schema = this.schema;
         const mutatedData = await this.mutate(data, context);
@@ -186,29 +336,33 @@ class ObjectValidator extends BaseValidator {
         };
     }
 }
-class ArrayValidator extends AnyValidator {
+class ArrayValidator extends BaseValidator {
     validator;
     constructor(validator, errorMessage) {
         super();
         this.validator = validator;
         this.addRule(arrayRule, errorMessage);
     }
-    // Start of mutators
-    //   Mutators methods should start with `m` prefix
     /**
      * Reverse array order
+     *
+     * @mutate
      */
     flip() {
         return this.addMutator(flipArrayMutator);
     }
     /**
      * Reverse array order
+     *
+     * @mutate
      */
     reverse() {
         return this.addMutator(flipArrayMutator);
     }
     /**
      * Make it has only unique values
+     *
+     * @mutate
      */
     onlyUnique() {
         return this.addMutator(uniqueArrayMutator);
@@ -217,6 +371,8 @@ class ArrayValidator extends AnyValidator {
      * Sort array
      *
      * If key is passed, it will sort by the key value
+     *
+     * @mutate
      * @supports dot notation
      */
     sort(direction = "asc", key) {
@@ -225,16 +381,25 @@ class ArrayValidator extends AnyValidator {
     }
     // End of mutators
     //   Start of rules
+    /**
+     * Array length must be greater than the given length
+     */
     minLength(length, errorMessage) {
         const rule = this.addRule(minLengthRule, errorMessage);
         rule.context.options.minLength = length;
         return this;
     }
+    /**
+     * Array length must be less than the given length
+     */
     maxLength(length, errorMessage) {
         const rule = this.addRule(maxLengthRule, errorMessage);
         rule.context.options.maxLength = length;
         return this;
     }
+    /**
+     * Array length must be of the given length
+     */
     length(length, errorMessage) {
         const rule = this.addRule(lengthRule, errorMessage);
         rule.context.options.length = length;
@@ -247,13 +412,21 @@ class ArrayValidator extends AnyValidator {
         this.addRule(uniqueArrayRule);
         return this;
     }
+    /**
+     * Mutate the data
+     *
+     * Please note this method should not be called directly, as it is used internally by the `validate` method
+     */
     mutate(data, context) {
         if (!Array.isArray(data))
             return data;
         return super.mutate([...data], context);
     }
+    /**
+     * Validate array
+     */
     async validate(data, context) {
-        const mutatedData = await this.mutate(data, context);
+        const mutatedData = (await this.mutate(data, context)) || [];
         const result = await super.validate(data, context);
         if (result.isValid === false)
             return result;
@@ -289,83 +462,326 @@ class StringValidator extends BaseValidator {
         this.addRule(stringRule, errorMessage);
         this.addMutator(stringMutator);
     }
+    /**
+     * Convert string to lowercase
+     *
+     * @mutate
+     */
     lowercase() {
         this.addMutator(lowercaseMutator);
         return this;
     }
+    /**
+     * Convert string to uppercase
+     *
+     * @mutate
+     */
     uppercase() {
         this.addMutator(uppercaseMutator);
         return this;
     }
+    /**
+     * Capitalize the first letter of the string
+     *
+     * @mutate
+     */
+    capitalize() {
+        this.addMutator(capitalizeMutator);
+        return this;
+    }
+    /**
+     * Value must be a valid email
+     */
     email(errorMessage) {
         this.addRule(emailRule, errorMessage);
         return this;
     }
+    /**
+     * Value must be a valid URL
+     */
     url(errorMessage) {
         this.addRule(urlRule, errorMessage);
         return this;
     }
+    /**
+     * Value must match the value of the given field
+     */
     matches(field, errorMessage) {
         const rule = this.addRule(matchesRule, errorMessage);
         rule.context.options.field = field;
         return this;
     }
+    /**
+     * Value can not have whitespace
+     */
+    withoutWhitespace(errorMessage) {
+        this.addRule(withoutWhitespaceRule, errorMessage);
+        return this;
+    }
+    /**
+     * Value must match the given pattern
+     */
     pattern(pattern, errorMessage) {
         const rule = this.addRule(patternRule, errorMessage);
         rule.context.options.pattern = pattern;
         return this;
     }
+    /**
+     * Validate the current string as an uploadable hash id
+     */
+    uploadable(errorMessage) {
+        this.addRule(uploadableRule, errorMessage);
+        return this;
+    }
+    /**
+     * Value must be exactly the given number of words
+     */
+    words(words, errorMessage) {
+        const rule = this.addRule(wordsRule, errorMessage);
+        rule.context.options.words = words;
+        return this;
+    }
+    /**
+     * Value must be at least the given number of words
+     */
+    minWords(words, errorMessage) {
+        const rule = this.addRule(minWordsRule, errorMessage);
+        rule.context.options.minWords = words;
+        return this;
+    }
+    /**
+     * Value must be at most the given number of words
+     */
+    maxWords(words, errorMessage) {
+        const rule = this.addRule(maxWordsRule, errorMessage);
+        rule.context.options.maxWords = words;
+        return this;
+    }
+    /**
+     * Value length must be greater than the given length
+     */
     minLength(length, errorMessage) {
         const rule = this.addRule(minLengthRule, errorMessage);
         rule.context.options.minLength = length;
         return this;
     }
+    /**
+     * @alias minLength
+     */
+    min(min, errorMessage) {
+        return this.minLength(min, errorMessage);
+    }
+    /**
+     * Value length must be less than the given length
+     */
     maxLength(length, errorMessage) {
         const rule = this.addRule(maxLengthRule, errorMessage);
         rule.context.options.maxLength = length;
         return this;
     }
+    /**
+     * @alias maxLength
+     */
+    max(max, errorMessage) {
+        return this.maxLength(max, errorMessage);
+    }
+    /**
+     * Value must be of the given length
+     */
     length(length, errorMessage) {
         const rule = this.addRule(lengthRule, errorMessage);
         rule.context.options.length = length;
         return this;
     }
-    enum(values, errorMessage) {
-        const rule = this.addRule(enumRule, errorMessage);
-        rule.context.options.values = values;
+    /**
+     * Allow only alphabetic characters
+     */
+    alpha(errorMessage) {
+        this.addRule(alphaRule, errorMessage);
         return this;
     }
-    in(values, errorMessage) {
-        return this.enum(values, errorMessage);
+    /**
+     * Allow only alphanumeric characters
+     */
+    alphanumeric(errorMessage) {
+        this.addRule(alphaNumericRule, errorMessage);
+        return this;
     }
-    equal(value, errorMessage) {
-        const rule = this.addRule(equalRule, errorMessage);
+    /**
+     * Allow only numeric characters
+     */
+    numeric(errorMessage) {
+        this.addRule(isNumericRule, errorMessage);
+        return this;
+    }
+    /**
+     * Value must starts with the given string
+     */
+    startsWith(value, errorMessage) {
+        const rule = this.addRule(startsWithRule, errorMessage);
         rule.context.options.value = value;
         return this;
     }
-    unique(model, { errorMessage, ...options } = {}) {
-        const rule = this.addRule(uniqueRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
+    /**
+     * Value must ends with the given string
+     */
+    endsWith(value, errorMessage) {
+        const rule = this.addRule(endsWithRule, errorMessage);
+        rule.context.options.value = value;
         return this;
     }
-    exists(model, { errorMessage, ...options } = {}) {
-        const rule = this.addRule(existsRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
+    /**
+     * Value must contain the given string
+     */
+    contains(value, errorMessage) {
+        const rule = this.addRule(containsRule, errorMessage);
+        rule.context.options.value = value;
+        return this;
+    }
+    /**
+     * Value must not contain the given string
+     */
+    notContains(value, errorMessage) {
+        const rule = this.addRule(notContainsRule, errorMessage);
+        rule.context.options.value = value;
+        return this;
+    }
+    /**
+     * Value must be a valid IP address
+     */
+    ip(errorMessage) {
+        this.addRule(ipRule, errorMessage);
+        return this;
+    }
+    /**
+     * Value must be a valid IPv4 address
+     */
+    ip4(errorMessage) {
+        this.addRule(ip4Rule, errorMessage);
+        return this;
+    }
+    /**
+     * Value must be a valid IPv6 address
+     */
+    ip6(errorMessage) {
+        this.addRule(ip6Rule, errorMessage);
+        return this;
+    }
+    /**
+     * Check if the string matches a credit card number
+     */
+    creditCard(errorMessage) {
+        this.addRule(isCreditCardRule, errorMessage);
+        return this;
+    }
+    /**
+     * Determine if the value is a valid color
+     * This validation rule will check for hex, rgb, rgba, hsl colors
+     */
+    color(errorMessage) {
+        this.addRule(colorRule, errorMessage);
+        return this;
+    }
+    /**
+     * Determine if the value is a valid hex color
+     */
+    hexColor(errorMessage) {
+        this.addRule(hexColorRule, errorMessage);
+        return this;
+    }
+    /**
+     * Determine if the value is a valid HSL color
+     */
+    hslColor(errorMessage) {
+        this.addRule(hslColorRule, errorMessage);
+        return this;
+    }
+    /**
+     * Determine if the value is a valid RGB color
+     */
+    rgbColor(errorMessage) {
+        this.addRule(rgbColorRule, errorMessage);
+        return this;
+    }
+    /**
+     * Determine if the value is a valid RGBA color
+     */
+    rgbaColor(errorMessage) {
+        this.addRule(rgbaColorRule, errorMessage);
+        return this;
+    }
+    /**
+     * Determine if the value is a valid light color
+     */
+    lightColor(errorMessage) {
+        this.addRule(lightColorRule, errorMessage);
         return this;
     }
+    /**
+     * Determine if the value is a valid dark color
+     */
+    darkColor(errorMessage) {
+        this.addRule(darkColorRule, errorMessage);
+        return this;
+    }
+    /**
+     * Value must be one of the given values
+     */
+    enum = ScalarValidator.prototype.enum;
+    /**
+     * Value must be one of the given values
+     */
+    in = ScalarValidator.prototype.in;
+    /**
+     * @alias in
+     */
+    oneOf = ScalarValidator.prototype.in;
+    /**
+     * Value must be unique
+     */
+    unique = ScalarValidator.prototype.unique;
+    /**
+     * Value must exist
+     */
+    exists = ScalarValidator.prototype.exists;
+    /**
+     * Add rule to check if the value is one of the allowed values
+     */
+    allowsOnly = ScalarValidator.prototype.allowsOnly;
+    /**
+     * Add rule to forbid the value from being one of the given values
+     */
+    forbids = ScalarValidator.prototype.forbids;
+    /**
+     * @alias forbids
+     */
+    notIn = ScalarValidator.prototype.forbids;
 }
 class DateValidator extends BaseValidator {
-    constructor(errorMessage) {
+    constructor(format, errorMessage) {
         super();
-        this.addRule(dateRule, errorMessage);
+        const rule = this.addRule(dateRule, errorMessage);
+        if (format) {
+            rule.context.options.format = format;
+        }
         this.addMutator(dateMutator);
     }
+    /**
+     * Date must be before the given date
+     */
+    before(date, errorMessage) {
+        const rule = this.addRule(maxDateRule, errorMessage);
+        rule.context.options.maxDate = date;
+        return this;
+    }
+    /**
+     * Date must be after the given date
+     */
+    after(date, errorMessage) {
+        const rule = this.addRule(minDateRule, errorMessage);
+        rule.context.options.minDate = date;
+        return this;
+    }
 }
 class NumberValidator extends BaseValidator {
     constructor(errorMessage) {
@@ -373,41 +789,69 @@ class NumberValidator extends BaseValidator {
         this.addRule(numberRule, errorMessage);
         this.addMutator(numberMutator);
     }
+    /**
+     * Value must be equal or higher than the given number
+     */
     min(min, errorMessage) {
         const rule = this.addRule(minRule, errorMessage);
         rule.context.options.min = min;
         return this;
     }
+    /**
+     * Value must be equal or less than the given number
+     */
     max(max, errorMessage) {
         const rule = this.addRule(maxRule, errorMessage);
         rule.context.options.max = max;
         return this;
     }
-    equal(value, errorMessage) {
-        const rule = this.addRule(equalRule, errorMessage);
+    /**
+     * Value must be a modulo of the given number
+     */
+    modulo(value, errorMessage) {
+        const rule = this.addRule(moduloRule, errorMessage);
         rule.context.options.value = value;
         return this;
     }
+    /**
+     * Accept only numbers higher than 0
+     */
     positive(errorMessage) {
         this.addRule(positiveRule, errorMessage);
         return this;
     }
-    unique(model, { errorMessage, ...options } = {}) {
-        const rule = this.addRule(uniqueRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return this;
-    }
-    exists(model, { errorMessage, ...options } = {}) {
-        const rule = this.addRule(existsRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return;
-    }
+    /**
+     * Value must be unique and not exist in database
+     */
+    unique = ScalarValidator.prototype.unique;
+    /**
+     * Value must exist in database
+     */
+    exists = ScalarValidator.prototype.exists;
+    /**
+     * Value must be one of the given values
+     */
+    enum = ScalarValidator.prototype.enum;
+    /**
+     * Value must be one of the given values
+     */
+    in = ScalarValidator.prototype.in;
+    /**
+     * @alias in
+     */
+    oneOf = ScalarValidator.prototype.in;
+    /**
+     * Add rule to check if the value is one of the allowed values
+     */
+    allowsOnly = ScalarValidator.prototype.allowsOnly;
+    /**
+     * Add rule to forbid the value from being one of the given values
+     */
+    forbids = ScalarValidator.prototype.forbids;
+    /**
+     * @alias forbids
+     */
+    notIn = ScalarValidator.prototype.forbids;
 }
 class IntValidator extends NumberValidator {
     constructor(errorMessage) {
@@ -432,6 +876,9 @@ class ScalarValidator extends BaseValidator {
         super();
         this.addRule(scalarRule, errorMessage);
     }
+    /**
+     * Value must be unique
+     */
     unique(model, { errorMessage, ...options } = {}) {
         const rule = this.addRule(uniqueRule, errorMessage);
         rule.context.options = {
@@ -440,34 +887,113 @@ class ScalarValidator extends BaseValidator {
         };
         return this;
     }
+    /**
+     * Value must exist in database
+     */
     exists(model, { errorMessage, ...options } = {}) {
         const rule = this.addRule(existsRule, errorMessage);
         rule.context.options = {
             ...options,
             Model: model,
         };
-        return;
+        return this;
+    }
+    /**
+     * Value must be one of the given values
+     */
+    enum(values, errorMessage) {
+        const rule = this.addRule(enumRule, errorMessage);
+        rule.context.options.enum = values;
+        return this;
+    }
+    /**
+     * Value must be one of the given values
+     */
+    in(values, errorMessage) {
+        const rule = this.addRule(inRule, errorMessage);
+        rule.context.options.values = values;
+        return this;
+    }
+    /**
+     * @alias in
+     */
+    oneOf = ScalarValidator.prototype.in;
+    /**
+     * Add rule to check if the value is one of the allowed values
+     */
+    allowsOnly(values, errorMessage) {
+        const rule = this.addRule(allowedValuesRule, errorMessage);
+        rule.context.options.allowedValues = values;
+        return this;
+    }
+    /**
+     * Forbid the value from being one of the given values
+     */
+    forbids(values, errorMessage) {
+        const rule = this.addRule(notAllowedValuesRule, errorMessage);
+        rule.context.options.notAllowedValues = values;
+        return this;
     }
 }
 class FileValidator extends BaseValidator {
     constructor(errorMessage) {
         super();
-        this.addRule(fileRile, errorMessage);
+        this.addRule(fileRule, errorMessage);
     }
     image(errorMessage) {
         this.addRule(imageRule, errorMessage);
         return this;
     }
-    minFileSize(size, errorMessage) {
+    accept(extensions, errorMessage) {
+        const rule = this.addRule(fileExtensionRule, errorMessage);
+        rule.context.options.extensions = extensions;
+        return this;
+    }
+    mimeType(mimeTypes, errorMessage) {
+        const rule = this.addRule(fileTypeRule, errorMessage);
+        rule.context.options.mimeTypes = mimeTypes;
+        return this;
+    }
+    /**
+     * Allow only pdf files
+     */
+    pdf(errorMessage) {
+        return this.mimeType("application/pdf", errorMessage);
+    }
+    /**
+     * Allow only excel files
+     */
+    excel(errorMessage) {
+        return this.mimeType([
+            "application/vnd.ms-excel",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ], errorMessage);
+    }
+    /**
+     * Allow only word files
+     */
+    word(errorMessage) {
+        return this.mimeType([
+            "application/msword",
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ], errorMessage);
+    }
+    minSize(size, errorMessage) {
         const rule = this.addRule(minFileSizeRule, errorMessage);
         rule.context.options.minFileSize = size;
         return this;
     }
-    maxFileSize(size, errorMessage) {
+    min(size, errorMessage) {
+        return this.minSize(size, errorMessage);
+    }
+    maxSize(size, errorMessage) {
         const rule = this.addRule(maxFileSizeRule, errorMessage);
         rule.context.options.maxFileSize = size;
         return this;
     }
+    max(size, errorMessage) {
+        return this.maxSize(size, errorMessage);
+    }
     minWidth(width, errorMessage) {
         const rule = this.addRule(minWidthRule, errorMessage);
         rule.context.options.minWidth = width;
@@ -484,7 +1010,7 @@ class FileValidator extends BaseValidator {
         return this;
     }
     maxHeight(height, errorMessage) {
-        const rule = this.addRule(minHeightRule, errorMessage);
+        const rule = this.addRule(maxHeightRule, errorMessage);
         rule.context.options.maxHeight = height;
         return this;
     }
@@ -504,7 +1030,10 @@ const validate = async (schema, data) => {
 };
 const v = {
     object: (schema, errorMessage) => new ObjectValidator(schema, errorMessage),
+    any: () => new AnyValidator(),
+    forbidden: () => v.any().forbidden(),
     array: (validator, errorMessage) => new ArrayValidator(validator, errorMessage),
+    date: (format, errorMessage) => new DateValidator(format, errorMessage),
     string: (errorMessage) => new StringValidator(errorMessage),
     number: (errorMessage) => new NumberValidator(errorMessage),
     int: (errorMessage) => new IntValidator(errorMessage),
@@ -512,5 +1041,9 @@ const v = {
     boolean: (errorMessage) => new BooleanValidator(errorMessage),
     scalar: (errorMessage) => new ScalarValidator(errorMessage),
     file: (errorMessage) => new FileValidator(errorMessage),
+    localized: (valueValidator, errorMessage) => v.array(v.object({
+        localeCode: v.string().required(),
+        value: (valueValidator || v.string()).required(),
+    }), errorMessage),
     validate,
 };export{AnyValidator,ArrayValidator,BaseValidator,BooleanValidator,DateValidator,FileValidator,FloatValidator,IntValidator,ObjectValidator,ScalarValidator,StringValidator,v,validate};//# sourceMappingURL=schema.js.map