nox-validation/lib/constant.js

validate dynamic schema

const dataTypes = Object.freeze({
  STRING: "String",
  ARRAY: "Array",
  OBJECT: "Object",
  INT: "Int",
  BINARY: "Binary",
  BOOLEAN: "Boolean",
  CODE: "Code",
  DATE: "Date",
  DECIMAL128: "Decimal128",
  DOUBLE: "Double",
  INT32: "Int32",
  INT64: "Int64",
  MAX_KEY: "MaxKey",
  MIN_KEY: "MinKey",
  NULL: "Null",
  OBJECT_ID: "ObjectId",
  BSON_REGEXP: "BSONRegExp",
  BSON_SYMBOL: "BSONSymbol",
  TIMESTAMP: "Timestamp",
  UNDEFINED: "Undefined",
  BIGINT: "BigInt",
  SYMBOL: "Symbol",
});

const operatorTypes = Object.freeze({
  AND: "$and",
  OR: "$or",
  EQUAL: "$eq",
  NOT_EQUAL: "$ne",
  LESS_THAN: "$lt",
  LESS_THAN_EQUAL: "$lte",
  GREATER_THAN: "$gt",
  GREATER_THAN_EQUAL: "$gte",
  IN: "$in",
  NOT_IN: "$nin",
  EXISTS: "$exists",
  TYPE: "$type",
  MOD: "$mod",
  ALL: "$all",
  SIZE: "$size",
});

const rulesTypes = Object.freeze({
  EMPTY: "empty",
  NOT_EMPTY: "not_empty",
  ONE_OF: "one_of",
  NOT_ONE_OF: "not_one_of",
  NOT_ALLOWED: "not_allow",
  REGEX: "regex",
  MIN: "min_length",
  MAX: "max_length",
  OPERATOR: "Operator",
  FIELD_COMPARE: "field_compare",
  RULES_COMPARE: "rules_compare",
});

const rulesMessages = Object.freeze({
  EMPTY: `{field} should be empty.`,
  NOT_EMPTY: `{field} should not be empty.`,
  ONE_OF: `{field} should be one of the following: {value}.`,
  NOT_ONE_OF: `{field} should not be one of the following: {value}.`,
  REQUIRED: `{field} is required.`,
  OPTIONAL: `{field} is optional.`,
  NOT_NULLABLE: `{field} can not be null.`,
  INVALID_TYPE: "{field} contains invalid input type. Only {type} is allowed.",
  NOT_ALLOWED_FIELD: `{field} is not allowed.`,
  COMPARE: `{field} does not match the expected value.`,
  RULES_COMPARE: `{field} does not meet the comparison rules.`,
  ALLOW: `{field} contains allowed characters only.`,
  NOT_ALLOWED: `{field} contains disallowed characters.`,
  REGEX_MATCH: `{field} format is invalid.`,
  REGEX_START_WITH: `{field} should start with {value}.`,
  REGEX_ENDS_WITH: `{field} should end with {value}.`,
  REGEX_CONTAINS: `{field} should contain {value}.`,
  REGEX_EXACT: `{field} should be exactly {value}.`,
  REGEX_NOT_START_WITH: `{field} should not be start with {value}.`,
  REGEX_NOT_ENDS_WITH: `{field} should not be ends with {value}.`,
  REGEX_NOT_CONTAINS: `{field} should not contains {value}.`,
  MIN_STRING: `{field} must be at least {min} characters long.`,
  MAX_STRING: `{field} must be at most {max} characters long.`,
  MIN_NUMBER: `{field} must be at least {min}.`,
  MAX_NUMBER: `{field} must be at most {max}.`,
  AND: "{field} must be any of {value}",
  OR: "{field} must be any of {value}",
  EQUAL: "{field} must be equal to {value}",
  NOT_EQUAL: "{field} must not be equal to {value}",
  LESS_THAN: "{field} must be less than {value}",
  LESS_THAN_EQUAL: "{field} must be less than or equal to {value}",
  GREATER_THAN: "{field} must be greater than {value}",
  GREATER_THAN_EQUAL: "{field} must be greater than or equal to {value}",
  IN: "{field} must be one of the following: {value}",
  NOT_IN: "{field} must not contain any of these values: {value}",
  EXISTS: "{field} must exist",
  TYPE: "{field} must be of type {value}",
  MOD: "{field} must have a remainder of {value[1]} when divided by {value[0]}",
  ALL: "{field} must contain all of the following values: {value}",
  SIZE: "{field} must have a size of {value}",
});

