'use strict';

var dateFns = require('date-fns');

const DEFAULT_OPTIONS = {
    stopOnFail: false,
    language: "en",
    dateFormat: "yyyy-MM-dd",
};
let OPTIONS = {
    ...DEFAULT_OPTIONS,
};
const getOptions = () => {
    return OPTIONS;
};
const setOptions = async (value) => {
    OPTIONS = {
        ...OPTIONS,
        ...value,
    };
};

var isAccepted = (value) => {
    const acceptedValues = ["yes", "on", 1, "1", true];
    return acceptedValues.includes(value);
};

var isAfter = (value, date, extra) => {
    const inputValue = new Date(value);
    const comparisonDate = extra?.data[date]
        ? new Date(extra?.data[date])
        : new Date(date);
    if (isNaN(inputValue.getTime()) || isNaN(comparisonDate.getTime())) {
        return false;
    }
    return inputValue > comparisonDate;
};

var isAfterOrEqual = (value, date, extra) => {
    const inputValue = new Date(value);
    const comparisonDate = extra?.data[date]
        ? new Date(extra?.data[date])
        : new Date(date);
    if (isNaN(inputValue.getTime()) || isNaN(comparisonDate.getTime())) {
        return false;
    }
    return inputValue >= comparisonDate;
};

var isAlpha = (value) => {
    return /^[a-zA-Z]+$/.test(value);
};

var isAlphaDash = (value) => {
    // Check if the value contains only alphanumeric characters, dashes, and underscores
    const regex = /^[a-zA-Z0-9-_]+$/;
    return regex.test(value);
};

var isAlphaNum = (value) => {
    if (typeof value === "boolean") {
        return false;
    }
    // Check if the value consists entirely of alpha-numeric characters
    return /^[a-zA-Z0-9]+$/.test(value);
};

var isArray = (value) => {
    return Array.isArray(value);
};

var isBefore = (value, date, extra) => {
    // Parse the date strings or use Date objects based on your needs
    const inputValue = new Date(value);
    const comparisonDate = extra?.data[date]
        ? new Date(extra?.data[date])
        : new Date(date);
    if (isNaN(inputValue.getTime()) || isNaN(comparisonDate.getTime())) {
        return false;
    }
    // Compare the dates
    return inputValue < comparisonDate;
};

var isBeforeOrEqual = (value, date, extra) => {
    // Parse the date strings or use Date objects based on your needs
    const inputValue = new Date(value);
    const comparisonDate = extra?.data[date]
        ? new Date(extra?.data[date])
        : new Date(date);
    if (isNaN(inputValue.getTime()) || isNaN(comparisonDate.getTime())) {
        return false;
    }
    // Compare the dates
    return inputValue <= comparisonDate;
};

var isBetween = (value, min, max, extra) => {
    // Convert min and max to numbers if they are not already
    const minValue = typeof min === "number" ? min : parseFloat(min);
    const maxValue = typeof max === "number" ? max : parseFloat(max);
    // If there is a numeric definition on the field, we should test the numeric
    // values of the data.
    const shouldBeNumeric = extra?.definition.split("|").includes("numeric") || false;
    if (shouldBeNumeric) {
        value = parseFloat(value);
    }
    // Check the size based on the type of value
    if (Array.isArray(value)) {
        return value.length >= minValue && value.length <= maxValue;
    }
    else if (typeof value === "string" && shouldBeNumeric === false) {
        return value.length >= minValue && value.length <= maxValue;
    }
    else if (typeof value === "number") {
        return value >= minValue && value <= maxValue;
    }
    // For other types, return false
    return false;
};

var isBoolean = (value) => {
    // Check if the value is a boolean or a valid string representation of boolean
    if (typeof value === "boolean") {
        return true;
    }
    const lowerCaseValue = String(value).toLowerCase();
    // Check for valid boolean string representations
    return ["true", "false", "0", "1"].includes(lowerCaseValue);
};

const getValueViaPath = (data, path) => {
    const keys = path.split(".");
    let value = keys.reduce((acc, key) => {
        if (acc && typeof acc === "object" && key in acc) {
            return acc[key];
        }
        return undefined;
    }, data);
    if (typeof value === "string") {
        value = value.trim();
    }
    if (value === "") {
        return null;
    }
    return value;
};

var isConfirmed = (value, context) => {
    const confirmedKey = `${context.field}_confirmed`;
    const confirmedValue = getValueViaPath(context.data, confirmedKey);
    return value === confirmedValue;
};

var isDate = (value, dateFormat) => {
    const options = getOptions();
    const format = dateFormat ?? options.dateFormat;
    const date = dateFns.parse(value, format, new Date());
    return !isNaN(date);
};

var isDigits = (value, length) => {
    if (typeof value === "boolean") {
        return false;
    }
    // Check if the value is numeric
    if (typeof value !== "number" && isNaN(Number(value))) {
        return false;
    }
    // Check if the length is numeric
    if (typeof length !== "number" && isNaN(Number(length))) {
        throw new Error(`Incorrect validation rule: digits:number`);
    }
    // Shouldn't be a float value
    if (Number(value) % 1 !== 0) {
        return false;
    }
    // Check if the length is exact
    return String(value).trim().length === Number(length);
};

var isDigitsBetween = (value, min, max) => {
    if (value === null || value === undefined || typeof value === "boolean") {
        return false;
    }
    // Check if the value is numeric
    if (typeof value !== "number" && isNaN(Number(value))) {
        return false;
    }
    if (min === null || min === undefined || max === null || max === undefined) {
        throw new Error(`Incorrect validation rule: digits:min,max`);
    }
    if (typeof min !== "number" && isNaN(Number(min))) {
        // Check if the min is numeric
        throw new Error(`Incorrect validation rule: digits:min,max`);
    }
    // Check if the max is numeric
    if (typeof max !== "number" && isNaN(Number(max))) {
        throw new Error(`Incorrect validation rule: digits:min,max`);
    }
    // Shouldn't be a float value
    if (Number(value) % 1 !== 0) {
        return false;
    }
    // Check if the length is exact
    const length = String(value).trim().length;
    return length >= Number(min) && length <= Number(max);
};