const regexTypes = Object.freeze({
  MATCH: "match",
  START_WITH: "start_with",
  ENDS_WITH: "ends_with",
  CONTAINS: "contains",
  EXACT: "exact",
  NOT_START_WITH: "not_start_with",
  NOT_ENDS_WITH: "not_ends_with",
  NOT_CONTAINS: "not_contains",
});

const fieldTypes = Object.freeze({
  SINGLE: "Single",
  OBJECT: "Object",
  ARRAY: "Array",
});

const types = Object.freeze({
  STRING: "String",
  OBJECT: "Object",
  ARRAY: "Array",
  DATE: "Date",
  NUMBER: "Number",
  ALIAS: "Alias",
  OBJECT_ID: "ObjectId",
  BUFFER: "Buffer",
  BOOLEAN: "Boolean",
  MIXED: "Mixed",
  DATE_TIME: "datetime",
  TIME: "time",
});

const interfaces = Object.freeze({
  TIMESTAMP: "timestamp",
  INPUT: "input",
  MANY_TO_MANY: "list-m2m",
  ONE_TO_MANY: "list-o2m",
  MANY_TO_ONE: "list-m2o",
  MANY_TO_ANY: "list-m2a",
  FILE: "file",
  FILE_IMAGE: "file-image",
  FILES: "files",
  TRANSLATIONS: "translations",
  RELATIONAL: "relational",
});

const API_VERSION = Object.freeze({
  V1: "v1",
  V2: "v2",
});

const API_VERSIONS = Object.freeze(Object.values(API_VERSION));

const LANGUAGES = Object.freeze({
  en: "en",
  nl: "nl",
  lv:"lv",
  pl:"pl",
  ro:"ro",
  ru:"ru",
});

const LOCALE_NL_MESSAGES = Object.freeze({
  ADD_CHOICE: `Voeg minstens één optie toe voor {field}.`, 
  INVALID_VALUE: `{field} bevat een ongeldige waarde.`,
  EMPTY: `{field} moet leeg zijn.`,
  NOT_EMPTY: `{field} mag niet leeg zijn.`,
  ONE_OF: `{field} moet een van de volgende waarden zijn: {value}.`,
  NOT_ONE_OF: `{field} mag niet een van de volgende waarden zijn: {value}.`,
  REQUIRED: `{field} is verplicht.`,
  OPTIONAL: `{field} is optioneel.`,
  NOT_NULLABLE: `{field} mag niet null zijn.`,
  INVALID_TYPE: "{field} bevat een ongeldig invoertype. Alleen {type} is toegestaan.",
  NOT_ALLOWED_FIELD: `{field} is niet toegestaan.`,
  COMPARE: `{field} komt niet overeen met de verwachte waarde.`,
  RULES_COMPARE: `{field} voldoet niet aan de vergelijkingsregels.`,
  ALLOW: `{field} bevat alleen toegestane tekens.`,
  NOT_ALLOWED: `{field} bevat niet-toegestane tekens.`,
  REGEX_MATCH: `{field} heeft een ongeldig formaat.`,
  REGEX_START_WITH: `{field} moet beginnen met {value}.`,
  REGEX_ENDS_WITH: `{field} moet eindigen op {value}.`,
  REGEX_CONTAINS: `{field} moet {value} bevatten.`,
  REGEX_EXACT: `{field} moet exact {value} zijn.`,
  REGEX_NOT_START_WITH: `{field} mag niet beginnen met {value}.`,
  REGEX_NOT_ENDS_WITH: `{field} mag niet eindigen op {value}.`,
  REGEX_NOT_CONTAINS: `{field} mag {value} niet bevatten.`,
  MIN_STRING: `{field} moet minstens {min} tekens lang zijn.`,
  MAX_STRING: `{field} mag maximaal {max} tekens lang zijn.`,
  MIN_NUMBER: `{field} moet minstens {min} zijn.`,
  MAX_NUMBER: `{field} mag maximaal {max} zijn.`,
  AND: "{field} moet een van {value} zijn.",
  OR: "{field} moet een van {value} zijn.",
  EQUAL: "{field} moet gelijk zijn aan {value}.",
  NOT_EQUAL: "{field} mag niet gelijk zijn aan {value}.",
  LESS_THAN: "{field} moet kleiner zijn dan {value}.",
  LESS_THAN_EQUAL: "{field} moet kleiner dan of gelijk zijn aan {value}.",
  GREATER_THAN: "{field} moet groter zijn dan {value}.",
  GREATER_THAN_EQUAL: "{field} moet groter dan of gelijk zijn aan {value}.",
  IN: "{field} moet een van de volgende waarden zijn: {value}.",
  NOT_IN: "{field} mag geen van de volgende waarden bevatten: {value}.",
  EXISTS: "{field} moet bestaan.",
  TYPE: "{field} moet van type {value} zijn.",
  MOD: "{field} moet een restwaarde van {value[1]} hebben wanneer gedeeld door {value[0]}.",
  ALL: "{field} moet alle van de volgende waarden bevatten: {value}.",
  SIZE: "{field} moet een grootte van {value} hebben.",
});

const LOCALE_EN_MESSAGES = Object.freeze({
  ADD_CHOICE:`Please add at least one choice for {field}.`,
  INVALID_VALUE: `{field} contains invalid value.`,
  EMPTY: `{field} should be empty.`,
  NOT_EMPTY: `{field} should not be empty.`,
  ONE_OF: `{field} should be one of the following: {value}.`,
  NOT_ONE_OF: `{field} should not be one of the following: {value}.`,
  REQUIRED: `{field} is required.`,
  OPTIONAL: `{field} is optional.`,
  NOT_NULLABLE: `{field} can not be null.`,
  INVALID_TYPE: "{field} contains invalid input type. Only {type} is allowed.",
  NOT_ALLOWED_FIELD: `{field} is not allowed.`,
  COMPARE: `{field} does not match the expected value.`,
  RULES_COMPARE: `{field} does not meet the comparison rules.`,
  ALLOW: `{field} contains allowed characters only.`,
  NOT_ALLOWED: `{field} contains disallowed characters.`,
  REGEX_MATCH: `{field} format is invalid.`,
  REGEX_START_WITH: `{field} should start with {value}.`,
  REGEX_ENDS_WITH: `{field} should end with {value}.`,
  REGEX_CONTAINS: `{field} should contain {value}.`,
  REGEX_EXACT: `{field} should be exactly {value}.`,
  REGEX_NOT_START_WITH: `{field} should not be start with {value}.`,
  REGEX_NOT_ENDS_WITH: `{field} should not be ends with {value}.`,
  REGEX_NOT_CONTAINS: `{field} should not contains {value}.`,
  MIN_STRING: `{field} must be at least {min} characters long.`,
  MAX_STRING: `{field} must be at most {max} characters long.`,
  MIN_NUMBER: `{field} must be at least {min}.`,
  MAX_NUMBER: `{field} must be at most {max}.`,
  AND: "{field} must be any of {value}",
  OR: "{field} must be any of {value}",
  EQUAL: "{field} must be equal to {value}",
  NOT_EQUAL: "{field} must not be equal to {value}",
  LESS_THAN: "{field} must be less than {value}",
  LESS_THAN_EQUAL: "{field} must be less than or equal to {value}",
  GREATER_THAN: "{field} must be greater than {value}",
  GREATER_THAN_EQUAL: "{field} must be greater than or equal to {value}",
  IN: "{field} must be one of the following: {value}",
  NOT_IN: "{field} must not contain any of these values: {value}",
  EXISTS: "{field} must exist",
  TYPE: "{field} must be of type {value}",
  MOD: "{field} must have a remainder of {value[1]} when divided by {value[0]}",
  ALL: "{field} must contain all of the following values: {value}",
  SIZE: "{field} must have a size of {value}",
});