var isEmail = (value) => {
    return !!String(value)
        .toLowerCase()
        .match(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|.(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/);
};

var isHex = (value) => {
    return /^[0-9a-f]+$/i.test(String(value).trim());
};

var isIn = (value, options) => {
    const list = Array.isArray(options) ? options : options.split(",");
    const listAsString = list.map((item) => String(item).trim());
    if (Array.isArray(value)) {
        // Check if all elements in the array are in the list
        return value.every((item) => listAsString.includes(String(item).trim()));
    }
    // Check if the string value is in the list
    return listAsString.includes(String(value).trim());
};

var isInteger = (value) => {
    if (isNaN(value)) {
        return false;
    }
    return String(parseInt(value, 10)) === String(value);
};

var isMax = (value, size) => {
    if (value === null || value === undefined || typeof value === "boolean") {
        return false;
    }
    const check = Number(size);
    if (size === null || size === undefined || isNaN(check)) {
        throw new Error(`Incorrect validation rule: max:number`);
    }
    if (typeof value === "string") {
        return value.trim().length <= check;
    }
    const input = Number(value);
    if (isNaN(input)) {
        return false;
    }
    return input <= check;
};

var isMin = (value, size) => {
    if (value === null || value === undefined || typeof value === "boolean") {
        return false;
    }
    const check = Number(size);
    if (size === null || size === undefined || isNaN(check)) {
        throw new Error(`Incorrect validation rule: max:number`);
    }
    if (typeof value === "string") {
        return value.trim().length >= check;
    }
    const input = Number(value);
    if (isNaN(input)) {
        return false;
    }
    return input >= size;
};

var isNotIn = (value, options) => {
    if (value === null || value === undefined) {
        return false;
    }
    const list = Array.isArray(options) ? options : options.split(",");
    const listAsString = list.map((item) => String(item).trim());
    if (Array.isArray(value)) {
        // Check if all elements in the array are in the list
        return value.every((item) => !listAsString.includes(String(item).trim()));
    }
    // Check if the string value is in the list
    return !listAsString.includes(String(value).trim());
};

var isNumeric = (value) => {
    if (typeof value === "object") {
        return false;
    }
    if (String(value).trim().length === 0) {
        return true;
    }
    // Check if the string representation is numeric
    const stringValue = String(value).trim();
    return stringValue !== "" && !isNaN(Number(stringValue));
};

var isRequired = (value) => {
    if (value === null || value === undefined) {
        return false;
    }
    if (Array.isArray(value)) {
        return true;
    }
    const content = String(value).trim();
    return content.length > 0;
};

var isSize = (value, size) => {
    if (value === null || value === undefined) {
        return false;
    }
    if (isNaN(Number(size))) {
        throw new Error(`Invalid validation rule: size:${size} (size:number)`);
    }
    if (typeof value === "string") {
        return String(value).trim().length === Number(size);
    }
    return value === Number(size);
};

var isString = (value) => {
    return typeof value === "string";
};

var isUrl = (value) => {
    const urlRegex = /^(ftp|http|https):\/\/[^ "]+$/;
    return urlRegex.test(value);
};

const RULE_FUNCTION_MAPS = {
    string: isString,
    boolean: isBoolean,
    accepted: isAccepted,
    after: isAfter,
    after_or_equal: isAfterOrEqual,
    alpha: isAlpha,
    alpha_dash: isAlphaDash,
    alpha_num: isAlphaNum,
    array: isArray,
    before: isBefore,
    before_or_equal: isBeforeOrEqual,
    between: isBetween,
    confirmed: isConfirmed,
    date: isDate,
    digits: isDigits,
    digits_between: isDigitsBetween,
    email: isEmail,
    hex: isHex,
    in: isIn,
    integer: isInteger,
    max: isMax,
    min: isMin,
    not_in: isNotIn,
    numeric: isNumeric,
    required: isRequired,
    size: isSize,
    url: isUrl,
};

const TRANSLATIONS = {};
const setLocales = (values) => {
    if (Array.isArray(values)) {
        const locales = values;
        for (const item of locales) {
            mergeTranslations(item);
        }
    }
    else {
        const locale = values;
        mergeTranslations(locale);
    }
};
const mergeTranslations = (locale) => {
    if (TRANSLATIONS[locale.key]) {
        TRANSLATIONS[locale.key] = {
            ...TRANSLATIONS[locale.key],
            ...locale.values,
        };
    }
    else {
        TRANSLATIONS[locale.key] = locale.values;
    }
};
const getLoadedLocales = () => {
    return Object.keys(TRANSLATIONS);
};
const addCustomLocale = (locale, ruleName, translation) => {
    if (!TRANSLATIONS[locale]) {
        TRANSLATIONS[locale] = {};
    }
    const root = TRANSLATIONS[locale];
    if (root) {
        root[ruleName] = translation;
    }
    else {
        throw new Error(`The translation path couldn't find: ${locale}`);
    }
};
const getMessage = (rule, params, language, customTranslations = {}) => {
    const defaultTranslations = TRANSLATIONS[language];
    if (defaultTranslations === undefined) {
        throw new Error(`You should set locale: setLocales(["${language}"])`);
    }
    const translations = { ...defaultTranslations, ...customTranslations };
    let message = translations[rule];
    if (message === undefined) {
        throw new Error(`Undefined error message: ${rule} (${language})`);
    }
    for (const index in params) {
        message = message.replace(`{${index}}`, params[index]);
    }
    return message;
};

const DEFINED_RULES = {
    ...RULE_FUNCTION_MAPS,
};
const isRegistered = (name) => {
    return DEFINED_RULES.includes(name);
};
const register = (name, ruleFunction, translations) => {
    if (DEFINED_RULES[name]) {
        throw new Error(`The rule name is already defined: ${name}`);
    }
    for (const locale of Object.keys(translations)) {
        const message = translations[locale];
        if (message === undefined) {
            throw new Error(`The custom rule translation should be provided: ${locale}`);
        }
        addCustomLocale(locale, name, message);
    }
    DEFINED_RULES[name] = ruleFunction;
};

const toRuleDefinition = (rule) => {
    const [name, paramsAsString] = rule.split(":");
    const ruleType = toRuleType(name);
    const params = paramsAsString ? paramsAsString.split(",") : [];
    const callback = DEFINED_RULES[ruleType];
    if (callback === undefined) {
        throw new Error(`Undefined validation rule: ${ruleType}`);
    }
    return {
        name: ruleType,
        callback,
        params,
    };
};
const toRuleType = (name) => {
    try {
        return name;
    }
    catch (error) {
        throw new Error(`Undefined rule: ${name}`);
    }
};

const validate = async (data, definition, options) => {
    const currentOptions = {
        ...getOptions(),
        ...options,
    };
    const { isValid, fields, results } = await getResults(data, definition, currentOptions);
    return {
        isValid,
        isInvalid: !isValid,
        fields,
        errors: results,
    };
};
const getResults = async (data, definition, options) => {
    let isValid = true;
    const fields = {};
    const results = {};
    // Checking all validations
    for (const field in definition) {
        fields[field] = true;
        // Parsing the rules
        const params = definition[field];
        let ruleGroup = "";
        if (Array.isArray(params)) {
            ruleGroup = params.join("|");
        }
        else {
            ruleGroup = params;
        }
        const rules = toRuleNameArray(ruleGroup).map(toRuleDefinition);
        // Getting the value by the path
        const value = getValueViaPath(data, field);
        const context = {
            data,
            field,
            definition: ruleGroup,
        };
        // Checking all rules one by one
        for (const rule of rules) {
            // If the value is empty but the rule is not required, we don't execute
            // the rules
            if (rule.name !== "required" && (value === null || value === undefined)) {
                continue;
            }
            // Calling the rule function with the validation parameters
            const isRuleValid = await rule.callback(value, ...[...rule.params, context]);
            // Is the value valid?
            if (isRuleValid === false) {
                if (!results[field]) {
                    results[field] = [];
                }
                isValid = false;
                fields[field] = false;
                // Setting the rule and the error message
                results[field].push({
                    rule: rule.name,
                    message: getMessage(rule.name, rule.params, options.language, options.translations || {}),
                });
                if (options.stopOnFail) {
                    return {
                        isValid: false,
                        fields,
                        results,
                    };
                }
            }
        }
    }
    return {
        isValid,
        fields,
        results,
    };
};
const toRuleNameArray = (rules) => {
    return rules.split("|");
};

/**
 * The field under validation must be yes, on, 1 or true. This is useful for
 * validating "Terms of Service" acceptance.
 *
 * @example
 *  import { accepted } from "robust-validator"
 *
 *  const definition = {
 *    value: [accepted()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#accepted
 */
var accepted = () => {
    return "accepted";
};

/**
 * The field under validation must be after the given date.
 *
 * @example
 *  import { after } from "robust-validator"
 *
 *  const definition = {
 *    value: [after("2023-01-01")]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#after-date
 */
var after = (date) => {
    return `after:${date}`;
};

/**
 * The field unter validation must be after or equal to the given field
 *
 * @example
 *  import { afterOrEqual } from "robust-validator"
 *
 *  const definition = {
 *    value: [afterOrEqual("2023-01-01")]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#after-or-equal-date
 */
var afterOrEqual = (date) => {
    return `after_or_equal:${date}`;
};

/**
 * The field under validation must be entirely alphabetic characters.
 *
 * @example
 *  import { alpha } from "robust-validator"
 *
 *  const definition = {
 *    value: [alpha()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#alpha
 */
var alpha = () => {
    return "alpha";
};

/**
 * The field under validation may have alpha-numeric characters, as well as
 * dashes and underscores.
 *
 * @example
 *  import { alphaDash } from "robust-validator"
 *
 *  const definition = {
 *    value: [alphaDash()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#alpha-dash
 */
var alphaDash = () => {
    return "alpha_dash";
};

/**
 * The field under validation must be entirely alpha-numeric characters.
 *
 * @example
 *  import { alphaNum } from "robust-validator"
 *
 *  const definition = {
 *    value: [alphaNum()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#alpha-num
 */
var alphaNum = () => {
    return "alpha_num";
};

/**
 * The field under validation must be an array.
 *
 * @example
 *  import { array } from "robust-validator"
 *
 *  const definition = {
 *    value: [array()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#array
 */
var array = () => {
    return "array";
};

/**
 * The field under validation must be before the given date.
 *
 * @example
 *  import { before } from "robust-validator"
 *
 *  const definition = {
 *    value: [before("2023-01-01")]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#before-date
 */
var before = (date) => {
    return `before:${date}`;
};

/**
 * The field under validation must be before or equal to the given date.
 *
 * @example
 *  import { beforeOrEqual } from "robust-validator"
 *
 *  const definition = {
 *    value: [beforeOrEqual("2023-01-01")]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#before-or-equal-date
 */
var beforeOrEqual = (date) => {
    return `before_or_equal:${date}`;
};

/**
 * The field under validation must have a size between the given min and max.
 * Strings, and numerics are evaluated in the same fashion as the size rule.
 *
 * @example
 *  import { between } from "robust-validator"
 *
 *  const definition = {
 *    value: [between(5, 10)]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#between-min-max
 */
var between = (min, max) => {
    return `between:${min},${max}`;
};

/**
 * The field under validation must be a boolean value of the form true, false,
 * 0, 1, 'true', 'false', '0', '1',
 *
 * @example
 *  import { boolean } from "robust-validator"
 *
 *  const definition = {
 *    value: [boolean()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#boolean
 */
var boolean = () => {
    return "boolean";
};

/**
 * The field under validation must have a matching field of foo_confirmed.
 * For example, if the field under validation is password, a matching
 * password_confirmed field must be present in the input.
 *
 * @example
 *  import { confirmed } from "robust-validator"
 *
 *  const definition = {
 *    value: [confirmed()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#confirmed
 */
var confirmed = () => {
    return "confirmed";
};

/**
 * The field under validation must be a valid date format.
 *
 * @example
 *  import { date } from "robust-validator"
 *
 *  const definition = {
 *    value: [date("yyyy-MM-dd")]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#date-format
 */
var date = (dateFormat) => {
    if (dateFormat) {
        return `date|${dateFormat}`;
    }
    return "date";
};

/**
 * The field under validation must be numeric and must have an exact length of
 * value.
 *
 * @example
 *  import { digits } from "robust-validator"
 *
 *  const definition = {
 *    value: [digits(4)]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#digits-value
 */
var digits = (length) => {
    return `digits:${length}`;
};

/**
 * The field under validation must be numeric and must have length between
 * given min and max.
 *
 * @example
 *  import { digitsBetween } from "robust-validator"
 *
 *  const definition = {
 *    value: [digitsBetween(4, 6)]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#digits-between-min-max
 */
var digitsBetween = (min, max) => {
    return `digits_between:${min},${max}`;
};

/**
 * The field under validation must be formatted as an e-mail address.
 *
 * @example
 *  import { email } from "robust-validator"
 *
 *  const definition = {
 *    value: [email()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#email
 */
var email = () => {
    return "email";
};

/**
 * The field under validation should be a hexadecimal format.
 *
 * @example
 *  import { hex } from "robust-validator"
 *
 *  const definition = {
 *    value: [hex()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#hex
 */
var hex = () => {
    return "hex";
};

/**
 * The field under validation must be included in the given list of values.
 * The field can be an array or string.
 *
 * @example
 *  import { in } from "robust-validator"
 *
 *  const definition = {
 *    value: [in(["apple", "orange"])]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#in-foo-bar
 */
var _in = (items) => {
    return `in:${items.join(",")}`;
};

/**
 * The field under validation must have an integer value.
 *
 * @example
 *  import { integer } from "robust-validator"
 *
 *  const definition = {
 *    value: [integer()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#integer
 */
var integer = () => {
    return "integer";
};

/**
 * Validate that an attribute is no greater than a given size
 *
 * @example
 *  import { max } from "robust-validator"
 *
 *  const definition = {
 *    value: [max(20)]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#max-value
 */
var max = (value) => {
    return `max:${value}`;
};

/**
 * Validate that an attribute is at least a given size.
 *
 * @example
 *  import { min } from "robust-validator"
 *
 *  const definition = {
 *    value: [min(20)]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#min-value
 */
var min = (value) => {
    return `min:${value}`;
};

/**
 * The field under validation must not be included in the given list of values.
 *
 * @example
 *  import { notIn } from "robust-validator"
 *
 *  const definition = {
 *    value: [notIn(["apple", "orange"])]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#not-in-foo-bar
 */
var notIn = (items) => {
    return `not_in:${items.join(",")}`;
};

/**
 * Validate that an attribute is numeric. The string representation of a number
 * will pass.
 *
 * @example
 *  import { numeric } from "robust-validator"
 *
 *  const definition = {
 *    value: [numeric()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#numeric
 */
var numeric = () => {
    return "numeric";
};

/**
 * The value should be defined. null, undefined or empty strings are not
 * acceptable.
 *
 * @example
 *  import { required } from "robust-validator"
 *
 *  const definition = {
 *    value: [required()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#required
 */
var required = () => {
    return "required";
};

/**
 * The field under validation must have a size matching the given value.
 * For string data, value corresponds to the number of characters. For numeric
 * data, value corresponds to a given integer value.
 *
 * @example
 *  import { size } from "robust-validator"
 *
 *  const definition = {
 *    value: [size(10)]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#size-value
 */
var size = (value) => {
    return `size:${value}`;
};

/**
 * The field under validation must be a string.
 *
 * @example
 *  import { string } from "robust-validator"
 *
 *  const definition = {
 *    value: [string()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#string
 */
var string = () => {
    return "string";
};

/**
 * Validate that an attribute has a valid URL format
 *
 * @example
 *  import { url } from "robust-validator"
 *
 *  const definition = {
 *    value: [url()]
 *  };
 * @type {string}
 * @tutorial https://validator.axe-api.com/rules.html#url
 */
var url = () => {
    return "url";
};

const ar = {
    key: "ar",
    values: {
        accepted: "يجب قبول الحقل.",
        after: "يجب أن يكون الحقل بعد {0}.",
        after_or_equal: "يجب أن يكون الحقل مساويًا أو بعد {0}.",
        alpha: "يجب أن يحتوي الحقل على أحرف أبجدية فقط.",
        alpha_dash: "قد يحتوي الحقل على أحرف أبجدية وأرقام، وعلى الشرطات والشرطات السفلية فقط.",
        alpha_num: "يجب أن يكون الحقل أبجديًا رقميًا.",
        array: "يجب أن يكون الحقل مصفوفة.",
        before: "يجب أن يكون الحقل قبل {0}.",
        before_or_equal: "يجب أن يكون الحقل مساويًا أو قبل {0}.",
        between: "يجب أن يكون الحقل بين {0} و {1}.",
        boolean: "يجب أن يكون الحقل قيمة بولية.",
        confirmed: "تأكيد الحقل لا يتطابق.",
        email: "يجب أن يكون الحقل عنوان بريد إلكتروني.",
        date: "الحقل ليس بتنسيق تاريخ صالح.",
        digits: "يجب أن يحتوي الحقل على {0} أرقام.",
        digits_between: "يجب أن يكون الحقل بين {0} و {1} أرقام.",
        in: "الحقل المحدد غير صالح.",
        integer: "يجب أن يكون الحقل عددًا صحيحًا.",
        hex: "يجب أن يكون الحقل بتنسيق سداسي عشر",
        min: "يجب أن يكون الحقل على الأقل {0}.",
        max: "قد لا يكون الحقل أكبر من {0}.",
        not_in: "الحقل المحدد غير صالح.",
        numeric: "يجب أن يكون الحقل رقمًا.",
        required: "الحقل مطلوب.",
        size: "يجب أن يكون حجم الحقل {0}.",
        string: "يجب أن يكون الحقل نصًا.",
        url: "يجب أن يكون الحقل عنوان URL.",
    },
};
const az = {
    key: "az",
    values: {
        accepted: "Təsdiq olunmalıdır.",
        after: "Sahə {0}-dən sonra olmalıdır.",
        after_or_equal: "Sahə {0}-dən sonra və ya bərabər olmalıdır.",
        alpha: "Sahə yalnız hərflərdən ibarət olmalıdır.",
        alpha_dash: "Sahə yalnız hərf, rəqəm, tire və xətt simvollarından ibarət ola bilər.",
        alpha_num: "Sahə yalnız hərf və rəqəmlərdən ibarət olmalıdır.",
        array: "Sahə bir massiv olmalıdır.",
        before: "Sahə {0}-dən əvvəl olmalıdır.",
        before_or_equal: "Sahə {0}-dən əvvəl və ya bərabər olmalıdır.",
        between: "Sahə {0} və {1} arasında olmalıdır.",
        boolean: "Sahə bir boolean dəyər olmalıdır.",
        confirmed: "Sahə təsdiqi uyğun gəlmir.",
        email: "Sahə bir email olmalıdır.",
        date: "Sahə doğru bir tarix formatında deyil.",
        digits: "Sahə {0} rəqəmindən ibarət olmalıdır.",
        digits_between: "Sahə {0} və {1} arasında rəqəmlərdən ibarət olmalıdır.",
        in: "Seçilmiş sahə yanlışdır.",
        integer: "Sahə bir tam ədəd olmalıdır.",
        hex: "Sahə doğru bir onalıq formatında olmalıdır",
        min: "Sahə ən az {0} olmalıdır.",
        max: "Sahə {0}-dən böyük olmamalıdır.",
        not_in: "Seçilmiş sahə yanlışdır.",
        numeric: "Sahə bir rəqəm olmalıdır.",
        required: "Sahə tələb olunur.",
        size: "Sahənin ölçüsü {0} olmalıdır.",
        string: "Sahə bir simvol sırası olmalıdır.",
        url: "Sahə bir URL olmalıdır.",
    },
};
const be = {
    key: "be",
    values: {
        accepted: "Поле павінна быць прынята.",
        after: "Поле павінна быць пасля {0}.",
        after_or_equal: "Поле павінна быць роўнае ці пасля {0}.",
        alpha: "У полі могуць знаходзіцца толькі літары.",
        alpha_dash: "У полі могуць знаходзіцца толькі літары, лічбы, дэфісы і падкрэсленьні.",
        alpha_num: "Поле павінна ўтрымліваць толькі літары і лічбы.",
        array: "Поле павінна быць масівам.",
        before: "Поле павінна быць да {0}.",
        before_or_equal: "Поле павінна быць роўнае ці да {0}.",
        between: "Поле павінна быць паміж {0} і {1}.",
        boolean: "Поле павінна быць лагічным значэннем.",
        confirmed: "Пацвярджэнне поля не супадае.",
        email: "Поле павінна быць адрасам электроннай пошты.",
        date: "Поле не мае правільнага фармата даты.",
        digits: "Поле павінна складацца з {0} лічбаў.",
        digits_between: "Поле павінна быць паміж {0} і {1} лічбамі.",
        in: "Выбранае поле несапраўднае.",
        integer: "Поле павінна быць цэлым лікам.",
        hex: "Поле павінна мець шаснаццатковы фармат",
        min: "Поле павінна быць не менш за {0}.",
        max: "Поле не можа быць больш за {0}.",
        not_in: "Выбранае поле несапраўднае.",
        numeric: "Поле павінна быць лікам.",
        required: "Гэта поле абавязкова для запаўнення.",
        size: "Памер поля павінен быць {0}.",
        string: "Поле павінна быць радком.",
        url: "Поле павінна быць URL-адрасам.",
    },
};
const bg = {
    key: "bg",
    values: {
        accepted: "Полето трябва да бъде прието.",
        after: "Полето трябва да бъде след {0}.",
        after_or_equal: "Полето трябва да бъде равно или след {0}.",
        alpha: "Полето трябва да съдържа само буквени символи.",
        alpha_dash: "Полето може да съдържа само буквено-цифрови символи, както и тирета и долни черти.",
        alpha_num: "Полето трябва да бъде алфа-цифрово.",
        array: "Полето трябва да бъде масив.",
        before: "Полето трябва да бъде преди {0}.",
        before_or_equal: "Полето трябва да бъде равно или преди {0}.",
        between: "Полето трябва да бъде между {0} и {1}.",
        boolean: "Полето трябва да бъде булева стойност.",
        confirmed: "Полето за потвърждение не съвпада.",
        email: "Полето трябва да бъде имейл адрес.",
        date: "Полето не е валиден формат за дата.",
        digits: "Полето трябва да бъде {0} цифри.",
        digits_between: "Полето трябва да бъде между {0} и {1} цифри.",
        in: "Избраното поле е невалидно.",
        integer: "Полето трябва да бъде цяло число.",
        hex: "Полето трябва да има шестнадесетичен формат",
        min: "Полето трябва да бъде поне {0}.",
        max: "Полето не може да бъде по-голямо от {0}.",
        not_in: "Избраното поле е невалидно.",
        numeric: "Полето трябва да бъде число.",
        required: "Полето е задължително.",
        size: "Размерът на полето трябва да бъде {0}.",
        string: "Полето трябва да бъде низ.",
        url: "Полето трябва да бъде URL адрес.",
    },
};
const bs = {
    key: "bs",
    values: {
        accepted: "Polje mora biti prihvaćeno.",
        after: "Polje mora biti nakon {0}.",
        after_or_equal: "Polje mora biti jednako ili nakon {0}.",
        alpha: "Polje mora sadržavati samo alfabetske znakove.",
        alpha_dash: "Polje može sadržavati samo alfa-numeričke znakove, kao i crtice i donje crte.",
        alpha_num: "Polje mora biti alfanumeričko.",
        array: "Polje mora biti niz.",
        before: "Polje mora biti prije {0}.",
        before_or_equal: "Polje mora biti jednako ili prije {0}.",
        between: "Polje mora biti između {0} i {1}.",
        boolean: "Polje mora biti boolean vrijednost.",
        confirmed: "Potvrda polja se ne poklapa.",
        email: "Polje mora biti email adresa.",
        date: "Polje nije u validnom formatu datuma.",
        digits: "Polje mora imati {0} cifara.",
        digits_between: "Polje mora imati između {0} i {1} cifara.",
        in: "Odabrano polje nije validno.",
        integer: "Polje mora biti cijeli broj.",
        hex: "Polje mora imati heksadecimalni format",
        min: "Polje mora biti barem {0}.",
        max: "Polje ne smije biti veće od {0}.",
        not_in: "Odabrano polje nije validno.",
        numeric: "Polje mora biti broj.",
        required: "Polje je obavezno.",
        size: "Veličina polja mora biti {0}.",
        string: "Polje mora biti string.",
        url: "Polje mora biti URL adresa.",
    },
};
const ca = {
    key: "ca",
    values: {
        accepted: "El camp ha de ser acceptat.",
        after: "El camp ha de ser posterior a {0}.",
        after_or_equal: "El camp ha de ser igual o posterior a {0}.",
        alpha: "El camp ha de contenir només caràcters alfabètics.",
        alpha_dash: "El camp pot contenir només caràcters alfanumèrics, guions i guions baixos.",
        alpha_num: "El camp ha de ser alfanumèric.",
        array: "El camp ha de ser una matriu.",
        before: "El camp ha de ser anterior a {0}.",
        before_or_equal: "El camp ha de ser igual o anterior a {0}.",
        between: "El camp ha de ser entre {0} i {1}.",
        boolean: "El valor del camp ha de ser un booleà.",
        confirmed: "La confirmació del camp no coincideix.",
        email: "El camp ha de ser un correu electrònic.",
        date: "El camp no té un format de data vàlid.",
        digits: "El camp ha de tenir {0} dígits.",
        digits_between: "El camp ha de tenir entre {0} i {1} dígits.",
        in: "El camp seleccionat no és vàlid.",
        integer: "El camp ha de ser un nombre enter.",
        hex: "El camp ha de tenir un format hexadecimal.",
        min: "El camp ha de ser com a mínim {0}.",
        max: "El camp no pot ser superior a {0}.",
        not_in: "El camp seleccionat no és vàlid.",
        numeric: "El camp ha de ser un nombre.",
        required: "El camp és obligatori.",
        size: "La mida del camp ha de ser {0}.",
        string: "El camp ha de ser una cadena de text.",
        url: "El camp ha de ser una URL.",
    },
};
const cs = {
    key: "cs",
    values: {
        accepted: "Pole musí být přijato.",
        after: "Pole musí být po {0}.",
        after_or_equal: "Pole musí být rovno nebo po {0}.",
        alpha: "Pole musí obsahovat pouze abecední znaky.",
        alpha_dash: "Pole může obsahovat pouze alfanumerické znaky, stejně jako pomlčky a podtržítka.",
        alpha_num: "Pole musí být alfanumerické.",
        array: "Pole musí být pole.",
        before: "Pole musí být před {0}.",
        before_or_equal: "Pole musí být rovno nebo před {0}.",
        between: "Pole musí být mezi {0} a {1}.",
        boolean: "Pole musí být hodnota boolean.",
        confirmed: "Potvrzení pole neodpovídá.",
        email: "Pole musí být e-mail.",
        date: "Pole nemá platný formát data.",
        digits: "Pole musí mít {0} číslic.",
        digits_between: "Pole musí být mezi {0} a {1} číslicemi.",
        in: "Vybrané pole je neplatné.",
        integer: "Pole musí být celé číslo.",
        hex: "Pole musí mít hexadecimální formát.",
        min: "Pole musí být alespoň {0}.",
        max: "Pole nesmí být větší než {0}.",
        not_in: "Vybrané pole je neplatné.",
        numeric: "Pole musí být číslo.",
        required: "Pole je povinné.",
        size: "Velikost pole musí být {0}.",
        string: "Pole musí být řetězec.",
        url: "Pole musí být URL.",
    },
};
const cy = {
    key: "cy",
    values: {
        accepted: "Rhaid derbyn y maes.",
        after: "Rhaid i'r maes fod ar ôl {0}.",
        after_or_equal: "Rhaid i'r maes fod yn gyfartal neu ar ôl {0}.",
        alpha: "Rhaid i'r maes gynnwys dim ond nodau alffa.",
        alpha_dash: "Dim ond nodau alffa-ariannol a gromlinellau a thiriadau yn unig a all fod yn y maes.",
        alpha_num: "Rhaid i'r maes fod yn alffa-ariannol.",
        array: "Rhaid i'r maes fod yn array.",
        before: "Rhaid i'r maes fod cyn {0}.",
        before_or_equal: "Rhaid i'r maes fod yn gyfartal neu cyn {0}.",
        between: "Rhaid i'r maes fod rhwng {0} a {1}.",
        boolean: "Rhaid i'r maes fod yn werth boolean.",
        confirmed: "Nid yw'r cadarnhad maes yn cydweddu.",
        email: "Rhaid i'r maes fod yn e-bost.",
        date: "Nid yw'r maes yn fformat dyddiad dilys.",
        digits: "Rhaid i'r maes fod yn {0} digidau.",
        digits_between: "Rhaid i'r maes fod rhwng {0} a {1} digid.",
        in: "Mae'r maes a ddewiswyd yn annilys.",
        integer: "Rhaid i'r maes fod yn gyfanrif.",
        hex: "Rhaid i'r maes fod â fformat hexadecanol",
        min: "Rhaid i'r maes fod o leiaf {0}.",
        max: "Nid yw'r maes yn gallu bod yn fwy na {0}.",
        not_in: "Mae'r maes a ddewiswyd yn annilys.",
        numeric: "Rhaid i'r maes fod yn rif.",
        required: "Rhaid i'r maes fod yn ofynnol.",
        size: "Rhaid i faint y maes fod yn {0}.",
        string: "Rhaid i'r maes fod yn llinyn.",
        url: "Rhaid i'r maes fod yn URL.",
    },
};
const da = {
    key: "da",
    values: {
        accepted: "Feltet skal accepteres.",
        after: "Feltet skal være efter {0}.",
        after_or_equal: "Feltet skal være lig med eller efter {0}.",
        alpha: "Feltet skal kun indeholde alfabetiske karakterer.",
        alpha_dash: "Feltet må kun indeholde alfa-numeriske karakterer samt bindestreger og underscores.",
        alpha_num: "Feltet skal være alfanumerisk.",
        array: "Feltet skal være en liste.",
        before: "Feltet skal være før {0}.",
        before_or_equal: "Feltet skal være lig med eller før {0}.",
        between: "Feltet skal være mellem {0} og {1}.",
        boolean: "Feltet skal være en boolesk værdi.",
        confirmed: "Bekræftelsen af feltet matcher ikke.",
        email: "Feltet skal være en email.",
        date: "Feltet har ikke en gyldig datoformat.",
        digits: "Feltet skal være på {0} cifre.",
        digits_between: "Feltet skal være mellem {0} og {1} cifre.",
        in: "Den valgte værdi er ugyldig.",
        integer: "Feltet skal være et heltal.",
        hex: "Feltet skal have en hexadecimal format",
        min: "Feltet skal være mindst {0}.",
        max: "Feltet må ikke være større end {0}.",
        not_in: "Den valgte værdi er ugyldig.",
        numeric: "Feltet skal være et tal.",
        required: "Feltet er påkrævet.",
        size: "Feltets størrelse skal være {0}.",
        string: "Feltet skal være en streng.",
        url: "Feltet skal være en URL.",
    },
};
const de = {
    key: "de",
    values: {
        accepted: "Das Feld muss akzeptiert werden.",
        after: "Das Feld muss nach {0} liegen.",
        after_or_equal: "Das Feld muss gleich oder nach {0} liegen.",
        alpha: "Das Feld darf nur alphabetische Zeichen enthalten.",
        alpha_dash: "Das Feld darf nur alphanumerische Zeichen sowie Bindestriche und Unterstriche enthalten.",
        alpha_num: "Das Feld muss alphanumerisch sein.",
        array: "Das Feld muss ein Array sein.",
        before: "Das Feld muss vor {0} liegen.",
        before_or_equal: "Das Feld muss gleich oder vor {0} liegen.",
        between: "Das Feld muss zwischen {0} und {1} liegen.",
        boolean: "Das Feld muss einen booleschen Wert haben.",
        confirmed: "Die Bestätigung stimmt nicht überein.",
        email: "Das Feld muss eine E-Mail sein.",
        date: "Das Feld hat kein gültiges Datumsformat.",
        digits: "Das Feld muss {0} Ziffern haben.",
        digits_between: "Das Feld muss zwischen {0} und {1} Ziffern haben.",
        in: "Die ausgewählte Option ist ungültig.",
        integer: "Das Feld muss eine ganze Zahl sein.",
        hex: "Das Feld sollte das Hexadezimalformat haben",
        min: "Das Feld muss mindestens {0} sein.",
        max: "Das Feld darf nicht größer als {0} sein.",
        not_in: "Die ausgewählte Option ist ungültig.",
        numeric: "Das Feld muss eine Zahl sein.",
        required: "Das Feld ist erforderlich.",
        size: "Die Größe des Feldes muss {0} sein.",
        string: "Das Feld muss eine Zeichenkette sein.",
        url: "Das Feld muss eine URL sein.",
    },
};
const el = {
    key: "el",
    values: {
        accepted: "Το πεδίο πρέπει να γίνει αποδεκτό.",
        after: "Το πεδίο πρέπει να είναι μετά από {0}.",
        after_or_equal: "Το πεδίο πρέπει να είναι ίσο ή μετά από {0}.",
        alpha: "Το πεδίο πρέπει να περιέχει μόνο αλφαβητικούς χαρακτήρες.",
        alpha_dash: "Το πεδίο μπορεί να περιέχει μόνο αλφαριθμητικούς χαρακτήρες, καθώς και παύλες και κάτω παύλες.",
        alpha_num: "Το πεδίο πρέπει να είναι αλφαριθμητικό.",
        array: "Το πεδίο πρέπει να είναι πίνακας.",
        before: "Το πεδίο πρέπει να είναι πριν από {0}.",
        before_or_equal: "Το πεδίο πρέπει να είναι ίσο ή πριν από {0}.",
        between: "Το πεδίο πρέπει να είναι μεταξύ {0} και {1}.",
        boolean: "Το πεδίο πρέπει να είναι λογική τιμή.",
        confirmed: "Η επιβεβαίωση του πεδίου δεν ταιριάζει.",
        email: "Το πεδίο πρέπει να είναι έγκυρη διεύθυνση email.",
        date: "Το πεδίο δεν έχει έγκυρη μορφή ημερομηνίας.",
        digits: "Το πεδίο πρέπει να έχει {0} ψηφία.",
        digits_between: "Το πεδίο πρέπει να έχει ανάμεσα σε {0} και {1} ψηφία.",
        in: "Το επιλεγμένο πεδίο δεν είναι έγκυρο.",
        integer: "Το πεδίο πρέπει να είναι ακέραιος αριθμός.",
        hex: "Το πεδίο πρέπει να έχει δεκαεξαδική μορφή",
        min: "Το πεδίο πρέπει να είναι τουλάχιστον {0}.",
        max: "Το πεδίο δεν πρέπει να είναι μεγαλύτερο από {0}.",
        not_in: "Το επιλεγμένο πεδίο δεν είναι έγκυρο.",
        numeric: "Το πεδίο πρέπει να είναι αριθμός.",
        required: "Το πεδίο είναι υποχρεωτικό.",
        size: "Το μέγεθος του πεδίου πρέπει να είναι {0}.",
        string: "Το πεδίο πρέπει να είναι αλφαριθμητικό.",
        url: "Το πεδίο πρέπει να είναι URL.",
    },
};
const en = {
    key: "en",
    values: {
        accepted: "The field must be accepted.",
        after: "The field must be after {0}.",
        after_or_equal: "The field must be equal or after {0}.",
        alpha: "The field must contain only alphabetic characters.",
        alpha_dash: "The field may only contain alpha-numeric characters, as well as dashes and underscores.",
        alpha_num: "The field must be alphanumeric.",
        array: "The field must be an array.",
        before: "The field must be before {0}.",
        before_or_equal: "The field must be equal or before {0}.",
        between: "The field must be between {0} and {1}.",
        boolean: "The field must be a boolean value.",
        confirmed: "The field confirmation does not match.",
        email: "The field must be an email.",
        date: "The field is not a valid date format.",
        digits: "The field must be {0} digits.",
        digits_between: "The field must be between {0} and {1} digits.",
        in: "The selected field is invalid.",
        integer: "The field must be an integer.",
        hex: "The field should have hexadecimal format",
        min: "The field must be at least {0}.",
        max: "The field may not be greater than {0}.",
        not_in: "The selected field is invalid.",
        numeric: "The field must be a number.",
        required: "The field is required.",
        size: "The field's size must be {0}.",
        string: "The field must be a string.",
        url: "The field must be an URL.",
    },
};
const es = {
    key: "es",
    values: {
        accepted: "El campo debe ser aceptado.",
        after: "El campo debe ser después de {0}.",
        after_or_equal: "El campo debe ser igual o después de {0}.",
        alpha: "El campo debe contener solo caracteres alfabéticos.",
        alpha_dash: "El campo solo puede contener caracteres alfanuméricos, así como guiones y guiones bajos.",
        alpha_num: "El campo debe ser alfanumérico.",
        array: "El campo debe ser un array.",
        before: "El campo debe ser antes de {0}.",
        before_or_equal: "El campo debe ser igual o antes de {0}.",
        between: "El campo debe estar entre {0} y {1}.",
        boolean: "El campo debe ser un valor booleano.",
        confirmed: "La confirmación del campo no coincide.",
        email: "El campo debe ser un correo electrónico.",
        date: "El campo no tiene un formato de fecha válido.",
        digits: "El campo debe tener {0} dígitos.",
        digits_between: "El campo debe tener entre {0} y {1} dígitos.",
        in: "El campo seleccionado no es válido.",
        integer: "El campo debe ser un número entero.",
        hex: "El campo debe tener formato hexadecimal",
        min: "El campo debe tener al menos {0}.",
        max: "El campo no puede ser mayor que {0}.",
        not_in: "El campo seleccionado no es válido.",
        numeric: "El campo debe ser un número.",
        required: "El campo es obligatorio.",
        size: "El tamaño del campo debe ser {0}.",
        string: "El campo debe ser una cadena de texto.",
        url: "El campo debe ser una URL.",
    },
};
const et = {
    key: "et",
    values: {
        accepted: "Väli peab olema aktsepteeritud.",
        after: "Väli peab olema pärast {0}.",
        after_or_equal: "Väli peab olema võrdne või pärast {0}.",
        alpha: "Väli võib sisaldada ainult tähestikulisi märke.",
        alpha_dash: "Väli võib sisaldada ainult tähestikulisi ja numbrilisi märke, samuti kriipse ja allkriipse.",
        alpha_num: "Väli peab olema alfanumeeriline.",
        array: "Väli peab olema massiiv.",
        before: "Väli peab olema enne {0}.",
        before_or_equal: "Väli peab olema võrdne või enne {0}.",
        between: "Väli peab olema vahemikus {0} kuni {1}.",
        boolean: "Väli peab olema booleani väärtus.",
        confirmed: "Väli kinnitus ei kattu.",
        email: "Väli peab olema e-posti aadress.",
        date: "Väli ei ole kehtiv kuupäeva vorming.",
        digits: "Väli peab olema {0} numbrit.",
        digits_between: "Väli peab olema vahemikus {0} kuni {1} numbrit.",
        in: "Valitud väli ei ole kehtiv.",
        integer: "Väli peab olema täisarv.",
        hex: "Väli peab olema heksadetsimaalne.",
        min: "Väli peab olema vähemalt {0}.",
        max: "Väli ei tohi olla suurem kui {0}.",
        not_in: "Valitud väli ei ole kehtiv.",
        numeric: "Väli peab olema number.",
        required: "Väli on kohustuslik.",
        size: "Välja suurus peab olema {0}.",
        string: "Väli peab olema sõne.",
        url: "Väli peab olema URL.",
    },
};
const eu = {
    key: "eu",
    values: {
        accepted: "Kanpoko eremua onartu behar da.",
        after: "Eremua {0} ostean egon behar da.",
        after_or_equal: "Eremua {0} berdina edo ostean egon behar da.",
        alpha: "Eremuak alfabetako karaktereak izan behar ditu soilik.",
        alpha_dash: "Eremuak alfanumeriko karaktereak, marrak eta azpimarrak soilik izan ditzake.",
        alpha_num: "Eremuak alfanumerikoa izan behar da.",
        array: "Eremuak bilduma izan behar da.",
        before: "Eremua {0} aurretik egon behar da.",
        before_or_equal: "Eremua {0} berdina edo aurretik egon behar da.",
        between: "Eremua {0} eta {1} artean egon behar da.",
        boolean: "Eremua boolean balioa izan behar da.",
        confirmed: "Eremuaren baieztapena ez dator bat.",
        email: "Eremuak emaila izan behar du.",
        date: "Eremua ez da data formatu baliogarria.",
        digits: "Eremuak {0} digitu izan behar ditu.",
        digits_between: "Eremuak {0} eta {1} digitu artean izan behar ditu.",
        in: "Hautatutako eremua ez da baliozkoa.",
        integer: "Eremua zenbaki osoa izan behar da.",
        hex: "Eremuak exadecimal formatua izan behar du",
        min: "Eremua gutxienez {0} izan behar da.",
        max: "Eremua ezin da {0} baino handiagoa izan.",
        not_in: "Hautatutako eremua ez da baliozkoa.",
        numeric: "Eremua zenbaki izan behar da.",
        required: "Eremuak derrigorrezkoa da.",
        size: "Eremuaren tamaina {0} izan behar da.",
        string: "Eremua karaktere-katea izan behar da.",
        url: "Eremua URL izan behar da.",
    },
};
const fa = {
    key: "fa",
    values: {
        accepted: "فیلد باید پذیرفته شود.",
        after: "فیلد باید پس از {0} باشد.",
        after_or_equal: "فیلد باید برابر یا پس از {0} باشد.",
        alpha: "فیلد باید فقط شامل حروف الفبا باشد.",
        alpha_dash: "فیلد تنها می‌تواند شامل حروف الفبا، اعداد، خط تیره و آندرلاین باشد.",
        alpha_num: "فیلد باید عددی یا حروفی باشد.",
        array: "فیلد باید یک آرایه باشد.",
        before: "فیلد باید پیش از {0} باشد.",
        before_or_equal: "فیلد باید برابر یا پیش از {0} باشد.",
        between: "فیلد باید بین {0} و {1} باشد.",
        boolean: "فیلد باید یک مقدار بولین باشد.",
        confirmed: "تأیید فیلد مطابقت ندارد.",
        email: "فیلد باید یک ایمیل باشد.",
        date: "فرمت تاریخ فیلد معتبر نیست.",
        digits: "فیلد باید {0} رقم باشد.",
        digits_between: "فیلد باید بین {0} و {1} رقم باشد.",
        in: "انتخاب شده برای فیلد معتبر نیست.",
        integer: "فیلد باید یک عدد صحیح باشد.",
        hex: "فیلد باید دارای فرمت شانزده‌گانه باشد.",
        min: "فیلد باید حداقل {0} باشد.",
        max: "فیلد نمی‌تواند بیشتر از {0} باشد.",
        not_in: "انتخاب شده برای فیلد معتبر نیست.",
        numeric: "فیلد باید یک عدد باشد.",
        required: "فیلد الزامی است.",
        size: "اندازه فیلد باید {0} باشد.",
        string: "فیلد باید یک رشته باشد.",
        url: "فیلد باید یک آدرس اینترنتی باشد.",
    },
};
const fi = {
    key: "fi",
    values: {
        accepted: "Kentän on oltava hyväksytty.",
        after: "Kentän on oltava jälkeen {0}.",
        after_or_equal: "Kentän on oltava yhtä suuri tai suurempi kuin {0}.",
        alpha: "Kenttä saa sisältää vain aakkosellisia merkkejä.",
        alpha_dash: "Kenttä voi sisältää vain aakkos-numeerisia merkkejä, viivoja ja alaviivoja.",
        alpha_num: "Kentän on oltava aakkos-numeerinen.",
        array: "Kentän on oltava taulukko.",
        before: "Kentän on oltava ennen {0}.",
        before_or_equal: "Kentän on oltava yhtä suuri tai pienempi kuin {0}.",
        between: "Kentän on oltava välillä {0} ja {1}.",
        boolean: "Kentän on oltava totuusarvo.",
        confirmed: "Vahvistus ei täsmää.",
        email: "Kentän on oltava sähköposti.",
        date: "Kenttä ei ole kelvollinen päivämäärämuoto.",
        digits: "Kentän on oltava {0} numeroa pitkä.",
        digits_between: "Kentän on oltava välillä {0} ja {1} numeroa pitkä.",
        in: "Valittu kenttä ei ole kelvollinen.",
        integer: "Kentän on oltava kokonaisluku.",
        hex: "Kentän on oltava heksadesimaalimuodossa.",
        min: "Kentän on oltava vähintään {0}.",
        max: "Kenttä ei saa olla suurempi kuin {0}.",
        not_in: "Valittu kenttä ei ole kelvollinen.",
        numeric: "Kentän on oltava numero.",
        required: "Kenttä on pakollinen.",
        size: "Kentän koon on oltava {0}.",
        string: "Kentän on oltava merkkijono.",
        url: "Kentän on oltava URL-osoite.",
    },
};
const fr = {
    key: "fr",
    values: {
        accepted: "Le champ doit être accepté.",
        after: "Le champ doit être après {0}.",
        after_or_equal: "Le champ doit être égal ou après {0}.",
        alpha: "Le champ doit contenir uniquement des caractères alphabétiques.",
        alpha_dash: "Le champ ne peut contenir que des caractères alphanumériques, des tirets et des underscores.",
        alpha_num: "Le champ doit être alphanumérique.",
        array: "Le champ doit être un tableau.",
        before: "Le champ doit être avant {0}.",
        before_or_equal: "Le champ doit être égal ou avant {0}.",
        between: "Le champ doit être entre {0} et {1}.",
        boolean: "Le champ doit être une valeur booléenne.",
        confirmed: "La confirmation du champ ne correspond pas.",
        email: "Le champ doit être une adresse e-mail.",
        date: "Le champ n'est pas au format date valide.",
        digits: "Le champ doit comporter {0} chiffres.",
        digits_between: "Le champ doit comporter entre {0} et {1} chiffres.",
        in: "La valeur sélectionnée du champ n'est pas valide.",
        integer: "Le champ doit être un entier.",
        hex: "Le champ doit avoir un format hexadécimal.",
        min: "Le champ doit être au moins {0}.",
        max: "Le champ ne peut pas être supérieur à {0}.",
        not_in: "La valeur sélectionnée du champ n'est pas valide.",
        numeric: "Le champ doit être un nombre.",
        required: "Le champ est obligatoire.",
        size: "La taille du champ doit être de {0}.",
        string: "Le champ doit être une chaîne de caractères.",
        url: "Le champ doit être une URL.",
    },
};
const hr = {
    key: "hr",
    values: {
        accepted: "Polje mora biti prihvaćeno.",
        after: "Polje mora biti nakon {0}.",
        after_or_equal: "Polje mora biti jednako ili nakon {0}.",
        alpha: "Polje mora sadržavati samo alfabetske znakove.",
        alpha_dash: "Polje može sadržavati samo alfanumeričke znakove, kao i crte i podvlake.",
        alpha_num: "Polje mora biti alfanumeričko.",
        array: "Polje mora biti niz.",
        before: "Polje mora biti prije {0}.",
        before_or_equal: "Polje mora biti jednako ili prije {0}.",
        between: "Polje mora biti između {0} i {1}.",
        boolean: "Polje mora biti boolean vrijednost.",
        confirmed: "Potvrda polja se ne podudara.",
        email: "Polje mora biti e-mail adresa.",
        date: "Polje nije valjanog formata datuma.",
        digits: "Polje mora imati {0} znamenki.",
        digits_between: "Polje mora imati između {0} i {1} znamenki.",
        in: "Odabrano polje nije valjano.",
        integer: "Polje mora biti cijeli broj.",
        hex: "Polje mora imati heksadecimalni format.",
        min: "Polje mora biti barem {0}.",
        max: "Polje ne smije biti veće od {0}.",
        not_in: "Odabrano polje nije valjano.",
        numeric: "Polje mora biti broj.",
        required: "Polje je obavezno.",
        size: "Veličina polja mora biti {0}.",
        string: "Polje mora biti niz znakova.",
        url: "Polje mora biti URL adresa.",
    },
};
const hu = {
    key: "hu",
    values: {
        accepted: "A mezőt el kell fogadni.",
        after: "A mezőnek {0} után kell lennie.",
        after_or_equal: "A mezőnek egyenlőnek vagy {0}-től későbbinek kell lennie.",
        alpha: "A mező csak betűket tartalmazhat.",
        alpha_dash: "A mező csak betűket, számokat, kötőjeleket és alsóvonásokat tartalmazhat.",
        alpha_num: "A mezőnek betűket és számokat kell tartalmaznia.",
        array: "A mezőnek tömbnek kell lennie.",
        before: "A mezőnek {0} előtt kell lennie.",
        before_or_equal: "A mezőnek egyenlőnek vagy {0}-től korábbinak kell lennie.",
        between: "A mezőnek {0} és {1} között kell lennie.",
        boolean: "A mezőnek logikai értéknek kell lennie.",
        confirmed: "A mező megerősítése nem egyezik meg.",
        email: "A mezőnek érvényes e-mail címnek kell lennie.",
        date: "A mező érvénytelen dátumformátum.",
        digits: "A mezőnek {0} számjegyből kell állnia.",
        digits_between: "A mezőnek {0} és {1} számjegy között kell lennie.",
        in: "A kiválasztott érték érvénytelen.",
        integer: "A mezőnek egész számnak kell lennie.",
        hex: "A mezőnek hexadecimális formátumúnak kell lennie.",
        min: "A mező legalább {0} kell legyen.",
        max: "A mező nem lehet nagyobb, mint {0}.",
        not_in: "A kiválasztott érték érvénytelen.",
        numeric: "A mezőnek számnak kell lennie.",
        required: "A mező kitöltése kötelező.",
        size: "A mező mérete {0} kell legyen.",
        string: "A mezőnek karakterláncnak kell lennie.",
        url: "A mezőnek érvényes URL-nek kell lennie.",
    },
};
const id = {
    key: "id",
    values: {
        accepted: "Bidang ini harus diterima.",
        after: "Bidang ini harus setelah {0}.",
        after_or_equal: "Bidang ini harus sama atau setelah {0}.",
        alpha: "Bidang ini harus berisi karakter alfabet saja.",
        alpha_dash: "Bidang ini hanya boleh berisi karakter alfa-numerik, serta tanda hubung dan garis bawah.",
        alpha_num: "Bidang ini harus alfanumerik.",
        array: "Bidang ini harus sebuah array.",
        before: "Bidang ini harus sebelum {0}.",
        before_or_equal: "Bidang ini harus sama atau sebelum {0}.",
        between: "Bidang ini harus antara {0} dan {1}.",
        boolean: "Bidang ini harus nilai boolean.",
        confirmed: "Konfirmasi bidang ini tidak cocok.",
        email: "Bidang ini harus sebuah email.",
        date: "Bidang ini bukan format tanggal yang valid.",
        digits: "Bidang ini harus {0} digit.",
        digits_between: "Bidang ini harus antara {0} dan {1} digit.",
        in: "Pilihan bidang ini tidak valid.",
        integer: "Bidang ini harus bilangan bulat.",
        hex: "Bidang ini harus berformat heksadesimal.",
        min: "Bidang ini harus setidaknya {0}.",
        max: "Bidang ini tidak boleh lebih dari {0}.",
        not_in: "Pilihan bidang ini tidak valid.",
        numeric: "Bidang ini harus sebuah angka.",
        required: "Bidang ini wajib diisi.",
        size: "Ukuran bidang ini harus {0}.",
        string: "Bidang ini harus sebuah string.",
        url: "Bidang ini harus sebuah URL.",
    },
};
const it = {
    key: "it",
    values: {
        accepted: "Il campo deve essere accettato.",
        after: "Il campo deve essere successivo a {0}.",
        after_or_equal: "Il campo deve essere uguale o successivo a {0}.",
        alpha: "Il campo deve contenere solo caratteri alfabetici.",
        alpha_dash: "Il campo può contenere solo caratteri alfanumerici, trattini e underscore.",
        alpha_num: "Il campo deve essere alfanumerico.",
        array: "Il campo deve essere un array.",
        before: "Il campo deve essere precedente a {0}.",
        before_or_equal: "Il campo deve essere uguale o precedente a {0}.",
        between: "Il campo deve essere compreso tra {0} e {1}.",
        boolean: "Il campo deve essere un valore booleano.",
        confirmed: "La conferma del campo non corrisponde.",
        email: "Il campo deve essere un indirizzo email.",
        date: "Il campo non ha un formato data valido.",
        digits: "Il campo deve essere composto da {0} cifre.",
        digits_between: "Il campo deve essere composto da un numero di cifre compreso tra {0} e {1}.",
        in: "Il campo selezionato non è valido.",
        integer: "Il campo deve essere un numero intero.",
        hex: "Il campo deve avere un formato esadecimale.",
        min: "Il campo deve essere almeno {0}.",
        max: "Il campo non può essere superiore a {0}.",
        not_in: "Il campo selezionato non è valido.",
        numeric: "Il campo deve essere un numero.",
        required: "Il campo è obbligatorio.",
        size: "La dimensione del campo deve essere {0}.",
        string: "Il campo deve essere una stringa.",
        url: "Il campo deve essere un URL.",
    },
};
const ja = {
    key: "ja",
    values: {
        accepted: "フィールドは受け入れる必要があります。",
        after: "フィールドは {0} の後でなければなりません。",
        after_or_equal: "フィールドは {0} と等しいかそれ以降でなければなりません。",
        alpha: "フィールドはアルファベットのみを含む必要があります。",
        alpha_dash: "フィールドはアルファベット、数字、ダッシュ、アンダースコアのみを含むことができます。",
        alpha_num: "フィールドは英数字でなければなりません。",
        array: "フィールドは配列でなければなりません。",
        before: "フィールドは {0} の前でなければなりません。",
        before_or_equal: "フィールドは {0} と等しいかそれ以前でなければなりません。",
        between: "フィールドは {0} から {1} の間でなければなりません。",
        boolean: "フィールドは真偽値でなければなりません。",
        confirmed: "フィールドの確認が一致しません。",
        email: "フィールドはメールアドレスでなければなりません。",
        date: "フィールドは有効な日付形式ではありません。",
        digits: "フィールドは {0} 桁でなければなりません。",
        digits_between: "フィールドは {0} から {1} 桁の間でなければなりません。",
        in: "選択されたフィールドは無効です。",
        integer: "フィールドは整数でなければなりません。",
        hex: "フィールドは16進数形式である必要があります。",
        min: "フィールドは少なくとも {0} でなければなりません。",
        max: "フィールドは {0} を超えてはいけません。",
        not_in: "選択されたフィールドは無効です。",
        numeric: "フィールドは数値でなければなりません。",
        required: "フィールドは必須です。",
        size: "フィールドのサイズは {0} でなければなりません。",
        string: "フィールドは文字列でなければなりません。",
        url: "フィールドはURLでなければなりません。",
    },
};
const ka = {
    key: "ka",
    values: {
        accepted: "ვეთანხმებით ველს.",
        after: "ველი უნდა იყოს {0}-ზე შემდეგ.",
        after_or_equal: "ველი უნდა იყოს {0}-ზე ტოლი ან შემდეგ.",
        alpha: "ველი უნდა შეიცავდეს მხოლოდ ანბანურ სიმბოლოებს.",
        alpha_dash: "ველი შეიძლება შეიცავდეს მხოლოდ ალფა-ნუმერიკ სიმბოლოებს, ტირებებს და ქვედნებს.",
        alpha_num: "ველი უნდა იყოს ალფა-ნუმერიკული.",
        array: "ველი უნდა იყოს მასივი.",
        before: "ველი უნდა იყოს {0}-ზე წინ.",
        before_or_equal: "ველი უნდა იყოს {0}-ზე ტოლი ან წინ.",
        between: "ველი უნდა იყოს {0}-დან {1}-მდე.",
        boolean: "ველი უნდა იყოს ლოგიკური მნიშვნელობა.",
        confirmed: "ველის დადასტურება არ ემთხვევა.",
        email: "ველი უნდა იყოს ელ. ფოსტა.",
        date: "ველი არ არის სწორი თარიღის ფორმატში.",
        digits: "ველი უნდა იყოს {0} ციფრი.",
        digits_between: "ველი უნდა იყოს {0}-დან {1}-მდე ციფრი.",
        in: "არჩეული ველი არასწორია.",
        integer: "ველი უნდა იყოს მთლიანი რიცხვი.",
        hex: "ველი უნდა ჰქსადეც იყოს ფორმატირებული.",
        min: "ველი უნდა იყოს მინიმუმ {0}.",
        max: "ველი არ უნდა აღემატოს {0}-ს.",
        not_in: "არჩეული ველი არასწორია.",
        numeric: "ველი უნდა იყოს რიცხვი.",
        required: "ველი აუცილებელია.",
        size: "ველის ზომა უნდა იყოს {0}.",
        string: "ველი უნდა იყოს ტექსტი.",
        url: "ველი უნდა იყოს URL.",
    },
};
const ko = {
    key: "ko",
    values: {
        accepted: "필드를 수락해야 합니다.",
        after: "필드는 {0} 이후여야 합니다.",
        after_or_equal: "필드는 {0} 이후거나 같아야 합니다.",
        alpha: "필드는 알파벳 문자만 포함해야 합니다.",
        alpha_dash: "필드는 알파벳, 숫자, 대시, 밑줄만 포함할 수 있습니다.",
        alpha_num: "필드는 알파벳 및 숫자만 허용됩니다.",
        array: "필드는 배열이어야 합니다.",
        before: "필드는 {0} 이전이어야 합니다.",
        before_or_equal: "필드는 {0} 이전이거나 같아야 합니다.",
        between: "필드는 {0}에서 {1} 사이여야 합니다.",
        boolean: "필드는 부울 값이어야 합니다.",
        confirmed: "필드 확인이 일치하지 않습니다.",
        email: "필드는 이메일이어야 합니다.",
        date: "필드는 유효한 날짜 형식이 아닙니다.",
        digits: "필드는 {0} 자리 숫자여야 합니다.",
        digits_between: "필드는 {0}에서 {1} 자리 사이여야 합니다.",
        in: "선택한 필드가 유효하지 않습니다.",
        integer: "필드는 정수여야 합니다.",
        hex: "필드는 16진수 형식이어야 합니다.",
        min: "필드는 최소 {0} 이어야 합니다.",
        max: "필드는 {0}보다 클 수 없습니다.",
        not_in: "선택한 필드가 유효하지 않습니다.",
        numeric: "필드는 숫자여야 합니다.",
        required: "필드는 필수입니다.",
        size: "필드의 크기는 {0}이어야 합니다.",
        string: "필드는 문자열이어야 합니다.",
        url: "필드는 URL이어야 합니다.",
    },
};
const li = {
    key: "li",
    values: {
        accepted: "Šis laukas turi būti priimtas.",
        after: "Šis laukas turi būti po {0}.",
        after_or_equal: "Šis laukas turi būti lygus arba po {0}.",
        alpha: "Šiame lauke gali būti tik abėcėlės raidės.",
        alpha_dash: "Šiame lauke gali būti tik alfa-numeric raidės, brūkšniai ir pabraukimai.",
        alpha_num: "Šis laukas turi būti alfa-numeric.",
        array: "Šis laukas turi būti masyvas.",
        before: "Šis laukas turi būti prieš {0}.",
        before_or_equal: "Šis laukas turi būti lygus arba prieš {0}.",
        between: "Šis laukas turi būti tarp {0} ir {1}.",
        boolean: "Šis laukas turi būti boolean tipo.",
        confirmed: "Šis laukas nesutampa su patvirtinimu.",
        email: "Šis laukas turi būti el. pašto adresas.",
        date: "Šis laukas netinkamo datos formato.",
        digits: "Šis laukas turi būti sudarytas iš {0} skaitmenų.",
        digits_between: "Šis laukas turi būti tarp {0} ir {1} skaitmenų.",
        in: "Pasirinktas laukas yra netinkamas.",
        integer: "Šis laukas turi būti sveikasis skaičius.",
        hex: "Šiame lauke turi būti heksadecimalinis formatas",
        min: "Šis laukas turi būti bent {0}.",
        max: "Šis laukas negali būti didesnis nei {0}.",
        not_in: "Pasirinktas laukas yra netinkamas.",
        numeric: "Šis laukas turi būti skaičius.",
        required: "Šis laukas yra privalomas.",
        size: "Šio lauko dydis turi būti {0}.",
        string: "Šis laukas turi būti tekstinis.",
        url: "Šis laukas turi būti URL.",
    },
};
const lt = {
    key: "lt",
    values: {
        accepted: "Šis laukas turi būti priimtas.",
        after: "Šis laukas turi būti po {0}.",
        after_or_equal: "Šis laukas turi būti lygus arba po {0}.",
        alpha: "Šis laukas turi turėti tik abėcėlinius simbolius.",
        alpha_dash: "Šis laukas gali turėti tik alfa-numeric simbolius, brūkšnius ir pabraukimus.",
        alpha_num: "Šis laukas turi būti alfa-numeric.",
        array: "Šis laukas turi būti masyvas.",
        before: "Šis laukas turi būti prieš {0}.",
        before_or_equal: "Šis laukas turi būti lygus arba prieš {0}.",
        between: "Šis laukas turi būti tarp {0} ir {1}.",
        boolean: "Šis laukas turi būti logikos reikšmė.",
        confirmed: "Šio lauko patvirtinimas nesutampa.",
        email: "Šis laukas turi būti el. paštas.",
        date: "Šis laukas neturi tinkamo datos formato.",
        digits: "Šis laukas turi būti {0} skaitmenys.",
        digits_between: "Šis laukas turi būti tarp {0} ir {1} skaitmenų.",
        in: "Pasirinktas laukas yra neteisingas.",
        integer: "Šis laukas turi būti sveikasis skaičius.",
        hex: "Šis laukas turi turėti heksadecimale formatą",
        min: "Šis laukas turi būti bent {0}.",
        max: "Šis laukas negali būti didesnis nei {0}.",
        not_in: "Pasirinktas laukas yra neteisingas.",
        numeric: "Šis laukas turi būti skaičius.",
        required: "Šis laukas yra privalomas.",
        size: "Šio lauko dydis turi būti {0}.",
        string: "Šis laukas turi būti eilutė.",
        url: "Šis laukas turi būti URL.",
    },
};
const lv = {
    key: "lv",
    values: {
        accepted: "Laukam jābūt apstiprinātam.",
        after: "Laukam jābūt pēc {0}.",
        after_or_equal: "Laukam jābūt vienādam vai pēc {0}.",
        alpha: "Laukā drīkst būt tikai alfabēta rakstzīmes.",
        alpha_dash: "Laukā drīkst būt tikai alfa-numeriskas rakstzīmes, kā arī domuzīmes un pasvītras.",
        alpha_num: "Laukam jābūt alfa-numeriskam.",
        array: "Laukam jābūt masīvam.",
        before: "Laukam jābūt pirms {0}.",
        before_or_equal: "Laukam jābūt vienādam vai pirms {0}.",
        between: "Laukam jābūt starp {0} un {1}.",
        boolean: "Laukam jābūt loģiskai vērtībai.",
        confirmed: "Lauka apstiprinājums nesakrīt.",
        email: "Laukam jābūt e-pasta adresei.",
        date: "Lauks nav derīgā datuma formātā.",
        digits: "Laukam jābūt {0} cipariem.",
        digits_between: "Laukam jābūt starp {0} un {1} cipariem.",
        in: "Atlasītais lauks nav derīgs.",
        integer: "Laukam jābūt veselam skaitlim.",
        hex: "Laukam jābūt heksadecimālā formātā",
        min: "Laukam jābūt vismaz {0}.",
        max: "Lauks nedrīkst būt lielāks par {0}.",
        not_in: "Atlasītais lauks nav derīgs.",
        numeric: "Laukam jābūt skaitlim.",
        required: "Lauks ir obligāts.",
        size: "Lauka izmēram jābūt {0}.",
        string: "Laukam jābūt virknei.",
        url: "Laukam jābūt URL.",
    },
};
const mk = {
    key: "mk",
    values: {
        accepted: "Полето мора да биде прифатено.",
        after: "Полето мора да биде по-касно од {0}.",
        after_or_equal: "Полето мора да биде еднакво или по-касно од {0}.",
        alpha: "Полето мора да содржи само алфабетни знаци.",
        alpha_dash: "Полето може да содржи само алфанумерички знаци, како и црти и доцници.",
        alpha_num: "Полето мора да биде алфанумеричко.",
        array: "Полето мора да биде низа.",
        before: "Полето мора да биде пред {0}.",
        before_or_equal: "Полето мора да биде еднакво или пред {0}.",
        between: "Полето мора да биде помеѓу {0} и {1}.",
        boolean: "Полето мора да биде булевска вредност.",
        confirmed: "Потврдата на полето не се совпаѓа.",
        email: "Полето мора да биде е-пошта.",
        date: "Полето не е валиден формат на датум.",
        digits: "Полето мора да има {0} цифри.",
        digits_between: "Полето мора да има помеѓу {0} и {1} цифри.",
        in: "Избраното поле не е валидно.",
        integer: "Полето мора да биде цел број.",
        hex: "Полето мора да има хексадецимален формат.",
        min: "Полето мора да биде најмалку {0}.",
        max: "Полето не може да биде поголемо од {0}.",
        not_in: "Избраното поле не е валидно.",
        numeric: "Полето мора да биде број.",
        required: "Полето е задолжително.",
        size: "Големината на полето мора да биде {0}.",
        string: "Полето мора да биде текст.",
        url: "Полето мора да биде URL.",
    },
};
const mn = {
    key: "mn",
    values: {
        accepted: "Талбайг зөвшөөрч байх шаардлагатай.",
        after: "Талбайн утга {0}-с хойш байх шаардлагатай.",
        after_or_equal: "Талбайн утга {0} эсвэл түүнээс хойш байх шаардлагатай.",
        alpha: "Талбайн утга зөвхөн цагаан үсэг агуулсан байх шаардлагатай.",
        alpha_dash: "Талбайн утга зөвхөн цагаан үсэг, тоо, дэлгэц, зураас орсон байх шаардлагатай.",
        alpha_num: "Талбайн утга цагаан үсэг болон тоо агуулсан байх шаардлагатай.",
        array: "Талбайн утга массив байх шаардлагатай.",
        before: "Талбайн утга {0}-с өмнө байх шаардлагатай.",
        before_or_equal: "Талбайн утга {0} эсвэл түүнээс өмнө байх шаардлагатай.",
        between: "Талбайн утга {0} ба {1} хооронд байх шаардлагатай.",
        boolean: "Талбайн утга булан утга байх шаардлагатай.",
        confirmed: "Талбайн баталгаажуулалт таарахгүй байна.",
        email: "Талбайн утга и-мэйл хаяг байх шаардлагатай.",
        date: "Талбайн утга буруу огноо байна.",
        digits: "Талбайн утга {0} тоо байх шаардлагатай.",
        digits_between: "Талбайн утга {0} ба {1} тоо хооронд байх шаардлагатай.",
        in: "Сонгосон талбайн утга буруу байна.",
        integer: "Талбайн утга бүхэл тоо байх шаардлагатай.",
        hex: "Талбайн утга 16-тын тооны системт байх шаардлагатай.",
        min: "Талбайн утга хамгийн багадаа {0} байх шаардлагатай.",
        max: "Талбайн утга хамгийн ихдээ {0}-с их байх шаардлагатай.",
        not_in: "Сонгосон талбайн утга буруу байна.",
        numeric: "Талбайн утга тоо байх шаардлагатай.",
        required: "Талбайн утга шаардлагатай.",
        size: "Талбайн утгын хэмжээ {0} байх шаардлагатай.",
        string: "Талбайн утга тэмдэгт мөр байх шаардлагатай.",
        url: "Талбайн утга веб хаяг байх шаардлагатай.",
    },
};
const ms = {
    key: "ms",
    values: {
        accepted: "Medan ini mesti diterima.",
        after: "Medan ini mesti selepas {0}.",
        after_or_equal: "Medan ini mesti sama atau selepas {0}.",
        alpha: "Medan ini mesti mengandungi hanya aksara abjad.",
        alpha_dash: "Medan ini hanya boleh mengandungi aksara alfa-numerik, tanda hubung, dan garis bawah.",
        alpha_num: "Medan ini mesti alfa-numerik.",
        array: "Medan ini mesti sebuah array.",
        before: "Medan ini mesti sebelum {0}.",
        before_or_equal: "Medan ini mesti sama atau sebelum {0}.",
        between: "Medan ini mesti antara {0} dan {1}.",
        boolean: "Medan ini mesti nilai boolean.",
        confirmed: "Pengesahan medan ini tidak sepadan.",
        email: "Medan ini mesti alamat emel.",
        date: "Medan ini bukan format tarikh yang sah.",
        digits: "Medan ini mesti {0} digit.",
        digits_between: "Medan ini mesti antara {0} dan {1} digit.",
        in: "Pilihan medan ini tidak sah.",
        integer: "Medan ini mesti nombor integer.",
        hex: "Medan ini patut mempunyai format heksadesimal",
        min: "Medan ini mesti sekurang-kurangnya {0}.",
        max: "Medan ini tidak boleh lebih besar daripada {0}.",
        not_in: "Pilihan medan ini tidak sah.",
        numeric: "Medan ini mesti nombor.",
        required: "Medan ini diperlukan.",
        size: "Saiz medan ini mesti {0}.",
        string: "Medan ini mesti rentetan.",
        url: "Medan ini mesti URL.",
    },
};
const nl = {
    key: "nl",
    values: {
        accepted: "Het veld moet worden geaccepteerd.",
        after: "Het veld moet na {0} zijn.",
        after_or_equal: "Het veld moet gelijk zijn aan of na {0} zijn.",
        alpha: "Het veld mag alleen alfabetische tekens bevatten.",
        alpha_dash: "Het veld mag alleen alfanumerieke tekens, evenals streepjes en underscores, bevatten.",
        alpha_num: "Het veld moet alfanumeriek zijn.",
        array: "Het veld moet een array zijn.",
        before: "Het veld moet voor {0} zijn.",
        before_or_equal: "Het veld moet gelijk zijn aan of voor {0} zijn.",
        between: "Het veld moet tussen {0} en {1} zijn.",
        boolean: "Het veld moet een booleaanse waarde zijn.",
        confirmed: "De bevestiging van het veld komt niet overeen.",
        email: "Het veld moet een e-mail zijn.",
        date: "Het veld heeft geen geldig datumformaat.",
        digits: "Het veld moet {0} cijfers bevatten.",
        digits_between: "Het veld moet tussen {0} en {1} cijfers bevatten.",
        in: "De geselecteerde waarde is ongeldig.",
        integer: "Het veld moet een geheel getal zijn.",
        hex: "Het veld moet een hexadecimaal formaat hebben.",
        min: "Het veld moet minimaal {0} zijn.",
        max: "Het veld mag niet groter zijn dan {0}.",
        not_in: "De geselecteerde waarde is ongeldig.",
        numeric: "Het veld moet een getal zijn.",
        required: "Het veld is verplicht.",
        size: "De grootte van het veld moet {0} zijn.",
        string: "Het veld moet een tekst zijn.",
        url: "Het veld moet een URL zijn.",
    },
};
const no = {
    key: "no",
    values: {
        accepted: "Feltet må godtas.",
        after: "Feltet må være etter {0}.",
        after_or_equal: "Feltet må være lik eller etter {0}.",
        alpha: "Feltet må kun inneholde alfabetiske tegn.",
        alpha_dash: "Feltet kan kun inneholde alfanumeriske tegn, samt bindestreker og understreker.",
        alpha_num: "Feltet må være alfanumerisk.",
        array: "Feltet må være en array.",
        before: "Feltet må være før {0}.",
        before_or_equal: "Feltet må være lik eller før {0}.",
        between: "Feltet må være mellom {0} og {1}.",
        boolean: "Feltet må være en boolsk verdi.",
        confirmed: "Bekreftelsen stemmer ikke overens med feltet.",
        email: "Feltet må være en e-postadresse.",
        date: "Feltet har ikke riktig datoformat.",
        digits: "Feltet må være på {0} siffer.",
        digits_between: "Feltet må være mellom {0} og {1} siffer.",
        in: "Den valgte verdien er ugyldig.",
        integer: "Feltet må være et heltall.",
        hex: "Feltet bør ha heksadesimalt format.",
        min: "Feltet må være minst {0}.",
        max: "Feltet kan ikke være større enn {0}.",
        not_in: "Den valgte verdien er ugyldig.",
        numeric: "Feltet må være et tall.",
        required: "Feltet er påkrevd.",
        size: "Feltets størrelse må være {0}.",
        string: "Feltet må være en streng.",
        url: "Feltet må være en URL.",
    },
};
const pl = {
    key: "pl",
    values: {
        accepted: "To pole musi być zaakceptowane.",
        after: "To pole musi być po {0}.",
        after_or_equal: "To pole musi być równe lub po {0}.",
        alpha: "To pole może zawierać tylko znaki alfabetu.",
        alpha_dash: "To pole może zawierać tylko znaki alfanumeryczne, myślniki i podkreślenia.",
        alpha_num: "To pole musi być alfanumeryczne.",
        array: "To pole musi być tablicą.",
        before: "To pole musi być przed {0}.",
        before_or_equal: "To pole musi być równe lub przed {0}.",
        between: "To pole musi być między {0} a {1}.",
        boolean: "To pole musi być wartością logiczną.",
        confirmed: "Potwierdzenie pola nie pasuje.",
        email: "To pole musi być adresem e-mail.",
        date: "To pole nie jest poprawnym formatem daty.",
        digits: "To pole musi mieć {0} cyfr.",
        digits_between: "To pole musi mieć między {0} a {1} cyfr.",
        in: "Wybrana wartość pola jest nieprawidłowa.",
        integer: "To pole musi być liczbą całkowitą.",
        hex: "To pole powinno mieć format szesnastkowy",
        min: "To pole musi mieć co najmniej {0}.",
        max: "To pole nie może być większe niż {0}.",
        not_in: "Wybrana wartość pola jest nieprawidłowa.",
        numeric: "To pole musi być liczbą.",
        required: "To pole jest wymagane.",
        size: "Rozmiar pola musi wynosić {0}.",
        string: "To pole musi być ciągiem znaków.",
        url: "To pole musi być adresem URL.",
    },
};
const pt = {
    key: "pt",
    values: {
        accepted: "O campo deve ser aceito.",
        after: "O campo deve ser depois de {0}.",
        after_or_equal: "O campo deve ser igual ou depois de {0}.",
        alpha: "O campo deve conter apenas caracteres alfabéticos.",
        alpha_dash: "O campo pode conter apenas caracteres alfanuméricos, traços e underscores.",
        alpha_num: "O campo deve ser alfanumérico.",
        array: "O campo deve ser um array.",
        before: "O campo deve ser antes de {0}.",
        before_or_equal: "O campo deve ser igual ou antes de {0}.",
        between: "O campo deve estar entre {0} e {1}.",
        boolean: "O campo deve ser um valor booleano.",
        confirmed: "A confirmação do campo não corresponde.",
        email: "O campo deve ser um email.",
        date: "O campo não está em um formato de data válido.",
        digits: "O campo deve ter {0} dígitos.",
        digits_between: "O campo deve ter entre {0} e {1} dígitos.",
        in: "O campo selecionado é inválido.",
        integer: "O campo deve ser um número inteiro.",
        hex: "O campo deve ter formato hexadecimal.",
        min: "O campo deve ser no mínimo {0}.",
        max: "O campo não pode ser maior que {0}.",
        not_in: "O campo selecionado é inválido.",
        numeric: "O campo deve ser um número.",
        required: "O campo é obrigatório.",
        size: "O tamanho do campo deve ser {0}.",
        string: "O campo deve ser uma string.",
        url: "O campo deve ser uma URL.",
    },
};
const ro = {
    key: "ro",
    values: {
        accepted: "Câmpul trebuie să fie acceptat.",
        after: "Câmpul trebuie să fie după {0}.",
        after_or_equal: "Câmpul trebuie să fie egal sau după {0}.",
        alpha: "Câmpul trebuie să conțină doar caractere alfabetice.",
        alpha_dash: "Câmpul poate conține doar caractere alfanumerice, precum și liniuțe și sublinieri.",
        alpha_num: "Câmpul trebuie să fie alfanumeric.",
        array: "Câmpul trebuie să fie un array.",
        before: "Câmpul trebuie să fie înainte de {0}.",
        before_or_equal: "Câmpul trebuie să fie egal sau înainte de {0}.",
        between: "Câmpul trebuie să fie între {0} și {1}.",
        boolean: "Câmpul trebuie să fie o valoare booleană.",
        confirmed: "Confirmarea câmpului nu se potrivește.",
        email: "Câmpul trebuie să fie o adresă de email.",
        date: "Câmpul nu are un format de dată valid.",
        digits: "Câmpul trebuie să aibă {0} cifre.",
        digits_between: "Câmpul trebuie să aibă între {0} și {1} cifre.",
        in: "Câmpul selectat nu este valid.",
        integer: "Câmpul trebuie să fie un număr întreg.",
        hex: "Câmpul trebuie să aibă format hexazecimal.",
        min: "Câmpul trebuie să aibă cel puțin {0}.",
        max: "Câmpul nu poate fi mai mare de {0}.",
        not_in: "Câmpul selectat nu este valid.",
        numeric: "Câmpul trebuie să fie un număr.",
        required: "Câmpul este obligatoriu.",
        size: "Dimensiunea câmpului trebuie să fie {0}.",
        string: "Câmpul trebuie să fie un șir de caractere.",
        url: "Câmpul trebuie să fie un URL.",
    },
};
const ru = {
    key: "ru",
    values: {
        accepted: "Поле должно быть принято.",
        after: "Поле должно быть после {0}.",
        after_or_equal: "Поле должно быть равным или после {0}.",
        alpha: "Поле должно содержать только буквенные символы.",
        alpha_dash: "Поле может содержать только буквенно-цифровые символы, а также тире и подчеркивания.",
        alpha_num: "Поле должно быть буквенно-цифровым.",
        array: "Поле должно быть массивом.",
        before: "Поле должно быть до {0}.",
        before_or_equal: "Поле должно быть равным или до {0}.",
        between: "Поле должно быть между {0} и {1}.",
        boolean: "Поле должно быть логическим значением.",
        confirmed: "Поле подтверждения не совпадает.",
        email: "Поле должно быть адресом электронной почты.",
        date: "Поле имеет недопустимый формат даты.",
        digits: "Поле должно содержать {0} цифр.",
        digits_between: "Поле должно содержать от {0} до {1} цифр.",
        in: "Выбранное поле недопустимо.",
        integer: "Поле должно быть целым числом.",
        hex: "Поле должно иметь шестнадцатеричный формат.",
        min: "Поле должно быть не менее {0}.",
        max: "Поле не должно быть больше {0}.",
        not_in: "Выбранное поле недопустимо.",
        numeric: "Поле должно быть числовым.",
        required: "Поле обязательно для заполнения.",
        size: "Размер поля должен быть {0}.",
        string: "Поле должно быть строкой.",
        url: "Поле должно быть URL-адресом.",
    },
};
const se = {
    key: "se",
    values: {
        accepted: "Fältet måste accepteras.",
        after: "Fältet måste vara efter {0}.",
        after_or_equal: "Fältet måste vara lika med eller efter {0}.",
        alpha: "Fältet får endast innehålla alfabetiska tecken.",
        alpha_dash: "Fältet får endast innehålla alfanumeriska tecken samt bindestreck och understreck.",
        alpha_num: "Fältet måste vara alfanumeriskt.",
        array: "Fältet måste vara en array.",
        before: "Fältet måste vara före {0}.",
        before_or_equal: "Fältet måste vara lika med eller före {0}.",
        between: "Fältet måste vara mellan {0} och {1}.",
        boolean: "Fältet måste vara ett booleskt värde.",
        confirmed: "Bekräftelsen matchar inte fältet.",
        email: "Fältet måste vara en e-postadress.",
        date: "Fältet har inte ett giltigt datumformat.",
        digits: "Fältet måste vara {0} siffror.",
        digits_between: "Fältet måste vara mellan {0} och {1} siffror.",
        in: "Det valda fältet är ogiltigt.",
        integer: "Fältet måste vara ett heltal.",
        hex: "Fältet bör ha ett hexadecimalt format",
        min: "Fältet måste vara minst {0}.",
        max: "Fältet får inte vara större än {0}.",
        not_in: "Det valda fältet är ogiltigt.",
        numeric: "Fältet måste vara ett nummer.",
        required: "Fältet är obligatoriskt.",
        size: "Fältets storlek måste vara {0}.",
        string: "Fältet måste vara en sträng.",
        url: "Fältet måste vara en URL.",
    },
};
const sl = {
    key: "sl",
    values: {
        accepted: "Polje mora biti sprejeto.",
        after: "Polje mora biti po {0}.",
        after_or_equal: "Polje mora biti enako ali po {0}.",
        alpha: "Polje sme vsebovati le črke.",
        alpha_dash: "Polje sme vsebovati le alfa-numerične znake, črtice in podčrtaje.",
        alpha_num: "Polje mora biti alfa-numerično.",
        array: "Polje mora biti seznam.",
        before: "Polje mora biti pred {0}.",
        before_or_equal: "Polje mora biti enako ali pred {0}.",
        between: "Polje mora biti med {0} in {1}.",
        boolean: "Polje mora biti logična vrednost.",
        confirmed: "Potrditev polja se ne ujema.",
        email: "Polje mora biti e-poštni naslov.",
        date: "Polje ni v veljavnem datumskem formatu.",
        digits: "Polje mora imeti {0} števk.",
        digits_between: "Polje mora imeti med {0} in {1} števk.",
        in: "Izbrano polje ni veljavno.",
        integer: "Polje mora biti celo število.",
        hex: "Polje mora imeti heksadecimalni format",
        min: "Polje mora biti vsaj {0}.",
        max: "Polje ne sme biti večje od {0}.",
        not_in: "Izbrano polje ni veljavno.",
        numeric: "Polje mora biti število.",
        required: "Polje je obvezno.",
        size: "Velikost polja mora biti {0}.",
        string: "Polje mora biti besedilo.",
        url: "Polje mora biti URL.",
    },
};
const sq = {
    key: "sq",
    values: {
        accepted: "Fusha duhet të pranohet.",
        after: "Fusha duhet të jetë pas {0}.",
        after_or_equal: "Fusha duhet të jetë e njëjtë ose pas {0}.",
        alpha: "Fusha duhet të përmbajë vetëm karaktere alfabetike.",
        alpha_dash: "Fusha mund të përmbajë vetëm karaktere alfanumerike, si dhe vijat dhe nënvijat.",
        alpha_num: "Fusha duhet të jetë alfanumerike.",
        array: "Fusha duhet të jetë një varg.",
        before: "Fusha duhet të jetë para {0}.",
        before_or_equal: "Fusha duhet të jetë e njëjtë ose para {0}.",
        between: "Fusha duhet të jetë në mes {0} dhe {1}.",
        boolean: "Fusha duhet të jetë një vlerë boolean.",
        confirmed: "Konfirmimi i fushës nuk përputhet.",
        email: "Fusha duhet të jetë një email.",
        date: "Fusha nuk është në formatin e vlefshëm të datës.",
        digits: "Fusha duhet të jetë {0} shifra.",
        digits_between: "Fusha duhet të jetë në mes {0} dhe {1} shifrash.",
        in: "Fusha e zgjedhur është e pavlefshme.",
        integer: "Fusha duhet të jetë një numër i plotë.",
        hex: "Fusha duhet të ketë format heksadecimal",
        min: "Fusha duhet të jetë të paktën {0}.",
        max: "Fusha nuk mund të jetë më e madhe se {0}.",
        not_in: "Fusha e zgjedhur është e pavlefshme.",
        numeric: "Fusha duhet të jetë një numër.",
        required: "Fusha është e detyrueshme.",
        size: "Madhësia e fushës duhet të jetë {0}.",
        string: "Fusha duhet të jetë një varg.",
        url: "Fusha duhet të jetë një URL.",
    },
};
const sr = {
    key: "sr",
    values: {
        accepted: "Polje mora biti prihvaćeno.",
        after: "Polje mora biti posle {0}.",
        after_or_equal: "Polje mora biti jednako ili posle {0}.",
        alpha: "Polje mora sadržavati samo alfabetske karaktere.",
        alpha_dash: "Polje može sadržavati samo alfa-numeričke karaktere, kao i crte i donje crte.",
        alpha_num: "Polje mora biti alfanumeričko.",
        array: "Polje mora biti niz.",
        before: "Polje mora biti pre {0}.",
        before_or_equal: "Polje mora biti jednako ili pre {0}.",
        between: "Polje mora biti između {0} i {1}.",
        boolean: "Polje mora biti boolean vrednost.",
        confirmed: "Potvrda polja se ne poklapa.",
        email: "Polje mora biti email adresa.",
        date: "Polje nije u validnom formatu datuma.",
        digits: "Polje mora imati {0} cifara.",
        digits_between: "Polje mora biti između {0} i {1} cifara.",
        in: "Izabrano polje nije validno.",
        integer: "Polje mora biti ceo broj.",
        hex: "Polje mora imati heksadecimalni format.",
        min: "Polje mora biti najmanje {0}.",
        max: "Polje ne sme biti veće od {0}.",
        not_in: "Izabrano polje nije validno.",
        numeric: "Polje mora biti broj.",
        required: "Polje je obavezno.",
        size: "Veličina polja mora biti {0}.",
        string: "Polje mora biti string.",
        url: "Polje mora biti URL adresa.",
    },
};
const sv = {
    key: "sv",
    values: {
        accepted: "Fältet måste vara godkänt.",
        after: "Fältet måste vara efter {0}.",
        after_or_equal: "Fältet måste vara lika med eller efter {0}.",
        alpha: "Fältet får endast innehålla alfabetiska tecken.",
        alpha_dash: "Fältet får endast innehålla alfanumeriska tecken samt bindestreck och understreck.",
        alpha_num: "Fältet måste vara alfanumeriskt.",
        array: "Fältet måste vara en array.",
        before: "Fältet måste vara före {0}.",
        before_or_equal: "Fältet måste vara lika med eller före {0}.",
        between: "Fältet måste vara mellan {0} och {1}.",
        boolean: "Fältet måste vara ett booleskt värde.",
        confirmed: "Fältets bekräftelse matchar inte.",
        email: "Fältet måste vara en e-postadress.",
        date: "Fältet har inte ett giltigt datumformat.",
        digits: "Fältet måste vara {0} siffror.",
        digits_between: "Fältet måste vara mellan {0} och {1} siffror.",
        in: "Det valda fältet är ogiltigt.",
        integer: "Fältet måste vara ett heltal.",
        hex: "Fältet måste ha hexadecimalt format.",
        min: "Fältet måste vara minst {0}.",
        max: "Fältet får inte vara större än {0}.",
        not_in: "Det valda fältet är ogiltigt.",
        numeric: "Fältet måste vara ett nummer.",
        required: "Fältet är obligatoriskt.",
        size: "Fältets storlek måste vara {0}.",
        string: "Fältet måste vara en sträng.",
        url: "Fältet måste vara en URL.",
    },
};
const tr = {
    key: "tr",
    values: {
        accepted: "Alan kabul edilmelidir.",
        after: "Alan {0}'dan sonra olmalıdır.",
        after_or_equal: "Alan, {0}'dan eşit veya sonra olmalıdır.",
        alpha: "Alan sadece alfabetik karakterler içermelidir.",
        alpha_dash: "Alan yalnızca alfa-nümerik karakterler, tireler ve alt çizgiler içerebilir.",
        alpha_num: "Alan alfanümerik olmalıdır.",
        array: "Alan bir dizi olmalıdır.",
        before: "Alan {0}'dan önce olmalıdır.",
        before_or_equal: "Alan, {0}'dan eşit veya önce olmalıdır.",
        between: "Alan {0} ile {1} arasında olmalıdır.",
        boolean: "Alan bir mantıksal değer olmalıdır.",
        confirmed: "Alan doğrulama eşleşmiyor.",
        email: "Alan bir e-posta olmalıdır.",
        date: "Alan geçerli bir tarih formatında değil.",
        digits: "Alan {0} basamaklı olmalıdır.",
        digits_between: "Alan {0} ile {1} arasında basamaklı olmalıdır.",
        in: "Seçilen alan geçersiz.",
        integer: "Alan bir tam sayı olmalıdır.",
        hex: "Alan onaltılık bir formatta olmalıdır",
        min: "Alan en az {0} olmalıdır.",
        max: "Alan {0}'den büyük olmamalıdır.",
        not_in: "Seçilen alan geçersiz.",
        numeric: "Alan bir sayı olmalıdır.",
        required: "Alan gereklidir.",
        size: "Alanın boyutu {0} olmalıdır.",
        string: "Alan bir dize olmalıdır.",
        url: "Alan bir URL olmalıdır.",
    },
};
const uk = {
    key: "uk",
    values: {
        accepted: "Поле повинно бути прийнято.",
        after: "Поле повинно бути після {0}.",
        after_or_equal: "Поле повинно бути рівне або після {0}.",
        alpha: "Поле повинно містити лише буквенні символи.",
        alpha_dash: "Поле може містити лише буквено-цифрові символи, а також дефіси та підкреслення.",
        alpha_num: "Поле повинно бути буквено-цифровим.",
        array: "Поле повинно бути масивом.",
        before: "Поле повинно бути до {0}.",
        before_or_equal: "Поле повинно бути рівне або до {0}.",
        between: "Поле повинно бути від {0} до {1}.",
        boolean: "Поле повинно бути логічним значенням.",
        confirmed: "Поле підтвердження не відповідає.",
        email: "Поле повинно бути електронною поштою.",
        date: "Поле має невірний формат дати.",
        digits: "Поле повинно бути {0} цифр.",
        digits_between: "Поле повинно бути від {0} до {1} цифр.",
        in: "Вибране поле недійсне.",
        integer: "Поле повинно бути цілим числом.",
        hex: "Поле повинно мати шістнадцятковий формат.",
        min: "Поле повинно бути не менше {0}.",
        max: "Поле не може бути більше {0}.",
        not_in: "Вибране поле недійсне.",
        numeric: "Поле повинно бути числом.",
        required: "Поле обов'язкове.",
        size: "Розмір поля повинен бути {0}.",
        string: "Поле повинно бути рядком.",
        url: "Поле повинно бути URL-адресою.",
    },
};
const vi = {
    key: "vi",
    values: {
        accepted: "Trường phải được chấp nhận.",
        after: "Trường phải sau ngày {0}.",
        after_or_equal: "Trường phải bằng hoặc sau ngày {0}.",
        alpha: "Trường chỉ có thể chứa các ký tự chữ cái.",
        alpha_dash: "Trường chỉ có thể chứa các ký tự chữ cái, số, dấu gạch ngang và gạch dưới.",
        alpha_num: "Trường phải là chuỗi chữ số và chữ cái.",
        array: "Trường phải là một mảng.",
        before: "Trường phải trước ngày {0}.",
        before_or_equal: "Trường phải bằng hoặc trước ngày {0}.",
        between: "Trường phải nằm trong khoảng {0} đến {1}.",
        boolean: "Trường phải là giá trị boolean.",
        confirmed: "Giá trị xác nhận không khớp.",
        email: "Trường phải là địa chỉ email.",
        date: "Trường không phải là định dạng ngày tháng hợp lệ.",
        digits: "Trường phải có {0} chữ số.",
        digits_between: "Trường phải có từ {0} đến {1} chữ số.",
        in: "Giá trị đã chọn không hợp lệ.",
        integer: "Trường phải là số nguyên.",
        hex: "Trường phải có định dạng số hexa.",
        min: "Trường phải ít nhất là {0}.",
        max: "Trường không được lớn hơn {0}.",
        not_in: "Giá trị đã chọn không hợp lệ.",
        numeric: "Trường phải là một số.",
        required: "Trường là bắt buộc.",
        size: "Kích thước của trường phải là {0}.",
        string: "Trường phải là một chuỗi.",
        url: "Trường phải là một địa chỉ URL.",
    },
};
const zh = {
    key: "zh",
    values: {
        accepted: "该字段必须被接受。",
        after: "该字段必须在 {0} 之后。",
        after_or_equal: "该字段必须等于或在 {0} 之后。",
        alpha: "该字段必须只包含字母字符。",
        alpha_dash: "该字段只能包含字母数字字符，破折号和下划线。",
        alpha_num: "该字段必须是字母数字。",
        array: "该字段必须是数组。",
        before: "该字段必须在 {0} 之前。",
        before_or_equal: "该字段必须等于或在 {0} 之前。",
        between: "该字段必须在 {0} 和 {1} 之间。",
        boolean: "该字段必须是布尔值。",
        confirmed: "该字段的确认值不匹配。",
        email: "该字段必须是电子邮件。",
        date: "该字段不是有效的日期格式。",
        digits: "该字段必须是 {0} 位数字。",
        digits_between: "该字段必须在 {0} 和 {1} 位数字之间。",
        in: "所选字段无效。",
        integer: "该字段必须是整数。",
        hex: "该字段应具有十六进制格式。",
        min: "该字段必须至少为 {0}。",
        max: "该字段不能大于 {0}。",
        not_in: "所选字段无效。",
        numeric: "该字段必须是数字。",
        required: "该字段是必需的。",
        size: "该字段的大小必须为 {0}。",
        string: "该字段必须是字符串。",
        url: "该字段必须是URL。",
    },
};

exports.DEFINED_RULES = DEFINED_RULES;
exports.RULE_FUNCTION_MAPS = RULE_FUNCTION_MAPS;
exports.accepted = accepted;
exports.addCustomLocale = addCustomLocale;
exports.after = after;
exports.afterOrEqual = afterOrEqual;
exports.alpha = alpha;
exports.alphaDash = alphaDash;
exports.alphaNum = alphaNum;
exports.ar = ar;
exports.array = array;
exports.az = az;
exports.be = be;
exports.before = before;
exports.beforeOrEqual = beforeOrEqual;
exports.between = between;
exports.bg = bg;
exports.boolean = boolean;
exports.bs = bs;
exports.ca = ca;
exports.confirmed = confirmed;
exports.cs = cs;
exports.cy = cy;
exports.da = da;
exports.date = date;
exports.de = de;
exports.digits = digits;
exports.digitsBetween = digitsBetween;
exports.el = el;
exports.email = email;
exports.en = en;
exports.es = es;
exports.et = et;
exports.eu = eu;
exports.fa = fa;
exports.fi = fi;
exports.fr = fr;
exports.getLoadedLocales = getLoadedLocales;
exports.getMessage = getMessage;
exports.getOptions = getOptions;
exports.hex = hex;
exports.hr = hr;
exports.hu = hu;
exports.id = id;
exports.inConverter = _in;
exports.integer = integer;
exports.isAccepted = isAccepted;
exports.isAfter = isAfter;
exports.isAfterOrEqual = isAfterOrEqual;
exports.isAlpha = isAlpha;
exports.isAlphaDash = isAlphaDash;
exports.isAlphaNum = isAlphaNum;
exports.isArray = isArray;
exports.isBefore = isBefore;
exports.isBeforeOrEqual = isBeforeOrEqual;
exports.isBetween = isBetween;
exports.isBoolean = isBoolean;
exports.isConfirmed = isConfirmed;
exports.isDate = isDate;
exports.isDigits = isDigits;
exports.isDigitsBetween = isDigitsBetween;
exports.isEmail = isEmail;
exports.isHex = isHex;
exports.isIn = isIn;
exports.isInteger = isInteger;
exports.isMax = isMax;
exports.isMin = isMin;
exports.isNotIn = isNotIn;
exports.isNumeric = isNumeric;
exports.isRegistered = isRegistered;
exports.isRequired = isRequired;
exports.isSize = isSize;
exports.isString = isString;
exports.isUrl = isUrl;
exports.it = it;
exports.ja = ja;
exports.ka = ka;
exports.ko = ko;
exports.li = li;
exports.lt = lt;
exports.lv = lv;
exports.max = max;
exports.min = min;
exports.mk = mk;
exports.mn = mn;
exports.ms = ms;
exports.nl = nl;
exports.no = no;
exports.notIn = notIn;
exports.numeric = numeric;
exports.pl = pl;
exports.pt = pt;
exports.register = register;
exports.required = required;
exports.ro = ro;
exports.ru = ru;
exports.se = se;
exports.setLocales = setLocales;
exports.setOptions = setOptions;
exports.size = size;
exports.sl = sl;
exports.sq = sq;
exports.sr = sr;
exports.string = string;
exports.sv = sv;
exports.tr = tr;
exports.uk = uk;
exports.url = url;
exports.validate = validate;
exports.vi = vi;
exports.zh = zh;