const LOCALE_LV_MESSAGES = Object.freeze({
  ADD_CHOICE: `Lūdzu, pievienojiet vismaz vienu izvēli laukam {field}.`, 
  INVALID_VALUE: `{field} satur nederīgu vērtību.`,
  EMPTY: `{field} jābūt tukšam.`,
  NOT_EMPTY: `{field} nedrīkst būt tukšs.`,
  ONE_OF: `{field} jābūt vienai no šīm vērtībām: {value}.`,
  NOT_ONE_OF: `{field} nedrīkst būt viena no šīm vērtībām: {value}.`,
  REQUIRED: `{field} ir obligāts.`,
  OPTIONAL: `{field} ir izvēles.`,
  NOT_NULLABLE: `{field} nevar būt null.`,
  INVALID_TYPE: `{field} satur nederīgu ievades tipu. Atļauts tikai {type}.`,
  NOT_ALLOWED_FIELD: `{field} nav atļauts.`,
  COMPARE: `{field} neatbilst paredzētajai vērtībai.`,
  RULES_COMPARE: `{field} neatbilst salīdzināšanas noteikumiem.`,
  ALLOW: `{field} satur tikai atļautās rakstzīmes.`,
  NOT_ALLOWED: `{field} satur neatļautas rakstzīmes.`,
  REGEX_MATCH: `{field} formāts nav derīgs.`,
  REGEX_START_WITH: `{field} jāsākas ar {value}.`,
  REGEX_ENDS_WITH: `{field} jābeidzas ar {value}.`,
  REGEX_CONTAINS: `{field} jāietver {value}.`,
  REGEX_EXACT: `{field} jābūt tieši {value}.`,
  REGEX_NOT_START_WITH: `{field} nedrīkst sākties ar {value}.`,
  REGEX_NOT_ENDS_WITH: `{field} nedrīkst beigties ar {value}.`,
  REGEX_NOT_CONTAINS: `{field} nedrīkst saturēt {value}.`,
  MIN_STRING: `{field} jābūt vismaz {min} rakstzīmes garam.`,
  MAX_STRING: `{field} jābūt ne vairāk kā {max} rakstzīmes garam.`,
  MIN_NUMBER: `{field} jābūt vismaz {min}.`,
  MAX_NUMBER: `{field} jābūt ne vairāk kā {max}.`,
  AND: `{field} jābūt vienai no {value}`,
  OR: `{field} jābūt vienai no {value}`,
  EQUAL: `{field} jābūt vienādam ar {value}`,
  NOT_EQUAL: `{field} nedrīkst būt vienāds ar {value}`,
  LESS_THAN: `{field} jābūt mazākam par {value}`,
  LESS_THAN_EQUAL: `{field} jābūt mazākam vai vienādam ar {value}`,
  GREATER_THAN: `{field} jābūt lielākam par {value}`,
  GREATER_THAN_EQUAL: `{field} jābūt lielākam vai vienādam ar {value}`,
  IN: `{field} jābūt vienai no šīm vērtībām: {value}`,
  NOT_IN: `{field} nedrīkst saturēt kādu no šīm vērtībām: {value}`,
  EXISTS: `{field} ir jāeksistē`,
  TYPE: `{field} jābūt {value} tipam`,
  MOD: `{field} jābūt atlikumam {value[1]} dalot ar {value[0]}`,
  ALL: `{field} jāietver visas šīs vērtības: {value}`,
  SIZE: `{field} izmēram jābūt {value}`,
});

const LOCALE_PL_MESSAGES = Object.freeze({
  ADD_CHOICE: `Proszę dodać co najmniej jedną opcję dla {field}.`,
  INVALID_VALUE: `{field} zawiera nieprawidłową wartość.`,
  EMPTY: `{field} powinno być puste.`,
  NOT_EMPTY: `{field} nie powinno być puste.`,
  ONE_OF: `{field} powinno być jedną z następujących wartości: {value}.`,
  NOT_ONE_OF: `{field} nie powinno być jedną z następujących wartości: {value}.`,
  REQUIRED: `{field} jest wymagane.`,
  OPTIONAL: `{field} jest opcjonalne.`,
  NOT_NULLABLE: `{field} nie może być puste (null).`,
  INVALID_TYPE: `{field} zawiera nieprawidłowy typ. Dozwolony tylko {type}.`,
  NOT_ALLOWED_FIELD: `{field} nie jest dozwolone.`,
  COMPARE: `{field} nie pasuje do oczekiwanej wartości.`,
  RULES_COMPARE: `{field} nie spełnia reguł porównania.`,
  ALLOW: `{field} zawiera tylko dozwolone znaki.`,
  NOT_ALLOWED: `{field} zawiera niedozwolone znaki.`,
  REGEX_MATCH: `Format pola {field} jest nieprawidłowy.`,
  REGEX_START_WITH: `{field} powinno zaczynać się od {value}.`,
  REGEX_ENDS_WITH: `{field} powinno kończyć się na {value}.`,
  REGEX_CONTAINS: `{field} powinno zawierać {value}.`,
  REGEX_EXACT: `{field} powinno być dokładnie równe {value}.`,
  REGEX_NOT_START_WITH: `{field} nie powinno zaczynać się od {value}.`,
  REGEX_NOT_ENDS_WITH: `{field} nie powinno kończyć się na {value}.`,
  REGEX_NOT_CONTAINS: `{field} nie powinno zawierać {value}.`,
  MIN_STRING: `{field} musi mieć co najmniej {min} znaków.`,
  MAX_STRING: `{field} może mieć maksymalnie {max} znaków.`,
  MIN_NUMBER: `{field} musi być co najmniej {min}.`,
  MAX_NUMBER: `{field} może być maksymalnie {max}.`,
  AND: `{field} musi być jedną z wartości: {value}`,
  OR: `{field} musi być jedną z wartości: {value}`,
  EQUAL: `{field} musi być równe {value}`,
  NOT_EQUAL: `{field} nie może być równe {value}`,
  LESS_THAN: `{field} musi być mniejsze niż {value}`,
  LESS_THAN_EQUAL: `{field} musi być mniejsze lub równe {value}`,
  GREATER_THAN: `{field} musi być większe niż {value}`,
  GREATER_THAN_EQUAL: `{field} musi być większe lub równe {value}`,
  IN: `{field} musi być jedną z następujących wartości: {value}`,
  NOT_IN: `{field} nie może zawierać żadnej z następujących wartości: {value}`,
  EXISTS: `{field} musi istnieć`,
  TYPE: `{field} musi być typu {value}`,
  MOD: `{field} musi mieć resztę {value[1]} po podzieleniu przez {value[0]}`,
  ALL: `{field} musi zawierać wszystkie z następujących wartości: {value}`,
  SIZE: `{field} musi mieć rozmiar {value}`,
});

const LOCALE_RO_MESSAGES = Object.freeze({
  ADD_CHOICE: `Vă rugăm să adăugați cel puțin o opțiune pentru {field}.`, 
  INVALID_VALUE: `{field} conține o valoare invalidă.`,
  EMPTY: `{field} trebuie să fie gol.`,
  NOT_EMPTY: `{field} nu trebuie să fie gol.`,
  ONE_OF: `{field} trebuie să fie una dintre următoarele: {value}.`,
  NOT_ONE_OF: `{field} nu trebuie să fie una dintre următoarele: {value}.`,
  REQUIRED: `{field} este obligatoriu.`,
  OPTIONAL: `{field} este opțional.`,
  NOT_NULLABLE: `{field} nu poate fi nul.`,
  INVALID_TYPE: `{field} conține un tip de intrare invalid. Doar {type} este permis.`,
  NOT_ALLOWED_FIELD: `{field} nu este permis.`,
  COMPARE: `{field} nu se potrivește cu valoarea așteptată.`,
  RULES_COMPARE: `{field} nu respectă regulile de comparare.`,
  ALLOW: `{field} conține doar caractere permise.`,
  NOT_ALLOWED: `{field} conține caractere nepermise.`,
  REGEX_MATCH: `Formatul lui {field} este invalid.`,
  REGEX_START_WITH: `{field} trebuie să înceapă cu {value}.`,
  REGEX_ENDS_WITH: `{field} trebuie să se termine cu {value}.`,
  REGEX_CONTAINS: `{field} trebuie să conțină {value}.`,
  REGEX_EXACT: `{field} trebuie să fie exact {value}.`,
  REGEX_NOT_START_WITH: `{field} nu trebuie să înceapă cu {value}.`,
  REGEX_NOT_ENDS_WITH: `{field} nu trebuie să se termine cu {value}.`,
  REGEX_NOT_CONTAINS: `{field} nu trebuie să conțină {value}.`,
  MIN_STRING: `{field} trebuie să aibă cel puțin {min} caractere.`,
  MAX_STRING: `{field} trebuie să aibă cel mult {max} caractere.`,
  MIN_NUMBER: `{field} trebuie să fie cel puțin {min}.`,
  MAX_NUMBER: `{field} trebuie să fie cel mult {max}.`,
  AND: `{field} trebuie să fie una dintre: {value}`,
  OR: `{field} trebuie să fie una dintre: {value}`,
  EQUAL: `{field} trebuie să fie egal cu {value}`,
  NOT_EQUAL: `{field} nu trebuie să fie egal cu {value}`,
  LESS_THAN: `{field} trebuie să fie mai mic decât {value}`,
  LESS_THAN_EQUAL: `{field} trebuie să fie mai mic sau egal cu {value}`,
  GREATER_THAN: `{field} trebuie să fie mai mare decât {value}`,
  GREATER_THAN_EQUAL: `{field} trebuie să fie mai mare sau egal cu {value}`,
  IN: `{field} trebuie să fie una dintre următoarele valori: {value}`,
  NOT_IN: `{field} nu trebuie să conțină niciuna dintre următoarele valori: {value}`,
  EXISTS: `{field} trebuie să existe`,
  TYPE: `{field} trebuie să fie de tipul {value}`,
  MOD: `{field} trebuie să aibă restul {value[1]} când este împărțit la {value[0]}`,
  ALL: `{field} trebuie să conțină toate valorile: {value}`,
  SIZE: `{field} trebuie să aibă dimensiunea {value}`,
});

const LOCALE_RU_MESSAGES = Object.freeze({
  ADD_CHOICE: `Пожалуйста, добавьте хотя бы один вариант для {field}.`,
  INVALID_VALUE: `{field} содержит недопустимое значение.`,
  EMPTY: `{field} должно быть пустым.`,
  NOT_EMPTY: `{field} не должно быть пустым.`,
  ONE_OF: `{field} должно быть одним из следующих значений: {value}.`,
  NOT_ONE_OF: `{field} не должно быть одним из следующих значений: {value}.`,
  REQUIRED: `{field} обязательно для заполнения.`,
  OPTIONAL: `{field} является необязательным.`,
  NOT_NULLABLE: `{field} не может быть null.`,
  INVALID_TYPE: `{field} содержит недопустимый тип. Допустим только {type}.`,
  NOT_ALLOWED_FIELD: `{field} не разрешено.`,
  COMPARE: `{field} не соответствует ожидаемому значению.`,
  RULES_COMPARE: `{field} не соответствует правилам сравнения.`,
  ALLOW: `{field} содержит только допустимые символы.`,
  NOT_ALLOWED: `{field} содержит недопустимые символы.`,
  REGEX_MATCH: `Неверный формат для {field}.`,
  REGEX_START_WITH: `{field} должно начинаться с {value}.`,
  REGEX_ENDS_WITH: `{field} должно заканчиваться на {value}.`,
  REGEX_CONTAINS: `{field} должно содержать {value}.`,
  REGEX_EXACT: `{field} должно быть точно равно {value}.`,
  REGEX_NOT_START_WITH: `{field} не должно начинаться с {value}.`,
  REGEX_NOT_ENDS_WITH: `{field} не должно заканчиваться на {value}.`,
  REGEX_NOT_CONTAINS: `{field} не должно содержать {value}.`,
  MIN_STRING: `{field} должно содержать минимум {min} символов.`,
  MAX_STRING: `{field} должно содержать не более {max} символов.`,
  MIN_NUMBER: `{field} должно быть не меньше {min}.`,
  MAX_NUMBER: `{field} должно быть не больше {max}.`,
  AND: `{field} должно быть одним из: {value}`,
  OR: `{field} должно быть одним из: {value}`,
  EQUAL: `{field} должно быть равно {value}`,
  NOT_EQUAL: `{field} не должно быть равно {value}`,
  LESS_THAN: `{field} должно быть меньше {value}`,
  LESS_THAN_EQUAL: `{field} должно быть меньше или равно {value}`,
  GREATER_THAN: `{field} должно быть больше {value}`,
  GREATER_THAN_EQUAL: `{field} должно быть больше или равно {value}`,
  IN: `{field} должно быть одним из следующих значений: {value}`,
  NOT_IN: `{field} не должно содержать ни одно из значений: {value}`,
  EXISTS: `{field} должно существовать`,
  TYPE: `{field} должно быть типа {value}`,
  MOD: `{field} должно иметь остаток {value[1]} при делении на {value[0]}`,
  ALL: `{field} должно содержать все следующие значения: {value}`,
  SIZE: `{field} должно иметь размер {value}`,
});

const LOCALE_MESSAGES = Object.freeze({
  [LANGUAGES.en]:LOCALE_EN_MESSAGES,
  [LANGUAGES.nl]:LOCALE_NL_MESSAGES,
  [LANGUAGES.lv]:LOCALE_LV_MESSAGES,
  [LANGUAGES.pl]:LOCALE_PL_MESSAGES,
  [LANGUAGES.ro]:LOCALE_RO_MESSAGES,
  [LANGUAGES.ru]:LOCALE_RU_MESSAGES
})

module.exports = {
  dataTypes,
  operatorTypes,
  rulesTypes,
  rulesMessages,
  regexTypes,
  types,
  fieldTypes,
  interfaces,
  API_VERSIONS,
  API_VERSION,
  LANGUAGES,
  LOCALE_MESSAGES
};