diff --git a/README.md b/README.md
index 886712dd76..b7d7dca312 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ Class-validator works on both browser and node.js platforms.
     - [Passing options](#passing-options)
   - [Validation errors](#validation-errors)
   - [Validation messages](#validation-messages)
+  - [Translation of validation messages](#translation-of-validation-messages)
   - [Validating arrays](#validating-arrays)
   - [Validating sets](#validating-sets)
   - [Validating maps](#validating-maps)
@@ -137,6 +138,8 @@ export interface ValidatorOptions {
 
   forbidUnknownValues?: boolean;
   stopAtFirstError?: boolean;
+
+  language?: string
 }
 ```
 
@@ -262,6 +265,88 @@ Message function accepts `ValidationArguments` which contains the following info
 - `object` - object that is being validated
 - `property` - name of the object's property being validated
 
+## Translation of validation messages
+
+The package supports translating error messages into different languages. Currently, the supported languages are:
+
+| Linguagem           | Código |
+|---------------------|--------|
+| English             | en     |
+| Portuguese (Brazil) | pt-br  |
+| Spanish             | es     |
+
+To translate error messages, simply set the language code in the `language` property of the options object when calling the validate function. For example:
+
+```ts
+import { validate } from 'class-validator';
+
+class MyClass {
+  @IsNotEmpty()
+  eicCode: string;
+}
+
+const model = new MyClass();
+
+validate(model, { language: 'en' }).then(errors => {
+  //
+});
+```
+
+If the language option is not specified, the default language will be English (en).
+
+**Default and Custom Driver**
+
+By default, the package uses the `DefaultDriver` to manage translations. However, it is possible to create a custom driver using the TranslatorDriver interface.
+
+Example of implementing a custom translation driver:
+
+```typescript
+import { setTranslatorDriver, TranslatorDriver } from 'class-validator';
+
+class MyTranslator implements TranslatorDriver {
+  translate(key: string, language?: string | null): string {
+    return 'Translated message';
+  }
+}
+
+setTranslatorDriver(new MyTranslator());
+```
+
+**Pre-built Drivers for i18n Integration**
+
+The package also provides support for internationalization using other popular third-party packages like i18n and nestjs-i18n, with out-of-the-box drivers.
+
+**Integration with i18n**
+
+Use the I18nDriver to integrate with the i18n package:
+
+```ts
+import { setTranslatorDriver, I18nDriver } from 'class-validator';
+import { I18n } from 'i18n';
+
+const i18n = new I18n();
+
+setTranslatorDriver(new I18nDriver(i18n));
+```
+
+**Integration with nestjs-i18n**
+
+With the nestjs-i18n package, the `NestI18nDriver` can be configured directly in the bootstrap of NestJS:
+
+```ts
+import { setTranslatorDriver, NestI18nDriver } from 'class-validator';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  
+  setTranslatorDriver(new NestI18nDriver(app.get(I18nService)));
+  
+  await app.listen(3000);
+}
+```
+
+In this way, the package's error messages will be automatically translated using the internationalization service configured in the project.
+
 ## Validating arrays
 
 If your field is an array and you want to perform validation of each item in the array you must specify a
diff --git a/locales/en.json b/locales/en.json
new file mode 100644
index 0000000000..b06a8cc31d
--- /dev/null
+++ b/locales/en.json
@@ -0,0 +1,214 @@
+{
+	"class-validator.array-contains": "$property must contain $constraint1 values",
+	"class-validator.array-contains-each": "each value $property must contain $constraint1 values",
+	"class-validator.array-max-size": "$property must contain no more than $constraint1 elements",
+	"class-validator.array-max-size-each": "each value $property must contain no more than $constraint1 elements",
+	"class-validator.array-min-size": "$property must contain at least $constraint1 elements",
+	"class-validator.array-min-size-each": "each value $property must contain at least $constraint1 elements",
+	"class-validator.array-not-contains": "$property should not contain $constraint1 values",
+	"class-validator.array-not-contains-each": "each value $property should not contain $constraint1 values",
+	"class-validator.array-not-empty": "$property should not be empty",
+	"class-validator.array-not-empty-each": "each value $property should not be empty",
+	"class-validator.array-unique": "All $property's elements must be unique",
+	"class-validator.array-unique-each": "each value all $property's elements must be unique",
+	"class-validator.equals": "$property must be equal to $constraint1",
+	"class-validator.equals-each": "each value $property must be equal to $constraint1",
+	"class-validator.is-defined": "$property should not be null or undefined",
+	"class-validator.is-defined-each": "each value $property should not be null or undefined",
+	"class-validator.is-empty": "$property must be empty",
+	"class-validator.is-empty-each": "each value $property must be empty",
+	"class-validator.is-in": "$property must be one of the following values: $constraint1",
+	"class-validator.is-in-each": "each value $property must be one of the following values: $constraint1",
+	"class-validator.is-latitude": "$property must be a latitude string or number",
+	"class-validator.is-latitude-each": "each value $property must be a latitude string or number",
+	"class-validator.is-lat-long": "$property must be a latitude,longitude string",
+	"class-validator.is-lat-long-each": "each value $property must be a latitude,longitude string",
+	"class-validator.is-longitude": "$property must be a longitude string or number",
+	"class-validator.is-longitude-each": "each value $property must be a longitude string or number",
+	"class-validator.is-not-empty": "$property should not be empty",
+	"class-validator.is-not-empty-each": "each value $property should not be empty",
+	"class-validator.is-not-in": "$property should not be one of the following values: $constraint1",
+	"class-validator.is-not-in-each": "each value $property should not be one of the following values: $constraint1",
+	"class-validator.not-equals": "$property should not be equal to $constraint1",
+	"class-validator.not-equals-each": "each value $property should not be equal to $constraint1",
+	"class-validator.max-date": "maximal allowed date for $property is $constraint1",
+	"class-validator.max-date-each": "maximal allowed date for each value $property is $constraint1",
+	"class-validator.min-date": "minimal allowed date for $property is $constraint1",
+	"class-validator.min-date-each": "minimal allowed date for each value $property is $constraint1",
+	"class-validator.is-divisible-by": "$property must be divisible by $constraint1",
+	"class-validator.is-divisible-by-each": "each value $property must be divisible by $constraint1",
+	"class-validator.is-negative": "$property must be a negative number",
+	"class-validator.is-negative-each": "each value $property must be a negative number",
+	"class-validator.is-positive": "$property must be a positive number",
+	"class-validator.is-positive-each": "each value $property must be a positive number",
+	"class-validator.max": "$property must not be greater than $constraint1",
+	"class-validator.max-each": "each value $property must not be greater than $constraint1",
+	"class-validator.min": "$property must not be less than $constraint1",
+	"class-validator.min-each": "each value $property must not be less than $constraint1",
+	"class-validator.is-instance": "$property must be an instance of $constraint1",
+	"class-validator.is-instance-eac": "each value $property must be an instance of $constraint1",
+	"class-validator.is-not-empty-object": "$property must be a non-empty object",
+	"class-validator.is-not-empty-object-each": "each value $property must be a non-empty object",
+	"class-validator.contains": "$property must contain a $constraint1 string",
+	"class-validator.contains-each": "each value in $property must contain a $constraint1 string",
+	"class-validator.is-iso4217-currency-code": "$property must be a valid ISO4217 currency code",
+	"class-validator.is-iso4217-currency-code-each": "each value $property must be a valid ISO4217 currency code",
+	"class-validator.is-tax-id": "$property must be a Tax Identification Number",
+	"class-validator.is-tax-id-each": "each value $property must be a Tax Identification Number",
+	"class-validator.is-alpha": "$property must contain only letters (a-zA-Z)",
+	"class-validator.is-alpha-each": "each value $property must contain only letters (a-zA-Z)",
+	"class-validator.is-alphanumeric": "$property must contain only letters and numbers",
+	"class-validator.is-alphanumeric-each": "each value $property must contain only letters and numbers",
+	"class-validator.is-ascii": "$property must contain only ASCII characters",
+	"class-validator.is-ascii-each": "each value $property must contain only ASCII characters",
+	"class-validator.is-base32": "$property must be base32 encoded",
+	"class-validator.is-base32-each": "each value $property must be base32 encoded",
+	"class-validator.is-base58": "$property must be base58 encoded",
+	"class-validator.is-base58-each": "each value $property must be base58 encoded",
+	"class-validator.is-base64": "$property must be base64 encoded",
+	"class-validator.is-base64-each": "each value $property must be base64 encoded",
+	"class-validator.is-bic": "$property must be a BIC or SWIFT code",
+	"class-validator.is-bic-each": "each value $property must be a BIC or SWIFT code",
+	"class-validator.is-boolean-string": "$property must be a boolean string",
+	"class-validator.is-boolean-string-each": "each value $property must be a boolean string",
+	"class-validator.is-btc-address-each": "$property must be a BTC address",
+	"class-validator.is-btc-address-each-each": "each value $property must be a BTC address",
+	"class-validator.is-byte-length": "$property's byte length must fall into ($constraint1, $constraint2) range",
+	"class-validator.is-byte-length-each": "each value $property's byte length must fall into ($constraint1, $constraint2) range",
+	"class-validator.is-credit-card": "$property must be a credit card",
+	"class-validator.is-credit-card-each": "each value $property must be a credit card",
+	"class-validator.is-currency": "$property must be a currency",
+	"class-validator.is-currency-each": "each value $property must be a currency",
+	"class-validator.is-data-uri": "$property must be a data uri format",
+	"class-validator.is-data-uri-each": "each value $property must be a data uri format",
+	"class-validator.is-date-string": "$property must be a valid ISO 8601 date string",
+	"class-validator.is-date-string-each": "each value $property must be a valid ISO 8601 date string",
+	"class-validator.is-decimal": "$property is not a valid decimal number.",
+	"class-validator.is-decimal-each": "each value $property is not a valid decimal number.",
+	"class-validator.is-ean": "$property must be an EAN (European Article Number)",
+	"class-validator.is-ean-each": "each value $property must be an EAN (European Article Number)",
+	"class-validator.is-email": "$property must be an email",
+	"class-validator.is-email-each": "each value $property must be an email",
+	"class-validator.is-ethereum-address": "$property must be an Ethereum address",
+	"class-validator.is-ethereum-address-each": "each value $property must be an Ethereum address",
+	"class-validator.is-firebase-push-id": "$property must be a Firebase Push Id",
+	"class-validator.is-firebase-push-id-each": "each value $property must be a Firebase Push Id",
+	"class-validator.is-fqdn": "$property must be a valid domain name",
+	"class-validator.is-fqdn-each": "each value $property must be a valid domain name",
+	"class-validator.is-full-width": "$property must contain a full-width characters",
+	"class-validator.is-full-width-each": "each value $property must contain a full-width characters",
+	"class-validator.is-half-width": "$property must contain a half-width characters",
+	"class-validator.is-half-width-each": "each value $property must contain a half-width characters",
+	"class-validator.is-hash": "$property must be a hash of type $constraint1",
+	"class-validator.is-hash-each": "each value $property must be a hash of type $constraint1",
+	"class-validator.is-hexadecimal": "$property must be a hexadecimal number",
+	"class-validator.is-hexadecimal-each": "each value $property must be a hexadecimal number",
+	"class-validator.is-hex-color": "$property must be a hexadecimal color",
+	"class-validator.is-hex-color-each": "each value $property must be a hexadecimal color",
+	"class-validator.is-hsl": "$property must be a HSL color",
+	"class-validator.is-hsl-each": "each value $property must be a HSL color",
+	"class-validator.is-iban": "$property must be an IBAN",
+	"class-validator.is-iban-each": "each value $property must be an IBAN",
+	"class-validator.is-identity-card": "$property must be a identity card number",
+	"class-validator.is-identity-card-each": "each value $property must be a identity card number",
+	"class-validator.is-ip": "$property must be an ip address",
+	"class-validator.is-ip-each": "each value $property must be an ip address",
+	"class-validator.is-isbn": "$property must be an ISBN",
+	"class-validator.is-isbn-each": "each value $property must be an ISBN",
+	"class-validator.is-isin": "$property must be an ISIN (stock/security identifier)",
+	"class-validator.is-isin-each": "each value $property must be an ISIN (stock/security identifier)",
+	"class-validator.is-iso-8601": "$property must be a valid ISO 8601 date string",
+	"class-validator.is-iso-8601-each": "each value $property must be a valid ISO 8601 date string",
+	"class-validator.is-iso31661-alpha2": "$property must be a valid ISO31661 Alpha2 code",
+	"class-validator.is-iso31661-alpha2-each": "each value $property must be a valid ISO31661 Alpha2 code",
+	"class-validator.is-iso-31661-alpha3": "$property must be a valid ISO31661 Alpha3 code",
+	"class-validator.is-iso-31661-alpha3-each": "each value $property must be a valid ISO31661 Alpha3 code",
+	"class-validator.is-isrc": "$property must be an ISRC",
+	"class-validator.is-isrc-each-each": "each value $property must be an ISRC",
+	"class-validator.is-issn": "$property must be a ISSN",
+	"class-validator.is-issn-each": "each value $property must be a ISSN",
+	"class-validator.is-json": "$property must be a json string",
+	"class-validator.is-json-each": "each value $property must be a json string",
+	"class-validator.is-jwt": "$property must be a jwt string",
+	"class-validator.is-jwt-each": "each value $property must be a jwt string",
+	"class-validator.is-locale": "$property must be locale",
+	"class-validator.is-locale-each": "each value $property must be locale",
+	"class-validator.is-lowercase": "$property must be a lowercase string",
+	"class-validator.is-lowercase-each": "each value $property must be a lowercase string",
+	"class-validator.is-mac-address": "$property must be a MAC Address",
+	"class-validator.is-mac-address-each": "each value $property must be a MAC Address",
+	"class-validator.is-magnet-uri": "$property must be magnet uri format",
+	"class-validator.is-magnet-uri-each": "each value $property must be magnet uri format",
+	"class-validator.is-military-time": "$property must be a valid representation of military time in the format HH:MM",
+	"class-validator.is-military-time-each": "each value $property must be a valid representation of military time in the format HH:MM",
+	"class-validator.is-mime-type": "$property must be MIME type format",
+	"class-validator.is-mime-type-each": "each value $property must be MIME type format",
+	"class-validator.is-mobile-phone": "$property must be a phone number",
+	"class-validator.is-mobile-phone-each": "each value $property must be a phone number",
+	"class-validator.is-mongo-id": "$property must be a mongodb id",
+	"class-validator.is-mongo-id-each": "each value $property must be a mongodb id",
+	"class-validator.is-multibyte": "$property must contain one or more multibyte chars",
+	"class-validator.is-multibyte-each": "each value $property must contain one or more multibyte chars",
+	"class-validator.is-number-string": "$property must be a number string",
+	"class-validator.is-number-string-each": "each value $property must be a number string",
+	"class-validator.is-octal": "$property must be valid octal number",
+	"class-validator.is-octal-each": "each value $property must be valid octal number",
+	"class-validator.is-passport-number": "$property must be valid passport number",
+	"class-validator.is-passport-number-each": "each value $property must be valid passport number",
+	"class-validator.is-phone-number": "$property must be a valid phone number",
+	"class-validator.is-phone-number-each": "each value $property must be a valid phone number",
+	"class-validator.is-port": "$property must be a port",
+	"class-validator.is-port-each": "each value $property must be a port",
+	"class-validator.is-postal-code": "$property must be a postal code",
+	"class-validator.is-postal-code-each": "each value $property must be a postal code",
+	"class-validator.is-rfc-3339": "$property must be RFC 3339 date",
+	"class-validator.is-rfc-3339-each": "each value $property must be RFC 3339 date",
+	"class-validator.is-rgb-color": "$property must be RGB color",
+	"class-validator.is-rgb-color-each": "each value $property must be RGB color",
+	"class-validator.is-sem-ver": "$property must be a Semantic Versioning Specification",
+	"class-validator.is-sem-ver-each": "each value $property must be a Semantic Versioning Specification",
+	"class-validator.is-strong-password": "$property is not strong enough",
+	"class-validator.is-strong-password-each": "each value $property is not strong enough",
+	"class-validator.is-surrogate-pair": "$property must contain any surrogate pairs chars",
+	"class-validator.is-surrogate-pair-each": "each value $property must contain any surrogate pairs chars",
+	"class-validator.is-time-zone": "$property must be a valid IANA time-zone",
+	"class-validator.is-time-zone-each": "each value $property must be a valid IANA time-zone",
+	"class-validator.is-uppercase": "$property must be uppercase",
+	"class-validator.is-uppercase-each": "each value $property must be uppercase",
+	"class-validator.is-url": "$property must be a URL address",
+	"class-validator.is-url-each": "each value $property must be a URL address",
+	"class-validator.is-uuid": "$property must be a UUID",
+	"class-validator.is-uuid-each": "each value $property must be a UUID",
+	"class-validator.is-variable-width": "$property must contain a full-width and half-width characters",
+	"class-validator.is-variable-width-each": "each value $property must contain a full-width and half-width characters",
+	"class-validator.is-min-length": "$property must be longer than or equal to $constraint1 characters",
+	"class-validator.is-min-length-each": "each value $property must be longer than or equal to $constraint1 characters",
+	"class-validator.is-max-length": "$property must be shorter than or equal to $constraint2 characters",
+	"class-validator.is-max-length-each": "each value $property must be shorter than or equal to $constraint2 characters",
+	"class-validator.length": "$property must be longer than or equal to $constraint1 and shorter than or equal to $constraint2 characters",
+	"class-validator.length-each": "each value $property must be longer than or equal to $constraint1 and shorter than or equal to $constraint2 characters",
+	"class-validator.matches": "$property must match $constraint1 regular expression",
+	"class-validator.matches-each": "each value $property must match $constraint1 regular expression",
+	"class-validator.max-length": "$property must be shorter than or equal to $constraint1 characters",
+	"class-validator.max-length-each": "each value $property must be shorter than or equal to $constraint1 characters",
+	"class-validator.min-length": "$property must be longer than or equal to $constraint1 characters",
+	"class-validator.min-length-each": "each value $property must be longer than or equal to $constraint1 characters",
+	"class-validator.not-contains": "$property should not contain a $constraint1 string",
+	"class-validator.not-contains-each": "each value $property should not contain a $constraint1 string",
+	"class-validator.is-array": "$property must be an array",
+	"class-validator.is-array-each": "each value $property must be an array",
+	"class-validator.is-boolean": "$property must be a boolean value",
+	"class-validator.is-boolean-each": "each value $property must be a boolean value",
+	"class-validator.is-date": "$property must be a Date instance",
+	"class-validator.is-date-each": "each value $property must be a Date instance",
+	"class-validator.is-enum": "$property must be one of the following values: $constraint2",
+	"class-validator.is-enum-each": "each value $property must be one of the following values: $constraint2",
+	"class-validator.is-int": "$property must be an integer number",
+	"class-validator.is-int-each": "each value $property must be an integer number",
+	"class-validator.is-number": "$property must be a number conforming to the specified constraints",
+	"class-validator.is-number-each": "each value $property must be a number conforming to the specified constraints",
+	"class-validator.is-object": "$property must be an object",
+	"class-validator.is-object-each": "each value $property must be an object",
+	"class-validator.is-string": "$property must be a string",
+	"class-validator.is-string-each": "each value $property must be a string"
+}
\ No newline at end of file
diff --git a/locales/es.json b/locales/es.json
new file mode 100644
index 0000000000..14657c39cb
--- /dev/null
+++ b/locales/es.json
@@ -0,0 +1,214 @@
+{
+	"class-validator.array-contains": "$property debe contener valores de $constraint1",
+	"class-validator.array-contains-each": "cada valor de $property debe contener valores de $constraint1",
+	"class-validator.array-max-size": "$property no debe contener más de $constraint1 elementos",
+	"class-validator.array-max-size-each": "cada valor de $property no debe contener más de $constraint1 elementos",
+	"class-validator.array-min-size": "$property debe contener al menos $constraint1 elementos",
+	"class-validator.array-min-size-each": "cada valor de $property debe contener al menos $constraint1 elementos",
+	"class-validator.array-not-contains": "$property no debe contener valores de $constraint1",
+	"class-validator.array-not-contains-each": "cada valor de $property no debe contener valores de $constraint1",
+	"class-validator.array-not-empty": "$property no debe estar vacío",
+	"class-validator.array-not-empty-each": "cada valor de $property no debe estar vacío",
+	"class-validator.array-unique": "Todos los elementos de $property deben ser únicos",
+	"class-validator.array-unique-each": "cada valor, todos los elementos de $property deben ser únicos",
+	"class-validator.equals": "$property debe ser igual a $constraint1",
+	"class-validator.equals-each": "cada valor de $property debe ser igual a $constraint1",
+	"class-validator.is-defined": "$property no debe ser nulo o indefinido",
+	"class-validator.is-defined-each": "cada valor de $property no debe ser nulo o indefinido",
+	"class-validator.is-empty": "$property debe estar vacío",
+	"class-validator.is-empty-each": "cada valor de $property debe estar vacío",
+	"class-validator.is-in": "$property debe ser uno de los siguientes valores: $constraint1",
+	"class-validator.is-in-each": "cada valor de $property debe ser uno de los siguientes valores: $constraint1",
+	"class-validator.is-latitude": "$property debe ser una cadena o número de latitud",
+	"class-validator.is-latitude-each": "cada valor de $property debe ser una cadena o número de latitud",
+	"class-validator.is-lat-long": "$property debe ser una cadena de latitud,longitud",
+	"class-validator.is-lat-long-each": "cada valor de $property debe ser una cadena de latitud,longitud",
+	"class-validator.is-longitude": "$property debe ser una cadena o número de longitud",
+	"class-validator.is-longitude-each": "cada valor de $property debe ser una cadena o número de longitud",
+	"class-validator.is-not-empty": "$property no debe estar vacío",
+	"class-validator.is-not-empty-each": "cada valor de $property no debe estar vacío",
+	"class-validator.is-not-in": "$property no debe ser uno de los siguientes valores: $constraint1",
+	"class-validator.is-not-in-each": "cada valor de $property no debe ser uno de los siguientes valores: $constraint1",
+	"class-validator.not-equals": "$property no debe ser igual a $constraint1",
+	"class-validator.not-equals-each": "cada valor de $property no debe ser igual a $constraint1",
+	"class-validator.max-date": "la fecha máxima permitida para $property es $constraint1",
+	"class-validator.max-date-each": "la fecha máxima permitida para cada valor de $property es $constraint1",
+	"class-validator.min-date": "la fecha mínima permitida para $property es $constraint1",
+	"class-validator.min-date-each": "la fecha mínima permitida para cada valor de $property es $constraint1",
+	"class-validator.is-divisible-by": "$property debe ser divisible por $constraint1",
+	"class-validator.is-divisible-by-each": "cada valor de $property debe ser divisible por $constraint1",
+	"class-validator.is-negative": "$property debe ser un número negativo",
+	"class-validator.is-negative-each": "cada valor de $property debe ser un número negativo",
+	"class-validator.is-positive": "$property debe ser un número positivo",
+	"class-validator.is-positive-each": "cada valor de $property debe ser un número positivo",
+	"class-validator.max": "$property no debe ser mayor que $constraint1",
+	"class-validator.max-each": "cada valor de $property no debe ser mayor que $constraint1",
+	"class-validator.min": "$property no debe ser menor que $constraint1",
+	"class-validator.min-each": "cada valor de $property no debe ser menor que $constraint1",
+	"class-validator.is-instance": "$property debe ser una instancia de $constraint1",
+	"class-validator.is-instance-eac": "cada valor de $property debe ser una instancia de $constraint1",
+	"class-validator.is-not-empty-object": "$property debe ser un objeto no vacío",
+	"class-validator.is-not-empty-object-each": "cada valor de $property debe ser un objeto no vacío",
+	"class-validator.contains": "$property debe contener una cadena $constraint1",
+	"class-validator.contains-each": "cada valor en $property debe contener una cadena $constraint1",
+	"class-validator.is-iso4217-currency-code": "$property debe ser un código de moneda ISO4217 válido",
+	"class-validator.is-iso4217-currency-code-each": "cada valor de $property debe ser un código de moneda ISO4217 válido",
+	"class-validator.is-tax-id": "$property debe ser un número de identificación fiscal",
+	"class-validator.is-tax-id-each": "cada valor de $property debe ser un número de identificación fiscal",
+	"class-validator.is-alpha": "$property debe contener solo letras (a-zA-Z)",
+	"class-validator.is-alpha-each": "cada valor de $property debe contener solo letras (a-zA-Z)",
+	"class-validator.is-alphanumeric": "$property debe contener solo letras y números",
+	"class-validator.is-alphanumeric-each": "cada valor de $property debe contener solo letras y números",
+	"class-validator.is-ascii": "$property debe contener solo caracteres ASCII",
+	"class-validator.is-ascii-each": "cada valor de $property debe contener solo caracteres ASCII",
+	"class-validator.is-base32": "$property debe estar codificado en base32",
+	"class-validator.is-base32-each": "cada valor de $property debe estar codificado en base32",
+	"class-validator.is-base58": "$property debe estar codificado en base58",
+	"class-validator.is-base58-each": "cada valor de $property debe estar codificado en base58",
+	"class-validator.is-base64": "$property debe estar codificado en base64",
+	"class-validator.is-base64-each": "cada valor de $property debe estar codificado en base64",
+	"class-validator.is-bic": "$property debe ser un código BIC o SWIFT",
+	"class-validator.is-bic-each": "cada valor de $property debe ser un código BIC o SWIFT",
+	"class-validator.is-boolean-string": "$property debe ser una cadena booleana",
+	"class-validator.is-boolean-string-each": "cada valor de $property debe ser una cadena booleana",
+	"class-validator.is-btc-address-each": "$property debe ser una dirección BTC",
+	"class-validator.is-btc-address-each-each": "cada valor de $property debe ser una dirección BTC",
+	"class-validator.is-byte-length": "la longitud en bytes de $property debe estar en el rango ($constraint1, $constraint2)",
+	"class-validator.is-byte-length-each": "cada valor de $property debe estar en el rango ($constraint1, $constraint2)",
+	"class-validator.is-credit-card": "$property debe ser una tarjeta de crédito",
+	"class-validator.is-credit-card-each": "cada valor de $property debe ser una tarjeta de crédito",
+	"class-validator.is-currency": "$property debe ser una moneda",
+	"class-validator.is-currency-each": "cada valor de $property debe ser una moneda",
+	"class-validator.is-data-uri": "$property debe tener formato de URI de datos",
+	"class-validator.is-data-uri-each": "cada valor de $property debe tener formato de URI de datos",
+	"class-validator.is-date-string": "$property debe ser una cadena de fecha ISO 8601 válida",
+	"class-validator.is-date-string-each": "cada valor de $property debe ser una cadena de fecha ISO 8601 válida",
+	"class-validator.is-decimal": "$property no es un número decimal válido.",
+	"class-validator.is-decimal-each": "cada valor de $property no es un número decimal válido.",
+	"class-validator.is-ean": "$property debe ser un número de artículo europeo (EAN)",
+	"class-validator.is-ean-each": "cada valor de $property debe ser un número de artículo europeo (EAN)",
+	"class-validator.is-email": "$property debe ser un correo electrónico",
+	"class-validator.is-email-each": "cada valor de $property debe ser un correo electrónico",
+	"class-validator.is-ethereum-address": "$property debe ser una dirección Ethereum",
+	"class-validator.is-ethereum-address-each": "cada valor de $property debe ser una dirección Ethereum",
+	"class-validator.is-firebase-push-id": "$property debe ser un Firebase Push Id",
+	"class-validator.is-firebase-push-id-each": "cada valor de $property debe ser un Firebase Push Id",
+	"class-validator.is-fqdn": "$property debe ser un nombre de dominio válido",
+	"class-validator.is-fqdn-each": "cada valor de $property debe ser un nombre de dominio válido",
+	"class-validator.is-full-width": "$property debe contener caracteres de ancho completo",
+	"class-validator.is-full-width-each": "cada valor de $property debe contener caracteres de ancho completo",
+	"class-validator.is-half-width": "$property debe contener caracteres de medio ancho",
+	"class-validator.is-half-width-each": "cada valor de $property debe contener caracteres de medio ancho",
+	"class-validator.is-hash": "$property debe ser un hash de tipo $constraint1",
+	"class-validator.is-hash-each": "cada valor de $property debe ser un hash de tipo $constraint1",
+	"class-validator.is-hexadecimal": "$property debe ser un número hexadecimal",
+	"class-validator.is-hexadecimal-each": "cada valor de $property debe ser un número hexadecimal",
+	"class-validator.is-hex-color": "$property debe ser un color hexadecimal",
+	"class-validator.is-hex-color-each": "cada valor de $property debe ser un color hexadecimal",
+	"class-validator.is-hsl": "$property debe ser un color HSL",
+	"class-validator.is-hsl-each": "cada valor de $property debe ser un color HSL",
+	"class-validator.is-iban": "$property debe ser un IBAN",
+	"class-validator.is-iban-each": "cada valor de $property debe ser un IBAN",
+	"class-validator.is-identity-card": "$property debe ser un número de documento de identidad",
+	"class-validator.is-identity-card-each": "cada valor de $property debe ser un número de documento de identidad",
+	"class-validator.is-ip": "$property debe ser una dirección IP",
+	"class-validator.is-ip-each": "cada valor de $property debe ser una dirección IP",
+	"class-validator.is-isbn": "$property debe ser un ISBN",
+	"class-validator.is-isbn-each": "cada valor de $property debe ser un ISBN",
+	"class-validator.is-isin": "$property debe ser un ISIN (identificador de acciones/valores)",
+	"class-validator.is-isin-each": "cada valor de $property debe ser un ISIN (identificador de acciones/valores)",
+	"class-validator.is-iso-8601": "$property debe ser una cadena de fecha ISO 8601 válida",
+	"class-validator.is-iso-8601-each": "cada valor de $property debe ser una cadena de fecha ISO 8601 válida",
+	"class-validator.is-iso31661-alpha2": "$property debe ser un código ISO31661 Alpha2 válido",
+	"class-validator.is-iso31661-alpha2-each": "cada valor de $property debe ser un código ISO31661 Alpha2 válido",
+	"class-validator.is-iso-31661-alpha3": "$property debe ser un código ISO31661 Alpha3 válido",
+	"class-validator.is-iso-31661-alpha3-each": "cada valor de $property debe ser un código ISO31661 Alpha3 válido",
+	"class-validator.is-isrc": "$property debe ser un ISRC",
+	"class-validator.is-isrc-each-each": "cada valor de $property debe ser un ISRC",
+	"class-validator.is-issn": "$property debe ser un ISSN",
+	"class-validator.is-issn-each": "cada valor de $property debe ser un ISSN",
+	"class-validator.is-json": "$property debe ser una cadena JSON",
+	"class-validator.is-json-each": "cada valor de $property debe ser una cadena JSON",
+	"class-validator.is-jwt": "$property debe ser una cadena JWT",
+	"class-validator.is-jwt-each": "cada valor de $property debe ser una cadena JWT",
+	"class-validator.is-locale": "$property debe ser un local",
+	"class-validator.is-locale-each": "cada valor de $property debe ser un local",
+	"class-validator.is-lowercase": "$property debe ser una cadena en minúsculas",
+	"class-validator.is-lowercase-each": "cada valor de $property debe ser una cadena en minúsculas",
+	"class-validator.is-mac-address": "$property debe ser una dirección MAC",
+	"class-validator.is-mac-address-each": "cada valor de $property debe ser una dirección MAC",
+	"class-validator.is-magnet-uri": "$property debe tener formato de URI magnet",
+	"class-validator.is-magnet-uri-each": "cada valor de $property debe tener formato de URI magnet",
+	"class-validator.is-military-time": "$property debe ser una representación válida del tiempo militar en el formato HH:MM",
+	"class-validator.is-military-time-each": "cada valor de $property debe ser una representación válida del tiempo militar en el formato HH:MM",
+	"class-validator.is-mime-type": "$property debe tener formato MIME",
+	"class-validator.is-mime-type-each": "cada valor de $property debe tener formato MIME",
+	"class-validator.is-mobile-phone": "$property debe ser un número de teléfono",
+	"class-validator.is-mobile-phone-each": "cada valor de $property debe ser un número de teléfono",
+	"class-validator.is-mongo-id": "$property debe ser un ID de MongoDB",
+	"class-validator.is-mongo-id-each": "cada valor de $property debe ser un ID de MongoDB",
+	"class-validator.is-multibyte": "$property debe contener uno o más caracteres multibyte",
+	"class-validator.is-multibyte-each": "cada valor de $property debe contener uno o más caracteres multibyte",
+	"class-validator.is-number-string": "$property debe ser una cadena numérica",
+	"class-validator.is-number-string-each": "cada valor de $property debe ser una cadena numérica",
+	"class-validator.is-octal": "$property debe ser un número octal válido",
+	"class-validator.is-octal-each": "cada valor de $property debe ser un número octal válido",
+	"class-validator.is-passport-number": "$property debe ser un número de pasaporte válido",
+	"class-validator.is-passport-number-each": "cada valor de $property debe ser un número de pasaporte válido",
+	"class-validator.is-phone-number": "$property debe ser un número de teléfono válido",
+	"class-validator.is-phone-number-each": "cada valor de $property debe ser un número de teléfono válido",
+	"class-validator.is-port": "$property debe ser un puerto",
+	"class-validator.is-port-each": "cada valor de $property debe ser un puerto",
+	"class-validator.is-postal-code": "$property debe ser un código postal",
+	"class-validator.is-postal-code-each": "cada valor de $property debe ser un código postal",
+	"class-validator.is-rfc-3339": "$property debe ser una fecha RFC 3339",
+	"class-validator.is-rfc-3339-each": "cada valor de $property debe ser una fecha RFC 3339",
+	"class-validator.is-rgb-color": "$property debe ser un color RGB",
+	"class-validator.is-rgb-color-each": "cada valor de $property debe ser un color RGB",
+	"class-validator.is-sem-ver": "$property debe ser una especificación de versión semántica",
+	"class-validator.is-sem-ver-each": "cada valor de $property debe ser una especificación de versión semántica",
+	"class-validator.is-strong-password": "$property no es lo suficientemente fuerte",
+	"class-validator.is-strong-password-each": "cada valor de $property no es lo suficientemente fuerte",
+	"class-validator.is-surrogate-pair": "$property debe contener caracteres de pares sustitutos",
+	"class-validator.is-surrogate-pair-each": "cada valor de $property debe contener caracteres de pares sustitutos",
+	"class-validator.is-time-zone": "$property debe ser una zona horaria válida de IANA",
+	"class-validator.is-time-zone-each": "cada valor de $property debe ser una zona horaria válida de IANA",
+	"class-validator.is-uppercase": "$property debe estar en mayúsculas",
+	"class-validator.is-uppercase-each": "cada valor de $property debe estar en mayúsculas",
+	"class-validator.is-url": "$property debe ser una dirección URL",
+	"class-validator.is-url-each": "cada valor de $property debe ser una dirección URL",
+	"class-validator.is-uuid": "$property debe ser un UUID",
+	"class-validator.is-uuid-each": "cada valor de $property debe ser un UUID",
+	"class-validator.is-variable-width": "$property debe contener caracteres de ancho completo y medio ancho",
+	"class-validator.is-variable-width-each": "cada valor $property debe contener caracteres de ancho completo y medio ancho",
+	"class-validator.is-min-length": "$property debe tener una longitud mayor o igual a $constraint1 caracteres",
+	"class-validator.is-min-length-each": "cada valor $property debe tener una longitud mayor o igual a $constraint1 caracteres",
+	"class-validator.is-max-length": "$property debe tener una longitud menor o igual a $constraint2 caracteres",
+	"class-validator.is-max-length-each": "cada valor $property debe tener una longitud menor o igual a $constraint2 caracteres",
+	"class-validator.length": "$property debe tener una longitud mayor o igual a $constraint1 y menor o igual a $constraint2 caracteres",
+	"class-validator.length-each": "cada valor $property debe tener una longitud mayor o igual a $constraint1 y menor o igual a $constraint2 caracteres",
+	"class-validator.matches": "$property debe coincidir con la expresión regular $constraint1",
+	"class-validator.matches-each": "cada valor $property debe coincidir con la expresión regular $constraint1",
+	"class-validator.max-length": "$property debe tener una longitud menor o igual a $constraint1 caracteres",
+	"class-validator.max-length-each": "cada valor $property debe tener una longitud menor o igual a $constraint1 caracteres",
+	"class-validator.min-length": "$property debe tener una longitud mayor o igual a $constraint1 caracteres",
+	"class-validator.min-length-each": "cada valor $property debe tener una longitud mayor o igual a $constraint1 caracteres",
+	"class-validator.not-contains": "$property no debe contener una cadena $constraint1",
+	"class-validator.not-contains-each": "cada valor $property no debe contener una cadena $constraint1",
+	"class-validator.is-array": "$property debe ser un arreglo",
+	"class-validator.is-array-each": "cada valor $property debe ser un arreglo",
+	"class-validator.is-boolean": "$property debe ser un valor booleano",
+	"class-validator.is-boolean-each": "cada valor $property debe ser un valor booleano",
+	"class-validator.is-date": "$property debe ser una instancia de Date",
+	"class-validator.is-date-each": "cada valor $property debe ser una instancia de Date",
+	"class-validator.is-enum": "$property debe ser uno de los siguientes valores: $constraint2",
+	"class-validator.is-enum-each": "cada valor $property debe ser uno de los siguientes valores: $constraint2",
+	"class-validator.is-int": "$property debe ser un número entero",
+	"class-validator.is-int-each": "cada valor $property debe ser un número entero",
+	"class-validator.is-number": "$property debe ser un número que cumpla con las restricciones especificadas",
+	"class-validator.is-number-each": "cada valor $property debe ser un número que cumpla con las restricciones especificadas",
+	"class-validator.is-object": "$property debe ser un objeto",
+	"class-validator.is-object-each": "cada valor $property debe ser un objeto",
+	"class-validator.is-string": "$property debe ser una cadena de texto",
+	"class-validator.is-string-each": "cada valor $property debe ser una cadena de texto"
+}
\ No newline at end of file
diff --git a/locales/pt-br.json b/locales/pt-br.json
new file mode 100644
index 0000000000..e05b734bbf
--- /dev/null
+++ b/locales/pt-br.json
@@ -0,0 +1,214 @@
+{
+	"class-validator.array-contains": "$property deve conter $constraint1 valores",
+	"class-validator.array-contains-each": "cada valor em $property deve conter $constraint1 valores",
+	"class-validator.array-max-size": "$property não deve conter mais do que $constraint1 elementos",
+	"class-validator.array-max-size-each": "cada valor em $property não deve conter mais do que $constraint1 elementos",
+	"class-validator.array-min-size": "$property deve conter pelo menos $constraint1 elementos",
+	"class-validator.array-min-size-each": "cada valor em $property deve conter pelo menos $constraint1 elementos",
+	"class-validator.array-not-contains": "$property não deve conter os valores $constraint1",
+	"class-validator.array-not-contains-each": "cada valor em $property não deve conter os valores $constraint1",
+	"class-validator.array-not-empty": "$property não deve estar vazio",
+	"class-validator.array-not-empty-each": "cada valor em $property não deve estar vazio",
+	"class-validator.array-unique": "Todos os elementos de $property devem ser únicos",
+	"class-validator.array-unique-each": "cada valor em $property deve conter elementos únicos",
+	"class-validator.equals": "$property deve ser igual a $constraint1",
+	"class-validator.equals-each": "cada valor em $property deve ser igual a $constraint1",
+	"class-validator.is-defined": "$property não deve ser nulo ou indefinido",
+	"class-validator.is-defined-each": "cada valor em $property não deve ser nulo ou indefinido",
+	"class-validator.is-empty": "$property deve estar vazio",
+	"class-validator.is-empty-each": "cada valor em $property deve estar vazio",
+	"class-validator.is-in": "$property deve ser um dos seguintes valores: $constraint1",
+	"class-validator.is-in-each": "cada valor em $property deve ser um dos seguintes valores: $constraint1",
+	"class-validator.is-latitude": "$property deve ser uma latitude válida (string ou número)",
+	"class-validator.is-latitude-each": "cada valor em $property deve ser uma latitude válida (string ou número)",
+	"class-validator.is-lat-long": "$property deve ser uma string de latitude e longitude",
+	"class-validator.is-lat-long-each": "cada valor em $property deve ser uma string de latitude e longitude",
+	"class-validator.is-longitude": "$property deve ser uma longitude válida (string ou número)",
+	"class-validator.is-longitude-each": "cada valor em $property deve ser uma longitude válida (string ou número)",
+	"class-validator.is-not-empty": "$property não deve estar vazio",
+	"class-validator.is-not-empty-each": "cada valor em $property não deve estar vazio",
+	"class-validator.is-not-in": "$property não deve ser um dos seguintes valores: $constraint1",
+	"class-validator.is-not-in-each": "cada valor em $property não deve ser um dos seguintes valores: $constraint1",
+	"class-validator.not-equals": "$property não deve ser igual a $constraint1",
+	"class-validator.not-equals-each": "cada valor em $property não deve ser igual a $constraint1",
+	"class-validator.max-date": "a data máxima permitida para $property é $constraint1",
+	"class-validator.max-date-each": "a data máxima permitida para cada valor em $property é $constraint1",
+	"class-validator.min-date": "a data mínima permitida para $property é $constraint1",
+	"class-validator.min-date-each": "a data mínima permitida para cada valor em $property é $constraint1",
+    "class-validator.is-divisible-by": "$property deve ser divisível por $constraint1",
+    "class-validator.is-divisible-by-each": "cada valor em $property deve ser divisível por $constraint1",
+    "class-validator.is-negative": "$property deve ser um número negativo",
+    "class-validator.is-negative-each": "cada valor em $property deve ser um número negativo",
+    "class-validator.is-positive": "$property deve ser um número positivo",
+    "class-validator.is-positive-each": "cada valor em $property deve ser um número positivo",
+    "class-validator.max": "$property não deve ser maior que $constraint1",
+    "class-validator.max-each": "cada valor em $property não deve ser maior que $constraint1",
+    "class-validator.min": "$property não deve ser menor que $constraint1",
+    "class-validator.min-each": "cada valor em $property não deve ser menor que $constraint1",
+    "class-validator.is-instance": "$property deve ser uma instância de $constraint1",
+    "class-validator.is-instance-eac": "cada valor em $property deve ser uma instância de $constraint1",
+    "class-validator.is-not-empty-object": "$property deve ser um objeto não vazio",
+    "class-validator.is-not-empty-object-each": "cada valor em $property deve ser um objeto não vazio",
+    "class-validator.contains": "$property deve conter a string $constraint1",
+    "class-validator.contains-each": "cada valor em $property deve conter a string $constraint1",
+    "class-validator.is-iso4217-currency-code": "$property deve ser um código de moeda ISO4217 válido",
+    "class-validator.is-iso4217-currency-code-each": "cada valor em $property deve ser um código de moeda ISO4217 válido",
+    "class-validator.is-tax-id": "$property deve ser um número de Identificação Fiscal",
+    "class-validator.is-tax-id-each": "cada valor em $property deve ser um número de Identificação Fiscal",
+    "class-validator.is-alpha": "$property deve conter apenas letras (a-zA-Z)",
+    "class-validator.is-alpha-each": "cada valor em $property deve conter apenas letras (a-zA-Z)",
+    "class-validator.is-alphanumeric": "$property deve conter apenas letras e números",
+    "class-validator.is-alphanumeric-each": "cada valor em $property deve conter apenas letras e números",
+    "class-validator.is-ascii": "$property deve conter apenas caracteres ASCII",
+    "class-validator.is-ascii-each": "cada valor em $property deve conter apenas caracteres ASCII",
+    "class-validator.is-base32": "$property deve ser codificado em base32",
+    "class-validator.is-base32-each": "cada valor em $property deve ser codificado em base32",
+    "class-validator.is-base58": "$property deve ser codificado em base58",
+    "class-validator.is-base58-each": "cada valor em $property deve ser codificado em base58",
+    "class-validator.is-base64": "$property deve ser codificado em base64",
+    "class-validator.is-base64-each": "cada valor em $property deve ser codificado em base64",
+    "class-validator.is-bic": "$property deve ser um código BIC ou SWIFT",
+    "class-validator.is-bic-each": "cada valor em $property deve ser um código BIC ou SWIFT",
+    "class-validator.is-boolean-string": "$property deve ser uma string booleana",
+    "class-validator.is-boolean-string-each": "cada valor em $property deve ser uma string booleana",
+    "class-validator.is-btc-address-each": "$property deve ser um endereço BTC",
+    "class-validator.is-btc-address-each-each": "cada valor em $property deve ser um endereço BTC",
+    "class-validator.is-byte-length": "o comprimento em bytes de $property deve estar no intervalo ($constraint1, $constraint2)",
+    "class-validator.is-byte-length-each": "cada valor em $property deve ter comprimento em bytes no intervalo ($constraint1, $constraint2)",
+    "class-validator.is-credit-card": "$property deve ser um cartão de crédito",
+    "class-validator.is-credit-card-each": "cada valor em $property deve ser um cartão de crédito",
+    "class-validator.is-currency": "$property deve ser uma moeda",
+    "class-validator.is-currency-each": "cada valor em $property deve ser uma moeda",
+    "class-validator.is-data-uri": "$property deve ser um formato de URI de dados",
+    "class-validator.is-data-uri-each": "cada valor em $property deve ser um formato de URI de dados",
+    "class-validator.is-date-string": "$property deve ser uma string de data ISO 8601 válida",
+    "class-validator.is-date-string-each": "cada valor em $property deve ser uma string de data ISO 8601 válida",
+    "class-validator.is-decimal": "$property não é um número decimal válido",
+    "class-validator.is-decimal-each": "cada valor em $property não é um número decimal válido",
+    "class-validator.is-ean": "$property deve ser um número EAN (European Article Number)",
+    "class-validator.is-ean-each": "cada valor em $property deve ser um número EAN (European Article Number)",
+    "class-validator.is-email": "$property deve ser um e-mail",
+    "class-validator.is-email-each": "cada valor em $property deve ser um e-mail",
+    "class-validator.is-ethereum-address": "$property deve ser um endereço Ethereum",
+    "class-validator.is-ethereum-address-each": "cada valor em $property deve ser um endereço Ethereum",
+    "class-validator.is-firebase-push-id": "$property deve ser um Firebase Push Id",
+    "class-validator.is-firebase-push-id-each": "cada valor em $property deve ser um Firebase Push Id",
+    "class-validator.is-fqdn": "$property deve ser um nome de domínio válido",
+    "class-validator.is-fqdn-each": "cada valor em $property deve ser um nome de domínio válido",
+    "class-validator.is-full-width": "$property deve conter caracteres de largura total",
+    "class-validator.is-full-width-each": "cada valor em $property deve conter caracteres de largura total",
+    "class-validator.is-half-width": "$property deve conter caracteres de largura meia",
+    "class-validator.is-half-width-each": "cada valor em $property deve conter caracteres de largura meia",
+    "class-validator.is-hash": "$property deve ser um hash do tipo $constraint1",
+    "class-validator.is-hash-each": "cada valor em $property deve ser um hash do tipo $constraint1",
+    "class-validator.is-hexadecimal": "$property deve ser um número hexadecimal",
+    "class-validator.is-hexadecimal-each": "cada valor em $property deve ser um número hexadecimal",
+    "class-validator.is-hex-color": "$property deve ser uma cor hexadecimal",
+    "class-validator.is-hex-color-each": "cada valor em $property deve ser uma cor hexadecimal",
+    "class-validator.is-hsl": "$property deve ser uma cor HSL",
+    "class-validator.is-hsl-each": "cada valor em $property deve ser uma cor HSL",
+    "class-validator.is-iban": "$property deve ser um IBAN",
+    "class-validator.is-iban-each": "cada valor em $property deve ser um IBAN",
+    "class-validator.is-identity-card": "$property deve ser um número de identidade",
+    "class-validator.is-identity-card-each": "cada valor em $property deve ser um número de identidade",
+    "class-validator.is-ip": "$property deve ser um endereço IP",
+    "class-validator.is-ip-each": "cada valor em $property deve ser um endereço IP",
+    "class-validator.is-isbn": "$property deve ser um ISBN",
+    "class-validator.is-isbn-each": "cada valor em $property deve ser um ISBN",
+    "class-validator.is-isin": "$property deve ser um ISIN (identificador de ações/títulos)",
+    "class-validator.is-isin-each": "cada valor em $property deve ser um ISIN (identificador de ações/títulos)",
+    "class-validator.is-iso-8601": "$property deve ser uma string de data ISO 8601 válida",
+    "class-validator.is-iso-8601-each": "cada valor em $property deve ser uma string de data ISO 8601 válida",
+    "class-validator.is-iso31661-alpha2": "$property deve ser um código ISO31661 Alpha2 válido",
+    "class-validator.is-iso31661-alpha2-each": "cada valor em $property deve ser um código ISO31661 Alpha2 válido",
+    "class-validator.is-iso-31661-alpha3": "$property deve ser um código ISO31661 Alpha3 válido",
+    "class-validator.is-iso-31661-alpha3-each": "cada valor em $property deve ser um código ISO31661 Alpha3 válido",
+    "class-validator.is-isrc": "$property deve ser um ISRC",
+    "class-validator.is-isrc-each-each": "cada valor em $property deve ser um ISRC",
+    "class-validator.is-issn": "$property deve ser um ISSN",
+    "class-validator.is-issn-each": "cada valor em $property deve ser um ISSN",
+    "class-validator.is-json": "$property deve ser uma string JSON",
+    "class-validator.is-json-each": "cada valor em $property deve ser uma string JSON",
+    "class-validator.is-jwt": "$property deve ser uma string JWT",
+    "class-validator.is-jwt-each": "cada valor em $property deve ser uma string JWT",
+    "class-validator.is-locale": "$property deve ser um local",
+    "class-validator.is-locale-each": "cada valor em $property deve ser um local",
+    "class-validator.is-lowercase": "$property deve ser uma string em minúsculas",
+    "class-validator.is-lowercase-each": "cada valor em $property deve ser uma string em minúsculas",
+    "class-validator.is-mac-address": "$property deve ser um endereço MAC",
+    "class-validator.is-mac-address-each": "cada valor em $property deve ser um endereço MAC",
+    "class-validator.is-magnet-uri": "$property deve ser um formato de URI magnética",
+    "class-validator.is-magnet-uri-each": "cada valor em $property deve ser um formato de URI magnética",
+    "class-validator.is-military-time": "$property deve ser uma representação válida de hora militar no formato HH:MM",
+    "class-validator.is-military-time-each": "cada valor em $property deve ser uma representação válida de hora militar no formato HH:MM",
+    "class-validator.is-mime-type": "$property deve ser um formato MIME",
+    "class-validator.is-mime-type-each": "cada valor em $property deve ser um formato MIME",
+    "class-validator.is-mobile-phone": "$property deve ser um número de telefone",
+    "class-validator.is-mobile-phone-each": "cada valor em $property deve ser um número de telefone",
+    "class-validator.is-mongo-id": "$property deve ser um ID MongoDB",
+    "class-validator.is-mongo-id-each": "cada valor em $property deve ser um ID MongoDB",
+    "class-validator.is-multibyte": "$property deve conter um ou mais caracteres multibyte",
+    "class-validator.is-multibyte-each": "cada valor em $property deve conter um ou mais caracteres multibyte",
+    "class-validator.is-number-string": "$property deve ser uma string numérica",
+    "class-validator.is-number-string-each": "cada valor em $property deve ser uma string numérica",
+    "class-validator.is-octal": "$property deve ser um número octal válido",
+    "class-validator.is-octal-each": "cada valor em $property deve ser um número octal válido",
+    "class-validator.is-passport-number": "$property deve ser um número de passaporte válido",
+    "class-validator.is-passport-number-each": "cada valor em $property deve ser um número de passaporte válido",
+    "class-validator.is-phone-number": "$property deve ser um número de telefone válido",
+    "class-validator.is-phone-number-each": "cada valor em $property deve ser um número de telefone válido",
+    "class-validator.is-port": "$property deve ser uma porta",
+    "class-validator.is-port-each": "cada valor em $property deve ser uma porta",
+    "class-validator.is-postal-code": "$property deve ser um código postal",
+    "class-validator.is-postal-code-each": "cada valor em $property deve ser um código postal",
+    "class-validator.is-rfc-3339": "$property deve ser uma data RFC 3339",
+    "class-validator.is-rfc-3339-each": "cada valor em $property deve ser uma data RFC 3339",
+    "class-validator.is-rgb-color": "$property deve ser uma cor RGB",
+    "class-validator.is-rgb-color-each": "cada valor em $property deve ser uma cor RGB",
+    "class-validator.is-sem-ver": "$property deve ser uma especificação de versão semântica",
+    "class-validator.is-sem-ver-each": "cada valor em $property deve ser uma especificação de versão semântica",
+    "class-validator.is-strong-password": "$property não é forte o suficiente",
+    "class-validator.is-strong-password-each": "cada valor em $property não é forte o suficiente",
+    "class-validator.is-surrogate-pair": "$property deve conter caracteres de pares substitutos",
+    "class-validator.is-surrogate-pair-each": "cada valor em $property deve conter caracteres de pares substitutos",
+    "class-validator.is-time-zone": "$property deve ser um fuso horário IANA válido",
+    "class-validator.is-time-zone-each": "cada valor em $property deve ser um fuso horário IANA válido",
+    "class-validator.is-uppercase": "$property deve ser uma string em maiúsculas",
+    "class-validator.is-uppercase-each": "cada valor em $property deve ser uma string em maiúsculas",
+    "class-validator.is-url": "$property deve ser um endereço URL",
+    "class-validator.is-url-each": "cada valor em $property deve ser um endereço URL",
+    "class-validator.is-uuid": "$property deve ser um UUID",
+    "class-validator.is-uuid-each": "cada valor em $property deve ser um UUID",
+    "class-validator.is-variable-width": "$property deve conter caracteres de largura total e meia largura",
+    "class-validator.is-variable-width-each": "cada valor em $property deve conter caracteres de largura total e meia largura",
+    "class-validator.is-min-length": "$property deve ter pelo menos $constraint1 caracteres",
+    "class-validator.is-min-length-each": "cada valor em $property deve ter pelo menos $constraint1 caracteres",
+    "class-validator.is-max-length": "$property deve ter no máximo $constraint2 caracteres",
+    "class-validator.is-max-length-each": "cada valor em $property deve ter no máximo $constraint2 caracteres",
+    "class-validator.length": "$property deve ter pelo menos $constraint1 e no máximo $constraint2 caracteres",
+    "class-validator.length-each": "cada valor em $property deve ter pelo menos $constraint1 e no máximo $constraint2 caracteres",
+    "class-validator.matches": "$property deve corresponder à expressão regular $constraint1",
+    "class-validator.matches-each": "cada valor em $property deve corresponder à expressão regular $constraint1",
+    "class-validator.max-length": "$property deve ter no máximo $constraint1 caracteres",
+    "class-validator.max-length-each": "cada valor em $property deve ter no máximo $constraint1 caracteres",
+    "class-validator.min-length": "$property deve ter pelo menos $constraint1 caracteres",
+    "class-validator.min-length-each": "cada valor em $property deve ter pelo menos $constraint1 caracteres",
+    "class-validator.not-contains": "$property não deve conter a string $constraint1",
+    "class-validator.not-contains-each": "cada valor em $property não deve conter a string $constraint1",
+    "class-validator.is-array": "$property deve ser um array",
+    "class-validator.is-array-each": "cada valor em $property deve ser um array",
+    "class-validator.is-boolean": "$property deve ser um valor booleano",
+    "class-validator.is-boolean-each": "cada valor em $property deve ser um valor booleano",
+    "class-validator.is-date": "$property deve ser uma instância de Date",
+    "class-validator.is-date-each": "cada valor em $property deve ser uma instância de Date",
+    "class-validator.is-enum": "$property deve ser um dos seguintes valores: $constraint2",
+    "class-validator.is-enum-each": "cada valor em $property deve ser um dos seguintes valores: $constraint2",
+    "class-validator.is-int": "$property deve ser um número inteiro",
+    "class-validator.is-int-each": "cada valor em $property deve ser um número inteiro",
+    "class-validator.is-number": "$property deve ser um número conforme os requisitos especificados",
+    "class-validator.is-number-each": "cada valor em $property deve ser um número conforme os requisitos especificados",
+    "class-validator.is-object": "$property deve ser um objeto",
+    "class-validator.is-object-each": "cada valor em $property deve ser um objeto",
+    "class-validator.is-string": "$property deve ser uma string",
+    "class-validator.is-string-each": "cada valor em $property deve ser uma string"
+}
diff --git a/src/decorator/array/ArrayContains.ts b/src/decorator/array/ArrayContains.ts
index b2242c15d2..1724a95b2d 100644
--- a/src/decorator/array/ArrayContains.ts
+++ b/src/decorator/array/ArrayContains.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const ARRAY_CONTAINS = 'arrayContains';
 
@@ -24,10 +26,7 @@ export function ArrayContains(values: any[], validationOptions?: ValidationOptio
       constraints: [values],
       validator: {
         validate: (value, args): boolean => arrayContains(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain $constraint1 values',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'array-contains-each' : 'array-contains'),
       },
     },
     validationOptions
diff --git a/src/decorator/array/ArrayMaxSize.ts b/src/decorator/array/ArrayMaxSize.ts
index 726ebd6b5e..b37db0fa7b 100644
--- a/src/decorator/array/ArrayMaxSize.ts
+++ b/src/decorator/array/ArrayMaxSize.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const ARRAY_MAX_SIZE = 'arrayMaxSize';
 
@@ -22,10 +24,7 @@ export function ArrayMaxSize(max: number, validationOptions?: ValidationOptions)
       constraints: [max],
       validator: {
         validate: (value, args): boolean => arrayMaxSize(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain no more than $constraint1 elements',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'array-max-size-each' : 'array-max-size'),
       },
     },
     validationOptions
diff --git a/src/decorator/array/ArrayMinSize.ts b/src/decorator/array/ArrayMinSize.ts
index 750b297e90..f71d0ec75c 100644
--- a/src/decorator/array/ArrayMinSize.ts
+++ b/src/decorator/array/ArrayMinSize.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const ARRAY_MIN_SIZE = 'arrayMinSize';
 
@@ -22,10 +24,7 @@ export function ArrayMinSize(min: number, validationOptions?: ValidationOptions)
       constraints: [min],
       validator: {
         validate: (value, args): boolean => arrayMinSize(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain at least $constraint1 elements',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'array-min-size-each' : 'array-min-size'),
       },
     },
     validationOptions
diff --git a/src/decorator/array/ArrayNotContains.ts b/src/decorator/array/ArrayNotContains.ts
index fca6c4ccb5..1a4866a4e2 100644
--- a/src/decorator/array/ArrayNotContains.ts
+++ b/src/decorator/array/ArrayNotContains.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const ARRAY_NOT_CONTAINS = 'arrayNotContains';
 
@@ -24,10 +26,7 @@ export function ArrayNotContains(values: any[], validationOptions?: ValidationOp
       constraints: [values],
       validator: {
         validate: (value, args): boolean => arrayNotContains(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property should not contain $constraint1 values',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'array-not-contains-each' : 'array-not-contains'),
       },
     },
     validationOptions
diff --git a/src/decorator/array/ArrayNotEmpty.ts b/src/decorator/array/ArrayNotEmpty.ts
index 432d4c5248..7373d99461 100644
--- a/src/decorator/array/ArrayNotEmpty.ts
+++ b/src/decorator/array/ArrayNotEmpty.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const ARRAY_NOT_EMPTY = 'arrayNotEmpty';
 
@@ -21,7 +23,7 @@ export function ArrayNotEmpty(validationOptions?: ValidationOptions): PropertyDe
       name: ARRAY_NOT_EMPTY,
       validator: {
         validate: (value, args): boolean => arrayNotEmpty(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property should not be empty', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'array-not-empty-each' : 'array-not-empty'),
       },
     },
     validationOptions
diff --git a/src/decorator/array/ArrayUnique.ts b/src/decorator/array/ArrayUnique.ts
index 0979aeefc0..54cc9a7966 100644
--- a/src/decorator/array/ArrayUnique.ts
+++ b/src/decorator/array/ArrayUnique.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const ARRAY_UNIQUE = 'arrayUnique';
 export type ArrayUniqueIdentifier<T = any> = (o: T) => any;
@@ -35,7 +37,7 @@ export function ArrayUnique<T = any>(
       name: ARRAY_UNIQUE,
       validator: {
         validate: (value, args): boolean => arrayUnique(value, identifier),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + "All $property's elements must be unique", options),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'array-unique-each' : 'array-unique'),
       },
     },
     options
diff --git a/src/decorator/common/Equals.ts b/src/decorator/common/Equals.ts
index 91ef9e65d7..6bdc0ae891 100644
--- a/src/decorator/common/Equals.ts
+++ b/src/decorator/common/Equals.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const EQUALS = 'equals';
 
@@ -20,10 +22,7 @@ export function Equals(comparison: any, validationOptions?: ValidationOptions):
       constraints: [comparison],
       validator: {
         validate: (value, args): boolean => equals(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be equal to $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'equals-each' : 'equals')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsDefined.ts b/src/decorator/common/IsDefined.ts
index 8e445dde72..69626d8319 100644
--- a/src/decorator/common/IsDefined.ts
+++ b/src/decorator/common/IsDefined.ts
@@ -1,6 +1,8 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from './ValidateBy';
+import { ValidateBy } from './ValidateBy';
 import { ValidationTypes } from '../../validation/ValidationTypes';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 // isDefined is (yet) a special case
 export const IS_DEFINED = ValidationTypes.IS_DEFINED;
@@ -21,10 +23,7 @@ export function IsDefined(validationOptions?: ValidationOptions): PropertyDecora
       name: IS_DEFINED,
       validator: {
         validate: (value): boolean => isDefined(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property should not be null or undefined',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-defined-each' : 'is-defined')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsEmpty.ts b/src/decorator/common/IsEmpty.ts
index 1447811b9e..922b515d3e 100644
--- a/src/decorator/common/IsEmpty.ts
+++ b/src/decorator/common/IsEmpty.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_EMPTY = 'isEmpty';
 
@@ -19,7 +21,7 @@ export function IsEmpty(validationOptions?: ValidationOptions): PropertyDecorato
       name: IS_EMPTY,
       validator: {
         validate: (value, args): boolean => isEmpty(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be empty', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-empty-each' : 'is-empty')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsIn.ts b/src/decorator/common/IsIn.ts
index d074dcca5e..33153b49de 100644
--- a/src/decorator/common/IsIn.ts
+++ b/src/decorator/common/IsIn.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_IN = 'isIn';
 
@@ -20,10 +22,7 @@ export function IsIn(values: readonly any[], validationOptions?: ValidationOptio
       constraints: [values],
       validator: {
         validate: (value, args): boolean => isIn(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be one of the following values: $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-in-each' : 'is-in')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsLatLong.ts b/src/decorator/common/IsLatLong.ts
index becbf29c33..2d86f3d061 100644
--- a/src/decorator/common/IsLatLong.ts
+++ b/src/decorator/common/IsLatLong.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from './ValidateBy';
+import { ValidateBy } from './ValidateBy';
 import isLatLongValidator from 'validator/lib/isLatLong';
 
 export const IS_LATLONG = 'isLatLong';
@@ -20,10 +22,7 @@ export function IsLatLong(validationOptions?: ValidationOptions): PropertyDecora
       name: IS_LATLONG,
       validator: {
         validate: (value, args): boolean => isLatLong(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a latitude,longitude string',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-lat-long-each' : 'is-lat-long')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsLatitude.ts b/src/decorator/common/IsLatitude.ts
index 1be12e130e..04edab6a6b 100644
--- a/src/decorator/common/IsLatitude.ts
+++ b/src/decorator/common/IsLatitude.ts
@@ -1,6 +1,8 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from './ValidateBy';
+import { ValidateBy } from './ValidateBy';
 import { isLatLong } from './IsLatLong';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_LATITUDE = 'isLatitude';
 
@@ -20,10 +22,7 @@ export function IsLatitude(validationOptions?: ValidationOptions): PropertyDecor
       name: IS_LATITUDE,
       validator: {
         validate: (value, args): boolean => isLatitude(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a latitude string or number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-latitude-each' : 'is-latitude')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsLongitude.ts b/src/decorator/common/IsLongitude.ts
index 013f5387af..e76423419c 100644
--- a/src/decorator/common/IsLongitude.ts
+++ b/src/decorator/common/IsLongitude.ts
@@ -1,6 +1,8 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from './ValidateBy';
+import { ValidateBy } from './ValidateBy';
 import { isLatLong } from './IsLatLong';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_LONGITUDE = 'isLongitude';
 
@@ -20,10 +22,7 @@ export function IsLongitude(validationOptions?: ValidationOptions): PropertyDeco
       name: IS_LONGITUDE,
       validator: {
         validate: (value, args): boolean => isLongitude(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a longitude string or number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-longitude-each' : 'is-longitude')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsNotEmpty.ts b/src/decorator/common/IsNotEmpty.ts
index 605da09edc..a421ca161b 100644
--- a/src/decorator/common/IsNotEmpty.ts
+++ b/src/decorator/common/IsNotEmpty.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_NOT_EMPTY = 'isNotEmpty';
 
@@ -19,7 +21,7 @@ export function IsNotEmpty(validationOptions?: ValidationOptions): PropertyDecor
       name: IS_NOT_EMPTY,
       validator: {
         validate: (value, args): boolean => isNotEmpty(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property should not be empty', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-not-empty-each' : 'is-not-empty')
       },
     },
     validationOptions
diff --git a/src/decorator/common/IsNotIn.ts b/src/decorator/common/IsNotIn.ts
index 187e91d96a..74eac2fc1a 100644
--- a/src/decorator/common/IsNotIn.ts
+++ b/src/decorator/common/IsNotIn.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_NOT_IN = 'isNotIn';
 
@@ -20,10 +22,7 @@ export function IsNotIn(values: readonly any[], validationOptions?: ValidationOp
       constraints: [values],
       validator: {
         validate: (value, args): boolean => isNotIn(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property should not be one of the following values: $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-not-in-each' : 'is-not-in')
       },
     },
     validationOptions
diff --git a/src/decorator/common/NotEquals.ts b/src/decorator/common/NotEquals.ts
index ec5ecdefc0..026104d35b 100644
--- a/src/decorator/common/NotEquals.ts
+++ b/src/decorator/common/NotEquals.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const NOT_EQUALS = 'notEquals';
 
@@ -20,10 +22,7 @@ export function NotEquals(comparison: any, validationOptions?: ValidationOptions
       constraints: [comparison],
       validator: {
         validate: (value, args): boolean => notEquals(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property should not be equal to $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'not-equals-each' : 'not-equals')
       },
     },
     validationOptions
diff --git a/src/decorator/date/MaxDate.ts b/src/decorator/date/MaxDate.ts
index 0b8802b15f..0cc92ba289 100644
--- a/src/decorator/date/MaxDate.ts
+++ b/src/decorator/date/MaxDate.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const MAX_DATE = 'maxDate';
 
@@ -20,10 +22,7 @@ export function MaxDate(date: Date | (() => Date), validationOptions?: Validatio
       constraints: [date],
       validator: {
         validate: (value, args): boolean => maxDate(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => 'maximal allowed date for ' + eachPrefix + '$property is $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'max-date-each' : 'max-date')
       },
     },
     validationOptions
diff --git a/src/decorator/date/MinDate.ts b/src/decorator/date/MinDate.ts
index a0855e798e..48294dd675 100644
--- a/src/decorator/date/MinDate.ts
+++ b/src/decorator/date/MinDate.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const MIN_DATE = 'minDate';
 
@@ -20,10 +22,7 @@ export function MinDate(date: Date | (() => Date), validationOptions?: Validatio
       constraints: [date],
       validator: {
         validate: (value, args): boolean => minDate(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => 'minimal allowed date for ' + eachPrefix + '$property is $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'min-date-each' : 'min-date')
       },
     },
     validationOptions
diff --git a/src/decorator/number/IsDivisibleBy.ts b/src/decorator/number/IsDivisibleBy.ts
index 439948c403..6499335bd7 100644
--- a/src/decorator/number/IsDivisibleBy.ts
+++ b/src/decorator/number/IsDivisibleBy.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isDivisibleByValidator from 'validator/lib/isDivisibleBy';
 
 export const IS_DIVISIBLE_BY = 'isDivisibleBy';
@@ -21,10 +23,7 @@ export function IsDivisibleBy(num: number, validationOptions?: ValidationOptions
       constraints: [num],
       validator: {
         validate: (value, args): boolean => isDivisibleBy(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be divisible by $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-divisible-by-each' : 'is-divisible-by')
       },
     },
     validationOptions
diff --git a/src/decorator/number/IsNegative.ts b/src/decorator/number/IsNegative.ts
index 85463760fa..a7b1001552 100644
--- a/src/decorator/number/IsNegative.ts
+++ b/src/decorator/number/IsNegative.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_NEGATIVE = 'isNegative';
 
@@ -19,10 +21,7 @@ export function IsNegative(validationOptions?: ValidationOptions): PropertyDecor
       name: IS_NEGATIVE,
       validator: {
         validate: (value, args): boolean => isNegative(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a negative number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-negative-each' : 'is-negative')
       },
     },
     validationOptions
diff --git a/src/decorator/number/IsPositive.ts b/src/decorator/number/IsPositive.ts
index 41c888d678..cb36ad1adf 100644
--- a/src/decorator/number/IsPositive.ts
+++ b/src/decorator/number/IsPositive.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_POSITIVE = 'isPositive';
 
@@ -19,10 +21,7 @@ export function IsPositive(validationOptions?: ValidationOptions): PropertyDecor
       name: IS_POSITIVE,
       validator: {
         validate: (value, args): boolean => isPositive(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a positive number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-positive-each' : 'is-positive')
       },
     },
     validationOptions
diff --git a/src/decorator/number/Max.ts b/src/decorator/number/Max.ts
index d495af1893..8f73c25bd6 100644
--- a/src/decorator/number/Max.ts
+++ b/src/decorator/number/Max.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const MAX = 'max';
 
@@ -20,10 +22,7 @@ export function Max(maxValue: number, validationOptions?: ValidationOptions): Pr
       constraints: [maxValue],
       validator: {
         validate: (value, args): boolean => max(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must not be greater than $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'max-each' : 'max')
       },
     },
     validationOptions
diff --git a/src/decorator/number/Min.ts b/src/decorator/number/Min.ts
index 22d665d0a3..76ce639972 100644
--- a/src/decorator/number/Min.ts
+++ b/src/decorator/number/Min.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const MIN = 'min';
 
@@ -20,10 +22,7 @@ export function Min(minValue: number, validationOptions?: ValidationOptions): Pr
       constraints: [minValue],
       validator: {
         validate: (value, args): boolean => min(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must not be less than $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'min-each' : 'min')
       },
     },
     validationOptions
diff --git a/src/decorator/object/IsInstance.ts b/src/decorator/object/IsInstance.ts
index e265223ca7..02a0303991 100644
--- a/src/decorator/object/IsInstance.ts
+++ b/src/decorator/object/IsInstance.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_INSTANCE = 'isInstance';
 
@@ -25,13 +27,14 @@ export function IsInstance(
       constraints: [targetType],
       validator: {
         validate: (value, args): boolean => isInstance(value, args?.constraints[0]),
-        defaultMessage: buildMessage((eachPrefix, args) => {
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => {
           if (args?.constraints[0]) {
-            return eachPrefix + `$property must be an instance of ${args?.constraints[0].name as string}`;
-          } else {
-            return eachPrefix + `${IS_INSTANCE} decorator expects and object as value, but got falsy value.`;
+            return translate(validationOptions?.each ? 'is-instance-each' : 'is-instance');
           }
-        }, validationOptions),
+
+          const eachPrefix = validationOptions?.each ? 'each value ' : '';
+          return eachPrefix + `${IS_INSTANCE} decorator expects and object as value, but got falsy value.`;
+        },
       },
     },
     validationOptions
diff --git a/src/decorator/object/IsNotEmptyObject.ts b/src/decorator/object/IsNotEmptyObject.ts
index 64aada8014..5e8bdbf23a 100644
--- a/src/decorator/object/IsNotEmptyObject.ts
+++ b/src/decorator/object/IsNotEmptyObject.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import { isObject } from '../typechecker/IsObject';
 
 export const IS_NOT_EMPTY_OBJECT = 'isNotEmptyObject';
@@ -40,10 +42,7 @@ export function IsNotEmptyObject(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isNotEmptyObject(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a non-empty object',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-not-empty-object-each' : 'is-not-empty-object')
       },
     },
     validationOptions
diff --git a/src/decorator/string/Contains.ts b/src/decorator/string/Contains.ts
index da2cc335c8..57aa71491b 100644
--- a/src/decorator/string/Contains.ts
+++ b/src/decorator/string/Contains.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import containsValidator from 'validator/lib/contains';
 
 export const CONTAINS = 'contains';
@@ -23,10 +25,7 @@ export function Contains(seed: string, validationOptions?: ValidationOptions): P
       constraints: [seed],
       validator: {
         validate: (value, args): boolean => contains(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain a $constraint1 string',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'contains-each' : 'contains'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsAlpha.ts b/src/decorator/string/IsAlpha.ts
index 090007b390..60aacd67c7 100644
--- a/src/decorator/string/IsAlpha.ts
+++ b/src/decorator/string/IsAlpha.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isAlphaValidator from 'validator/lib/isAlpha';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_ALPHA = 'isAlpha';
 
@@ -24,10 +26,7 @@ export function IsAlpha(locale?: ValidatorJS.AlphaLocale, validationOptions?: Va
       constraints: [locale],
       validator: {
         validate: (value, args): boolean => isAlpha(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain only letters (a-zA-Z)',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-alpha' : 'is-alpha'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsAlphanumeric.ts b/src/decorator/string/IsAlphanumeric.ts
index f0dc2e5f89..d8482d35b5 100644
--- a/src/decorator/string/IsAlphanumeric.ts
+++ b/src/decorator/string/IsAlphanumeric.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isAlphanumericValidator from 'validator/lib/isAlphanumeric';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_ALPHANUMERIC = 'isAlphanumeric';
 
@@ -27,10 +29,7 @@ export function IsAlphanumeric(
       constraints: [locale],
       validator: {
         validate: (value, args): boolean => isAlphanumeric(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain only letters and numbers',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-alphanumeric-each' : 'is-alphanumeric'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsAscii.ts b/src/decorator/string/IsAscii.ts
index 05f74725dd..354caf79b1 100644
--- a/src/decorator/string/IsAscii.ts
+++ b/src/decorator/string/IsAscii.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isAsciiValidator from 'validator/lib/isAscii';
 
 export const IS_ASCII = 'isAscii';
@@ -22,10 +24,7 @@ export function IsAscii(validationOptions?: ValidationOptions): PropertyDecorato
       name: IS_ASCII,
       validator: {
         validate: (value, args): boolean => isAscii(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain only ASCII characters',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-ascii-each' : 'is-ascii'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsBIC.ts b/src/decorator/string/IsBIC.ts
index b530e67758..a684973189 100644
--- a/src/decorator/string/IsBIC.ts
+++ b/src/decorator/string/IsBIC.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isBICValidator from 'validator/lib/isBIC';
 
 export const IS_BIC = 'isBIC';
@@ -22,10 +24,7 @@ export function IsBIC(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_BIC,
       validator: {
         validate: (value, args): boolean => isBIC(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a BIC or SWIFT code',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-bic-each' : 'is-bic'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsBase32.ts b/src/decorator/string/IsBase32.ts
index 99958d0d3e..79e740c6b0 100644
--- a/src/decorator/string/IsBase32.ts
+++ b/src/decorator/string/IsBase32.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isBase32Validator from 'validator/lib/isBase32';
 
 export const IS_BASE32 = 'isBase32';
@@ -22,7 +24,7 @@ export function IsBase32(validationOptions?: ValidationOptions): PropertyDecorat
       name: IS_BASE32,
       validator: {
         validate: (value, args): boolean => isBase32(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be base32 encoded', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-base32-each' : 'is-base32'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsBase58.ts b/src/decorator/string/IsBase58.ts
index cd474a0c2c..c08094ac7b 100644
--- a/src/decorator/string/IsBase58.ts
+++ b/src/decorator/string/IsBase58.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isBase58Validator from 'validator/lib/isBase58';
 
 export const IS_BASE58 = 'isBase58';
@@ -22,7 +24,7 @@ export function IsBase58(validationOptions?: ValidationOptions): PropertyDecorat
       name: IS_BASE58,
       validator: {
         validate: (value, args): boolean => isBase58(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be base58 encoded', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-base58-each' : 'is-base58'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsBase64.ts b/src/decorator/string/IsBase64.ts
index 2c5cd3e5be..16b73071c0 100644
--- a/src/decorator/string/IsBase64.ts
+++ b/src/decorator/string/IsBase64.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isBase64Validator from 'validator/lib/isBase64';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_BASE64 = 'isBase64';
 
@@ -27,7 +29,7 @@ export function IsBase64(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isBase64(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be base64 encoded', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-base64-each' : 'is-base64'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsBooleanString.ts b/src/decorator/string/IsBooleanString.ts
index e53d71b37b..bbab6dca5f 100644
--- a/src/decorator/string/IsBooleanString.ts
+++ b/src/decorator/string/IsBooleanString.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isBooleanValidator from 'validator/lib/isBoolean';
 
 export const IS_BOOLEAN_STRING = 'isBooleanString';
@@ -22,10 +24,7 @@ export function IsBooleanString(validationOptions?: ValidationOptions): Property
       name: IS_BOOLEAN_STRING,
       validator: {
         validate: (value, args): boolean => isBooleanString(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a boolean string',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-boolean-string-each' : 'is-boolean-string'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsBtcAddress.ts b/src/decorator/string/IsBtcAddress.ts
index f9162adcec..68ae0f5dff 100644
--- a/src/decorator/string/IsBtcAddress.ts
+++ b/src/decorator/string/IsBtcAddress.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isBtcAddressValidator from 'validator/lib/isBtcAddress';
 
 export const IS_BTC_ADDRESS = 'isBtcAddress';
@@ -22,7 +24,7 @@ export function IsBtcAddress(validationOptions?: ValidationOptions): PropertyDec
       name: IS_BTC_ADDRESS,
       validator: {
         validate: (value, args): boolean => isBtcAddress(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a BTC address', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-btc-address-each' : 'is-btc-address'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsByteLength.ts b/src/decorator/string/IsByteLength.ts
index 334e209733..2dd301b1d6 100644
--- a/src/decorator/string/IsByteLength.ts
+++ b/src/decorator/string/IsByteLength.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isByteLengthValidator from 'validator/lib/isByteLength';
 
 export const IS_BYTE_LENGTH = 'isByteLength';
@@ -23,10 +25,7 @@ export function IsByteLength(min: number, max?: number, validationOptions?: Vali
       constraints: [min, max],
       validator: {
         validate: (value, args): boolean => isByteLength(value, args?.constraints[0], args?.constraints[1]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + "$property's byte length must fall into ($constraint1, $constraint2) range",
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-byte-length-each' : 'is-byte-length'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsCreditCard.ts b/src/decorator/string/IsCreditCard.ts
index 2511d1930c..9f2e92887d 100644
--- a/src/decorator/string/IsCreditCard.ts
+++ b/src/decorator/string/IsCreditCard.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isCreditCardValidator from 'validator/lib/isCreditCard';
 
 export const IS_CREDIT_CARD = 'isCreditCard';
@@ -22,7 +24,7 @@ export function IsCreditCard(validationOptions?: ValidationOptions): PropertyDec
       name: IS_CREDIT_CARD,
       validator: {
         validate: (value, args): boolean => isCreditCard(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a credit card', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-credit-card-each' : 'is-credit-card'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsCurrency.ts b/src/decorator/string/IsCurrency.ts
index 8ebfdd9366..da24d706d3 100644
--- a/src/decorator/string/IsCurrency.ts
+++ b/src/decorator/string/IsCurrency.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isCurrencyValidator from 'validator/lib/isCurrency';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_CURRENCY = 'isCurrency';
 
@@ -27,7 +29,7 @@ export function IsCurrency(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isCurrency(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a currency', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-currency-each' : 'is-currency'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsDataURI.ts b/src/decorator/string/IsDataURI.ts
index f07e5fefae..4d8245c3eb 100644
--- a/src/decorator/string/IsDataURI.ts
+++ b/src/decorator/string/IsDataURI.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isDataURIValidator from 'validator/lib/isDataURI';
 
 export const IS_DATA_URI = 'isDataURI';
@@ -22,10 +24,7 @@ export function IsDataURI(validationOptions?: ValidationOptions): PropertyDecora
       name: IS_DATA_URI,
       validator: {
         validate: (value, args): boolean => isDataURI(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a data uri format',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-data-uri-each' : 'is-data-uri'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsDateString.ts b/src/decorator/string/IsDateString.ts
index 5fd91af73d..1e3cc21e76 100644
--- a/src/decorator/string/IsDateString.ts
+++ b/src/decorator/string/IsDateString.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import * as ValidatorJS from 'validator';
 import { isISO8601 } from './IsISO8601';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_DATE_STRING = 'isDateString';
 
@@ -25,10 +27,7 @@ export function IsDateString(
       constraints: [options],
       validator: {
         validate: (value): boolean => isDateString(value, options),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid ISO 8601 date string',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-date-string-each' : 'is-date-string'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsDecimal.ts b/src/decorator/string/IsDecimal.ts
index 3996d296fc..226f47b102 100644
--- a/src/decorator/string/IsDecimal.ts
+++ b/src/decorator/string/IsDecimal.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isDecimalValidator from 'validator/lib/isDecimal';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_DECIMAL = 'isDecimal';
 
@@ -27,10 +29,7 @@ export function IsDecimal(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isDecimal(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property is not a valid decimal number.',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-decimal-each' : 'is-decimal'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsEAN.ts b/src/decorator/string/IsEAN.ts
index 73669e969a..137dccb323 100644
--- a/src/decorator/string/IsEAN.ts
+++ b/src/decorator/string/IsEAN.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isEANValidator from 'validator/lib/isEAN';
 
 export const IS_EAN = 'isEAN';
@@ -22,10 +24,7 @@ export function IsEAN(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_EAN,
       validator: {
         validate: (value, args): boolean => isEAN(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be an EAN (European Article Number)',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-ean-each' : 'is-ean'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsEmail.ts b/src/decorator/string/IsEmail.ts
index 790ee44c51..9ca2587ad2 100644
--- a/src/decorator/string/IsEmail.ts
+++ b/src/decorator/string/IsEmail.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isEmailValidator from 'validator/lib/isEmail';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_EMAIL = 'isEmail';
 
@@ -27,7 +29,7 @@ export function IsEmail(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isEmail(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be an email', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-email-each' : 'is-email'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsEthereumAddress.ts b/src/decorator/string/IsEthereumAddress.ts
index cf8dbdbb1b..9407fb1727 100644
--- a/src/decorator/string/IsEthereumAddress.ts
+++ b/src/decorator/string/IsEthereumAddress.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isEthereumAddressValidator from 'validator/lib/isEthereumAddress';
 
 export const IS_ETHEREUM_ADDRESS = 'isEthereumAddress';
@@ -22,10 +24,7 @@ export function IsEthereumAddress(validationOptions?: ValidationOptions): Proper
       name: IS_ETHEREUM_ADDRESS,
       validator: {
         validate: (value, args): boolean => isEthereumAddress(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be an Ethereum address',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-ethereum-address-each' : 'is-ethereum-address'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsFQDN.ts b/src/decorator/string/IsFQDN.ts
index 3c6683d68e..aa2941248e 100644
--- a/src/decorator/string/IsFQDN.ts
+++ b/src/decorator/string/IsFQDN.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isFqdnValidator from 'validator/lib/isFQDN';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_FQDN = 'isFqdn';
 
@@ -24,10 +26,7 @@ export function IsFQDN(options?: ValidatorJS.IsFQDNOptions, validationOptions?:
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isFQDN(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid domain name',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-fqdn-each' : 'is-fqdn'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsFirebasePushId.ts b/src/decorator/string/IsFirebasePushId.ts
index 1d81230c7b..84be790a63 100644
--- a/src/decorator/string/IsFirebasePushId.ts
+++ b/src/decorator/string/IsFirebasePushId.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_FIREBASE_PUSH_ID = 'IsFirebasePushId';
 
@@ -22,10 +24,7 @@ export function IsFirebasePushId(validationOptions?: ValidationOptions): Propert
       name: IS_FIREBASE_PUSH_ID,
       validator: {
         validate: (value, args): boolean => isFirebasePushId(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a Firebase Push Id',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-firebase-push-id-each' : 'is-firebase-push-id'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsFullWidth.ts b/src/decorator/string/IsFullWidth.ts
index cb9a7cc3a5..919835f463 100644
--- a/src/decorator/string/IsFullWidth.ts
+++ b/src/decorator/string/IsFullWidth.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isFullWidthValidator from 'validator/lib/isFullWidth';
 
 export const IS_FULL_WIDTH = 'isFullWidth';
@@ -22,10 +24,7 @@ export function IsFullWidth(validationOptions?: ValidationOptions): PropertyDeco
       name: IS_FULL_WIDTH,
       validator: {
         validate: (value, args): boolean => isFullWidth(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain a full-width characters',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-full-width-each' : 'is-full-width'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsHSL.ts b/src/decorator/string/IsHSL.ts
index 401cbc6fb1..a644e5f04a 100644
--- a/src/decorator/string/IsHSL.ts
+++ b/src/decorator/string/IsHSL.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isHSLValidator from 'validator/lib/isHSL';
 
 export const IS_HSL = 'isHSL';
@@ -24,7 +26,7 @@ export function IsHSL(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_HSL,
       validator: {
         validate: (value, args): boolean => isHSL(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a HSL color', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-hsl-each' : 'is-hsl'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsHalfWidth.ts b/src/decorator/string/IsHalfWidth.ts
index 0f04c94348..945073d995 100644
--- a/src/decorator/string/IsHalfWidth.ts
+++ b/src/decorator/string/IsHalfWidth.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isHalfWidthValidator from 'validator/lib/isHalfWidth';
 
 export const IS_HALF_WIDTH = 'isHalfWidth';
@@ -22,10 +24,7 @@ export function IsHalfWidth(validationOptions?: ValidationOptions): PropertyDeco
       name: IS_HALF_WIDTH,
       validator: {
         validate: (value, args): boolean => isHalfWidth(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain a half-width characters',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-half-width-each' : 'is-half-width'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsHash.ts b/src/decorator/string/IsHash.ts
index 0794de5844..37a20b5bef 100644
--- a/src/decorator/string/IsHash.ts
+++ b/src/decorator/string/IsHash.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isHashValidator from 'validator/lib/isHash';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_HASH = 'isHash';
 
@@ -26,10 +28,7 @@ export function IsHash(algorithm: string, validationOptions?: ValidationOptions)
       constraints: [algorithm],
       validator: {
         validate: (value, args): boolean => isHash(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a hash of type $constraint1',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-hash-each' : 'is-hash'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsHexColor.ts b/src/decorator/string/IsHexColor.ts
index c72c471135..a5fa45cc65 100644
--- a/src/decorator/string/IsHexColor.ts
+++ b/src/decorator/string/IsHexColor.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isHexColorValidator from 'validator/lib/isHexColor';
 
 export const IS_HEX_COLOR = 'isHexColor';
@@ -22,10 +24,7 @@ export function IsHexColor(validationOptions?: ValidationOptions): PropertyDecor
       name: IS_HEX_COLOR,
       validator: {
         validate: (value, args): boolean => isHexColor(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a hexadecimal color',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-hex-color-each' : 'is-hex-color'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsHexadecimal.ts b/src/decorator/string/IsHexadecimal.ts
index 26d3eb3e34..b4d7b529c0 100644
--- a/src/decorator/string/IsHexadecimal.ts
+++ b/src/decorator/string/IsHexadecimal.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isHexadecimalValidator from 'validator/lib/isHexadecimal';
 
 export const IS_HEXADECIMAL = 'isHexadecimal';
@@ -22,10 +24,7 @@ export function IsHexadecimal(validationOptions?: ValidationOptions): PropertyDe
       name: IS_HEXADECIMAL,
       validator: {
         validate: (value, args): boolean => isHexadecimal(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a hexadecimal number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-hexadecimal-each' : 'is-hexadecimal'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsIBAN.ts b/src/decorator/string/IsIBAN.ts
index d0a159fc83..150cbd4285 100644
--- a/src/decorator/string/IsIBAN.ts
+++ b/src/decorator/string/IsIBAN.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isIBANValidator from 'validator/lib/isIBAN';
 
 export const IS_IBAN = 'isIBAN';
@@ -22,7 +24,7 @@ export function IsIBAN(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_IBAN,
       validator: {
         validate: (value, args): boolean => isIBAN(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be an IBAN', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-iban-each' : 'is-iban'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsIP.ts b/src/decorator/string/IsIP.ts
index 01fc55d2aa..34de302566 100644
--- a/src/decorator/string/IsIP.ts
+++ b/src/decorator/string/IsIP.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isIPValidator from 'validator/lib/isIP';
 
 export type IsIpVersion = '4' | '6' | 4 | 6;
@@ -27,7 +29,7 @@ export function IsIP(version?: IsIpVersion, validationOptions?: ValidationOption
       constraints: [version],
       validator: {
         validate: (value, args): boolean => isIP(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be an ip address', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-ip-each' : 'is-ip'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsISBN.ts b/src/decorator/string/IsISBN.ts
index 336d62c61d..d23532c021 100644
--- a/src/decorator/string/IsISBN.ts
+++ b/src/decorator/string/IsISBN.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isIsbnValidator from 'validator/lib/isISBN';
 
 export type IsISBNVersion = '10' | '13' | 10 | 13;
@@ -27,7 +29,7 @@ export function IsISBN(version?: IsISBNVersion, validationOptions?: ValidationOp
       constraints: [version],
       validator: {
         validate: (value, args): boolean => isISBN(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be an ISBN', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-isbn-each' : 'is-isbn'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsISIN.ts b/src/decorator/string/IsISIN.ts
index 2f9b143b1d..92309bcc5e 100644
--- a/src/decorator/string/IsISIN.ts
+++ b/src/decorator/string/IsISIN.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isIsinValidator from 'validator/lib/isISIN';
 
 export const IS_ISIN = 'isIsin';
@@ -22,10 +24,7 @@ export function IsISIN(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_ISIN,
       validator: {
         validate: (value, args): boolean => isISIN(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be an ISIN (stock/security identifier)',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-isin-each' : 'is-isin'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsISO31661Alpha2.ts b/src/decorator/string/IsISO31661Alpha2.ts
index 87b19551ae..99bae94efe 100644
--- a/src/decorator/string/IsISO31661Alpha2.ts
+++ b/src/decorator/string/IsISO31661Alpha2.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isISO31661Alpha2Validator from 'validator/lib/isISO31661Alpha2';
 
 export const IS_ISO31661_ALPHA_2 = 'isISO31661Alpha2';
@@ -20,10 +22,7 @@ export function IsISO31661Alpha2(validationOptions?: ValidationOptions): Propert
       name: IS_ISO31661_ALPHA_2,
       validator: {
         validate: (value, args): boolean => isISO31661Alpha2(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid ISO31661 Alpha2 code',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-iso31661-alpha2-each' : 'is-iso31661-alpha2'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsISO31661Alpha3.ts b/src/decorator/string/IsISO31661Alpha3.ts
index bf43ff519b..46e8b67708 100644
--- a/src/decorator/string/IsISO31661Alpha3.ts
+++ b/src/decorator/string/IsISO31661Alpha3.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isISO31661Alpha3Validator from 'validator/lib/isISO31661Alpha3';
 
 export const IS_ISO31661_ALPHA_3 = 'isISO31661Alpha3';
@@ -20,10 +22,7 @@ export function IsISO31661Alpha3(validationOptions?: ValidationOptions): Propert
       name: IS_ISO31661_ALPHA_3,
       validator: {
         validate: (value, args): boolean => isISO31661Alpha3(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid ISO31661 Alpha3 code',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-iso-31661-alpha3-each' : 'is-iso-31661-alpha3'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsISO8601.ts b/src/decorator/string/IsISO8601.ts
index ca1f771851..f207f7db4e 100644
--- a/src/decorator/string/IsISO8601.ts
+++ b/src/decorator/string/IsISO8601.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isIso8601Validator from 'validator/lib/isISO8601';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_ISO8601 = 'isIso8601';
 
@@ -29,10 +31,7 @@ export function IsISO8601(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isISO8601(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid ISO 8601 date string',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-iso-8601-each' : 'is-iso-8601'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsISRC.ts b/src/decorator/string/IsISRC.ts
index f41b3c3cdc..6896b4604e 100644
--- a/src/decorator/string/IsISRC.ts
+++ b/src/decorator/string/IsISRC.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isISRCValidator from 'validator/lib/isISRC';
 
 export const IS_ISRC = 'isISRC';
@@ -22,7 +24,7 @@ export function IsISRC(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_ISRC,
       validator: {
         validate: (value, args): boolean => isISRC(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be an ISRC', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-isrc-each' : 'is-isrc'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsISSN.ts b/src/decorator/string/IsISSN.ts
index 6227976882..a7c8a6e9a3 100644
--- a/src/decorator/string/IsISSN.ts
+++ b/src/decorator/string/IsISSN.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isISSNValidator from 'validator/lib/isISSN';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_ISSN = 'isISSN';
 
@@ -24,7 +26,7 @@ export function IsISSN(options?: ValidatorJS.IsISSNOptions, validationOptions?:
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isISSN(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a ISSN', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-issn-each' : 'is-issn'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsIdentityCard.ts b/src/decorator/string/IsIdentityCard.ts
index 54834f8f84..c8a442d300 100644
--- a/src/decorator/string/IsIdentityCard.ts
+++ b/src/decorator/string/IsIdentityCard.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isIdentityCardValidator from 'validator/lib/isIdentityCard';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_IDENTITY_CARD = 'isIdentityCard';
 
@@ -31,10 +33,7 @@ export function IsIdentityCard(
       constraints: [locale],
       validator: {
         validate: (value, args): boolean => isIdentityCard(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a identity card number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-identity-card-each' : 'is-identity-card'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsJSON.ts b/src/decorator/string/IsJSON.ts
index 2bdf8f04b9..6f3fd3f64f 100644
--- a/src/decorator/string/IsJSON.ts
+++ b/src/decorator/string/IsJSON.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isJSONValidator from 'validator/lib/isJSON';
 
 export const IS_JSON = 'isJson';
@@ -22,7 +24,7 @@ export function IsJSON(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_JSON,
       validator: {
         validate: (value, args): boolean => isJSON(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a json string', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-json-each' : 'is-json'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsJWT.ts b/src/decorator/string/IsJWT.ts
index 69ecc900a7..c6b00d3cd7 100644
--- a/src/decorator/string/IsJWT.ts
+++ b/src/decorator/string/IsJWT.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isJwtValidator from 'validator/lib/isJWT';
 
 export const IS_JWT = 'isJwt';
@@ -22,7 +24,7 @@ export function IsJWT(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_JWT,
       validator: {
         validate: (value, args): boolean => isJWT(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a jwt string', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-jwt-each' : 'is-jwt'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsLocale.ts b/src/decorator/string/IsLocale.ts
index 043ddf2510..b5ec8672ff 100644
--- a/src/decorator/string/IsLocale.ts
+++ b/src/decorator/string/IsLocale.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isLocaleValidator from 'validator/lib/isLocale';
 
 export const IS_LOCALE = 'isLocale';
@@ -22,7 +24,7 @@ export function IsLocale(validationOptions?: ValidationOptions): PropertyDecorat
       name: IS_LOCALE,
       validator: {
         validate: (value, args): boolean => isLocale(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be locale', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-locale-each' : 'is-locale'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsLowercase.ts b/src/decorator/string/IsLowercase.ts
index 1042dadcfd..12e5aa9aad 100644
--- a/src/decorator/string/IsLowercase.ts
+++ b/src/decorator/string/IsLowercase.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isLowercaseValidator from 'validator/lib/isLowercase';
 
 export const IS_LOWERCASE = 'isLowercase';
@@ -22,10 +24,7 @@ export function IsLowercase(validationOptions?: ValidationOptions): PropertyDeco
       name: IS_LOWERCASE,
       validator: {
         validate: (value, args): boolean => isLowercase(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a lowercase string',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-lowercase-each' : 'is-lowercase'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsMacAddress.ts b/src/decorator/string/IsMacAddress.ts
index f2e3ea745f..0beddfaaa7 100644
--- a/src/decorator/string/IsMacAddress.ts
+++ b/src/decorator/string/IsMacAddress.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions, isValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isMacAddressValidator from 'validator/lib/isMACAddress';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_MAC_ADDRESS = 'isMacAddress';
 
@@ -37,7 +39,7 @@ export function IsMACAddress(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isMACAddress(value, options),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a MAC Address', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-mac-address-each' : 'is-mac-address'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsMagnetURI.ts b/src/decorator/string/IsMagnetURI.ts
index a4758dca65..a7e45805dd 100644
--- a/src/decorator/string/IsMagnetURI.ts
+++ b/src/decorator/string/IsMagnetURI.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isMagnetURIValidator from 'validator/lib/isMagnetURI';
 
 export const IS_MAGNET_URI = 'isMagnetURI';
@@ -22,10 +24,7 @@ export function IsMagnetURI(validationOptions?: ValidationOptions): PropertyDeco
       name: IS_MAGNET_URI,
       validator: {
         validate: (value, args): boolean => isMagnetURI(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be magnet uri format',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-magnet-uri-each' : 'is-magnet-uri'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsMilitaryTime.ts b/src/decorator/string/IsMilitaryTime.ts
index 6d209b2ac1..ba7178a86c 100644
--- a/src/decorator/string/IsMilitaryTime.ts
+++ b/src/decorator/string/IsMilitaryTime.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import matchesValidator from 'validator/lib/matches';
 
 export const IS_MILITARY_TIME = 'isMilitaryTime';
@@ -23,10 +25,7 @@ export function IsMilitaryTime(validationOptions?: ValidationOptions): PropertyD
       name: IS_MILITARY_TIME,
       validator: {
         validate: (value, args): boolean => isMilitaryTime(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid representation of military time in the format HH:MM',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-military-time-each' : 'is-military-time'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsMimeType.ts b/src/decorator/string/IsMimeType.ts
index edc5136953..5d40551416 100644
--- a/src/decorator/string/IsMimeType.ts
+++ b/src/decorator/string/IsMimeType.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isMimeTypeValidator from 'validator/lib/isMimeType';
 
 export const IS_MIME_TYPE = 'isMimeType';
@@ -22,10 +24,7 @@ export function IsMimeType(validationOptions?: ValidationOptions): PropertyDecor
       name: IS_MIME_TYPE,
       validator: {
         validate: (value, args): boolean => isMimeType(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be MIME type format',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-mime-type-each' : 'is-mime-type'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsMobilePhone.ts b/src/decorator/string/IsMobilePhone.ts
index 34859b5007..66d7699e22 100644
--- a/src/decorator/string/IsMobilePhone.ts
+++ b/src/decorator/string/IsMobilePhone.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isMobilePhoneValidator from 'validator/lib/isMobilePhone';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_MOBILE_PHONE = 'isMobilePhone';
 
@@ -48,7 +50,7 @@ export function IsMobilePhone(
       constraints: [locale, options],
       validator: {
         validate: (value, args): boolean => isMobilePhone(value, args?.constraints[0], args?.constraints[1]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a phone number', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-mobile-phone-each' : 'is-mobile-phone'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsMongoId.ts b/src/decorator/string/IsMongoId.ts
index fa8507fb66..6267163a30 100644
--- a/src/decorator/string/IsMongoId.ts
+++ b/src/decorator/string/IsMongoId.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isMongoIdValidator from 'validator/lib/isMongoId';
 
 export const IS_MONGO_ID = 'isMongoId';
@@ -22,7 +24,7 @@ export function IsMongoId(validationOptions?: ValidationOptions): PropertyDecora
       name: IS_MONGO_ID,
       validator: {
         validate: (value, args): boolean => isMongoId(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a mongodb id', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-mongo-id-each' : 'is-mongo-id'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsMultibyte.ts b/src/decorator/string/IsMultibyte.ts
index c295b640c9..d0a8c45966 100644
--- a/src/decorator/string/IsMultibyte.ts
+++ b/src/decorator/string/IsMultibyte.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isMultibyteValidator from 'validator/lib/isMultibyte';
 
 export const IS_MULTIBYTE = 'isMultibyte';
@@ -22,10 +24,7 @@ export function IsMultibyte(validationOptions?: ValidationOptions): PropertyDeco
       name: IS_MULTIBYTE,
       validator: {
         validate: (value, args): boolean => isMultibyte(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain one or more multibyte chars',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-multibyte-each' : 'is-multibyte'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsNumberString.ts b/src/decorator/string/IsNumberString.ts
index 45f6b67c25..8515e8556c 100644
--- a/src/decorator/string/IsNumberString.ts
+++ b/src/decorator/string/IsNumberString.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isNumericValidator from 'validator/lib/isNumeric';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_NUMBER_STRING = 'isNumberString';
 
@@ -27,7 +29,7 @@ export function IsNumberString(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isNumberString(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a number string', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-number-string-each' : 'is-number-string'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsOctal.ts b/src/decorator/string/IsOctal.ts
index 4427926455..c0ee70799c 100644
--- a/src/decorator/string/IsOctal.ts
+++ b/src/decorator/string/IsOctal.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isOctalValidator from 'validator/lib/isOctal';
 
 export const IS_OCTAL = 'isOctal';
@@ -22,10 +24,7 @@ export function IsOctal(validationOptions?: ValidationOptions): PropertyDecorato
       name: IS_OCTAL,
       validator: {
         validate: (value, args): boolean => isOctal(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be valid octal number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-octal-each' : 'is-octal'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsPassportNumber.ts b/src/decorator/string/IsPassportNumber.ts
index e900aeed2e..20dac6aad7 100644
--- a/src/decorator/string/IsPassportNumber.ts
+++ b/src/decorator/string/IsPassportNumber.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isPassportNumberValidator from 'validator/lib/isPassportNumber';
 
 export const IS_PASSPORT_NUMBER = 'isPassportNumber';
@@ -23,10 +25,7 @@ export function IsPassportNumber(countryCode: string, validationOptions?: Valida
       constraints: [countryCode],
       validator: {
         validate: (value, args): boolean => isPassportNumber(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be valid passport number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-passport-number-each' : 'is-passport-number'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsPhoneNumber.ts b/src/decorator/string/IsPhoneNumber.ts
index 65744a99ab..592e47ff2f 100644
--- a/src/decorator/string/IsPhoneNumber.ts
+++ b/src/decorator/string/IsPhoneNumber.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import { parsePhoneNumber, CountryCode } from 'libphonenumber-js/max';
 
 export const IS_PHONE_NUMBER = 'isPhoneNumber';
@@ -48,10 +50,7 @@ export function IsPhoneNumber(region?: CountryCode, validationOptions?: Validati
       constraints: [region],
       validator: {
         validate: (value, args): boolean => isPhoneNumber(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid phone number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-phone-number-each' : 'is-phone-number'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsPort.ts b/src/decorator/string/IsPort.ts
index d7809e3c42..5582403b1f 100644
--- a/src/decorator/string/IsPort.ts
+++ b/src/decorator/string/IsPort.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isPortValidator from 'validator/lib/isPort';
 
 export const IS_PORT = 'isPort';
@@ -20,7 +22,7 @@ export function IsPort(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_PORT,
       validator: {
         validate: (value, args): boolean => isPort(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a port', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-port-each' : 'is-port'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsPostalCode.ts b/src/decorator/string/IsPostalCode.ts
index 507a462c64..a687f0e90f 100644
--- a/src/decorator/string/IsPostalCode.ts
+++ b/src/decorator/string/IsPostalCode.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isPostalCodeValidator from 'validator/lib/isPostalCode';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_POSTAL_CODE = 'isPostalCode';
 
@@ -27,7 +29,7 @@ export function IsPostalCode(
       constraints: [locale],
       validator: {
         validate: (value, args): boolean => isPostalCode(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a postal code', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-postal-code-each' : 'is-postal-code'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsRFC3339.ts b/src/decorator/string/IsRFC3339.ts
index 88262b79a5..119d88ca41 100644
--- a/src/decorator/string/IsRFC3339.ts
+++ b/src/decorator/string/IsRFC3339.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isRFC3339Validator from 'validator/lib/isRFC3339';
 
 export const IS_RFC_3339 = 'isRFC3339';
@@ -22,7 +24,7 @@ export function IsRFC3339(validationOptions?: ValidationOptions): PropertyDecora
       name: IS_RFC_3339,
       validator: {
         validate: (value, args): boolean => isRFC3339(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be RFC 3339 date', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-rfc-3339-each' : 'is-rfc-3339'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsRgbColor.ts b/src/decorator/string/IsRgbColor.ts
index 0fc56cc5dd..7b485de9e2 100644
--- a/src/decorator/string/IsRgbColor.ts
+++ b/src/decorator/string/IsRgbColor.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isRgbColorValidator from 'validator/lib/isRgbColor';
 
 export const IS_RGB_COLOR = 'isRgbColor';
@@ -25,7 +27,7 @@ export function IsRgbColor(includePercentValues?: boolean, validationOptions?: V
       constraints: [includePercentValues],
       validator: {
         validate: (value, args): boolean => isRgbColor(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be RGB color', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-rgb-color-each' : 'is-rgb-color'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsSemVer.ts b/src/decorator/string/IsSemVer.ts
index e599655085..3785779bff 100644
--- a/src/decorator/string/IsSemVer.ts
+++ b/src/decorator/string/IsSemVer.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isSemVerValidator from 'validator/lib/isSemVer';
 
 export const IS_SEM_VER = 'isSemVer';
@@ -22,10 +24,7 @@ export function IsSemVer(validationOptions?: ValidationOptions): PropertyDecorat
       name: IS_SEM_VER,
       validator: {
         validate: (value, args): boolean => isSemVer(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a Semantic Versioning Specification',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-sem-ver-each' : 'is-sem-ver'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsStrongPassword.ts b/src/decorator/string/IsStrongPassword.ts
index 31e6f918a3..5ca350931e 100644
--- a/src/decorator/string/IsStrongPassword.ts
+++ b/src/decorator/string/IsStrongPassword.ts
@@ -1,6 +1,8 @@
 import * as validator from 'validator';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_STRONG_PASSWORD = 'isStrongPassword';
 
@@ -34,7 +36,7 @@ export function IsStrongPassword(
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isStrongPassword(value, args.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property is not strong enough', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-strong-password-each' : 'is-strong-password'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsSurrogatePair.ts b/src/decorator/string/IsSurrogatePair.ts
index 8cd7e2a8d0..c2c26114e0 100644
--- a/src/decorator/string/IsSurrogatePair.ts
+++ b/src/decorator/string/IsSurrogatePair.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isSurrogatePairValidator from 'validator/lib/isSurrogatePair';
 
 export const IS_SURROGATE_PAIR = 'isSurrogatePair';
@@ -22,10 +24,7 @@ export function IsSurrogatePair(validationOptions?: ValidationOptions): Property
       name: IS_SURROGATE_PAIR,
       validator: {
         validate: (value, args): boolean => isSurrogatePair(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain any surrogate pairs chars',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-surrogate-pair-each' : 'is-surrogate-pair'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsTimeZone.ts b/src/decorator/string/IsTimeZone.ts
index 3504d0aa6b..b80b43d9a3 100644
--- a/src/decorator/string/IsTimeZone.ts
+++ b/src/decorator/string/IsTimeZone.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_TIMEZONE = 'isTimeZone';
 
@@ -32,10 +34,7 @@ export function IsTimeZone(validationOptions?: ValidationOptions): PropertyDecor
       name: IS_TIMEZONE,
       validator: {
         validate: (value, args): boolean => isTimeZone(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid IANA time-zone',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-time-zone-each' : 'is-time-zone'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsUUID.ts b/src/decorator/string/IsUUID.ts
index a1ac241cf6..909152d028 100644
--- a/src/decorator/string/IsUUID.ts
+++ b/src/decorator/string/IsUUID.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isUuidValidator from 'validator/lib/isUUID';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_UUID = 'isUuid';
 
@@ -24,7 +26,7 @@ export function IsUUID(version?: ValidatorJS.UUIDVersion, validationOptions?: Va
       constraints: [version],
       validator: {
         validate: (value, args): boolean => isUUID(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a UUID', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-uuid-each' : 'is-uuid'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsUppercase.ts b/src/decorator/string/IsUppercase.ts
index 2e22354082..fc36cc38c5 100644
--- a/src/decorator/string/IsUppercase.ts
+++ b/src/decorator/string/IsUppercase.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isUppercaseValidator from 'validator/lib/isUppercase';
 
 export const IS_UPPERCASE = 'isUppercase';
@@ -22,7 +24,7 @@ export function IsUppercase(validationOptions?: ValidationOptions): PropertyDeco
       name: IS_UPPERCASE,
       validator: {
         validate: (value, args): boolean => isUppercase(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be uppercase', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-uppercase-each' : 'is-uppercase'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsUrl.ts b/src/decorator/string/IsUrl.ts
index 0ea6dda3a0..dff78d04f0 100644
--- a/src/decorator/string/IsUrl.ts
+++ b/src/decorator/string/IsUrl.ts
@@ -1,7 +1,9 @@
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isUrlValidator from 'validator/lib/isURL';
 import * as ValidatorJS from 'validator';
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 
 export const IS_URL = 'isUrl';
 
@@ -24,7 +26,7 @@ export function IsUrl(options?: ValidatorJS.IsURLOptions, validationOptions?: Va
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isURL(value, args?.constraints[0]),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a URL address', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-url-each' : 'is-url'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/IsVariableWidth.ts b/src/decorator/string/IsVariableWidth.ts
index 0eb4d312d3..dd1b648f30 100644
--- a/src/decorator/string/IsVariableWidth.ts
+++ b/src/decorator/string/IsVariableWidth.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isVariableWidthValidator from 'validator/lib/isVariableWidth';
 
 export const IS_VARIABLE_WIDTH = 'isVariableWidth';
@@ -22,10 +24,7 @@ export function IsVariableWidth(validationOptions?: ValidationOptions): Property
       name: IS_VARIABLE_WIDTH,
       validator: {
         validate: (value, args): boolean => isVariableWidth(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must contain a full-width and half-width characters',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-variable-width-each' : 'is-variable-width'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/Length.ts b/src/decorator/string/Length.ts
index 04427bdfb7..a473014e1f 100644
--- a/src/decorator/string/Length.ts
+++ b/src/decorator/string/Length.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isLengthValidator from 'validator/lib/isLength';
 
 export const IS_LENGTH = 'isLength';
@@ -23,19 +25,16 @@ export function Length(min: number, max?: number, validationOptions?: Validation
       constraints: [min, max],
       validator: {
         validate: (value, args): boolean => length(value, args?.constraints[0], args?.constraints[1]),
-        defaultMessage: buildMessage((eachPrefix, args) => {
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => {
           const isMinLength = args?.constraints[0] !== null && args?.constraints[0] !== undefined;
           const isMaxLength = args?.constraints[1] !== null && args?.constraints[1] !== undefined;
           if (isMinLength && (!args.value || args.value.length < args?.constraints[0])) {
-            return eachPrefix + '$property must be longer than or equal to $constraint1 characters';
+            return translate(validationOptions?.each ? 'is-min-length-each' : 'is-min-length');
           } else if (isMaxLength && args.value.length > args?.constraints[1]) {
-            return eachPrefix + '$property must be shorter than or equal to $constraint2 characters';
+            return translate(validationOptions?.each ? 'is-max-length-each' : 'is-max-length');
           }
-          return (
-            eachPrefix +
-            '$property must be longer than or equal to $constraint1 and shorter than or equal to $constraint2 characters'
-          );
-        }, validationOptions),
+          return translate(validationOptions?.each ? 'length-each' : 'length');
+        },
       },
     },
     validationOptions
diff --git a/src/decorator/string/Matches.ts b/src/decorator/string/Matches.ts
index 403d5a6f15..8c98479ebc 100644
--- a/src/decorator/string/Matches.ts
+++ b/src/decorator/string/Matches.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import matchesValidator from 'validator/lib/matches';
 
 export const MATCHES = 'matches';
@@ -38,10 +40,7 @@ export function Matches(
       constraints: [pattern, modifiers],
       validator: {
         validate: (value, args): boolean => matches(value, args?.constraints[0], args?.constraints[1]),
-        defaultMessage: buildMessage(
-          (eachPrefix, args) => eachPrefix + '$property must match $constraint1 regular expression',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'matches-each' : 'matches'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/MaxLength.ts b/src/decorator/string/MaxLength.ts
index 78dc194ccf..c5b48b8e78 100644
--- a/src/decorator/string/MaxLength.ts
+++ b/src/decorator/string/MaxLength.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isLengthValidator from 'validator/lib/isLength';
 
 export const MAX_LENGTH = 'maxLength';
@@ -23,10 +25,7 @@ export function MaxLength(max: number, validationOptions?: ValidationOptions): P
       constraints: [max],
       validator: {
         validate: (value, args): boolean => maxLength(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be shorter than or equal to $constraint1 characters',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'max-length-each' : 'max-length'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/MinLength.ts b/src/decorator/string/MinLength.ts
index 050a51be26..f366364777 100644
--- a/src/decorator/string/MinLength.ts
+++ b/src/decorator/string/MinLength.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isLengthValidator from 'validator/lib/isLength';
 
 export const MIN_LENGTH = 'minLength';
@@ -23,10 +25,7 @@ export function MinLength(min: number, validationOptions?: ValidationOptions): P
       constraints: [min],
       validator: {
         validate: (value, args): boolean => minLength(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be longer than or equal to $constraint1 characters',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'min-length-each' : 'min-length'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/NotContains.ts b/src/decorator/string/NotContains.ts
index 5db77b9de0..901de64c2f 100644
--- a/src/decorator/string/NotContains.ts
+++ b/src/decorator/string/NotContains.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import containsValidator from 'validator/lib/contains';
 
 export const NOT_CONTAINS = 'notContains';
@@ -23,10 +25,7 @@ export function NotContains(seed: string, validationOptions?: ValidationOptions)
       constraints: [seed],
       validator: {
         validate: (value, args): boolean => notContains(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property should not contain a $constraint1 string',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'not-contains-each' : 'not-contains'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/is-iso4217-currency-code.ts b/src/decorator/string/is-iso4217-currency-code.ts
index 903620a146..a1416f7f13 100644
--- a/src/decorator/string/is-iso4217-currency-code.ts
+++ b/src/decorator/string/is-iso4217-currency-code.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isISO4217Validator from 'validator/lib/isISO4217';
 
 export const IS_ISO4217_CURRENCY_CODE = 'isISO4217CurrencyCode';
@@ -20,10 +22,7 @@ export function IsISO4217CurrencyCode(validationOptions?: ValidationOptions): Pr
       name: IS_ISO4217_CURRENCY_CODE,
       validator: {
         validate: (value, args): boolean => isISO4217CurrencyCode(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a valid ISO4217 currency code',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-iso4217-currency-code-each' : 'is-iso4217-currency-code'),
       },
     },
     validationOptions
diff --git a/src/decorator/string/is-tax-id.ts b/src/decorator/string/is-tax-id.ts
index 950852f190..ab26f131a8 100644
--- a/src/decorator/string/is-tax-id.ts
+++ b/src/decorator/string/is-tax-id.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 import isTaxIDValidator from 'validator/lib/isTaxID';
 
 export const IS_TAX_ID = 'isTaxId';
@@ -31,10 +33,7 @@ export function IsTaxId(locale?: string, validationOptions?: ValidationOptions):
       constraints: [locale],
       validator: {
         validate: (value, args): boolean => isTaxId(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a Tax Identification Number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-tax-id-each' : 'is-tax-id'),
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsArray.ts b/src/decorator/typechecker/IsArray.ts
index 7e5f43d7de..2ec5ca2e3b 100644
--- a/src/decorator/typechecker/IsArray.ts
+++ b/src/decorator/typechecker/IsArray.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_ARRAY = 'isArray';
 
@@ -19,7 +21,7 @@ export function IsArray(validationOptions?: ValidationOptions): PropertyDecorato
       name: IS_ARRAY,
       validator: {
         validate: (value, args): boolean => isArray(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be an array', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-array-each' : 'is-array')
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsBoolean.ts b/src/decorator/typechecker/IsBoolean.ts
index 187638de22..c8907b154b 100644
--- a/src/decorator/typechecker/IsBoolean.ts
+++ b/src/decorator/typechecker/IsBoolean.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_BOOLEAN = 'isBoolean';
 
@@ -19,7 +21,7 @@ export function IsBoolean(validationOptions?: ValidationOptions): PropertyDecora
       name: IS_BOOLEAN,
       validator: {
         validate: (value, args): boolean => isBoolean(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a boolean value', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-boolean-each' : 'is-boolean')
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsDate.ts b/src/decorator/typechecker/IsDate.ts
index ea12e927f8..6aefa428a6 100644
--- a/src/decorator/typechecker/IsDate.ts
+++ b/src/decorator/typechecker/IsDate.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_DATE = 'isDate';
 
@@ -19,7 +21,7 @@ export function IsDate(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_DATE,
       validator: {
         validate: (value, args): boolean => isDate(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a Date instance', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-date-each' : 'is-date')
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsEnum.ts b/src/decorator/typechecker/IsEnum.ts
index eb3d6b064b..a68677a690 100644
--- a/src/decorator/typechecker/IsEnum.ts
+++ b/src/decorator/typechecker/IsEnum.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_ENUM = 'isEnum';
 
@@ -30,10 +32,7 @@ export function IsEnum(entity: object, validationOptions?: ValidationOptions): P
       constraints: [entity, validEnumValues(entity)],
       validator: {
         validate: (value, args): boolean => isEnum(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be one of the following values: $constraint2',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-enum-each' : 'is-enum')
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsInt.ts b/src/decorator/typechecker/IsInt.ts
index 50f822841d..587bd7601b 100644
--- a/src/decorator/typechecker/IsInt.ts
+++ b/src/decorator/typechecker/IsInt.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_INT = 'isInt';
 
@@ -19,10 +21,7 @@ export function IsInt(validationOptions?: ValidationOptions): PropertyDecorator
       name: IS_INT,
       validator: {
         validate: (value, args): boolean => isInt(value),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be an integer number',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-int-each' : 'is-int')
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsNumber.ts b/src/decorator/typechecker/IsNumber.ts
index 5b6e67c13c..d137993d75 100644
--- a/src/decorator/typechecker/IsNumber.ts
+++ b/src/decorator/typechecker/IsNumber.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_NUMBER = 'isNumber';
 
@@ -51,10 +53,7 @@ export function IsNumber(options: IsNumberOptions = {}, validationOptions?: Vali
       constraints: [options],
       validator: {
         validate: (value, args): boolean => isNumber(value, args?.constraints[0]),
-        defaultMessage: buildMessage(
-          eachPrefix => eachPrefix + '$property must be a number conforming to the specified constraints',
-          validationOptions
-        ),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-number-each' : 'is-number')
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsObject.ts b/src/decorator/typechecker/IsObject.ts
index 5cbd415b67..08923b1e05 100644
--- a/src/decorator/typechecker/IsObject.ts
+++ b/src/decorator/typechecker/IsObject.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_OBJECT = 'isObject';
 
@@ -21,7 +23,7 @@ export function IsObject(validationOptions?: ValidationOptions): PropertyDecorat
       name: IS_OBJECT,
       validator: {
         validate: (value, args): boolean => isObject(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be an object', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-object-each' : 'is-object')
       },
     },
     validationOptions
diff --git a/src/decorator/typechecker/IsString.ts b/src/decorator/typechecker/IsString.ts
index 4c309cd622..761a9ce2fb 100644
--- a/src/decorator/typechecker/IsString.ts
+++ b/src/decorator/typechecker/IsString.ts
@@ -1,5 +1,7 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { TranslateFunction } from '../../validation/ValidationExecutor';
 import { ValidationOptions } from '../ValidationOptions';
-import { buildMessage, ValidateBy } from '../common/ValidateBy';
+import { ValidateBy } from '../common/ValidateBy';
 
 export const IS_STRING = 'isString';
 
@@ -19,7 +21,7 @@ export function IsString(validationOptions?: ValidationOptions): PropertyDecorat
       name: IS_STRING,
       validator: {
         validate: (value, args): boolean => isString(value),
-        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property must be a string', validationOptions),
+        defaultMessage: (args: ValidationArguments, translate: TranslateFunction) => translate(validationOptions?.each ? 'is-string-each' : 'is-string')
       },
     },
     validationOptions
diff --git a/src/index.ts b/src/index.ts
index 34aa0f38b5..bdb83225d3 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -21,6 +21,10 @@ export * from './validation/Validator';
 export * from './validation-schema/ValidationSchema';
 export * from './register-decorator';
 export * from './metadata/MetadataStorage';
+export * from './translator/Translator';
+export * from './translator/drivers/DefaultDriver';
+export * from './translator/drivers/I18nDriver';
+export * from './translator/drivers/NestI18nDriver';
 
 // -------------------------------------------------------------------------
 // Shortcut methods for api users
diff --git a/src/register-decorator.ts b/src/register-decorator.ts
index ffe4bf86a5..b41fa53326 100644
--- a/src/register-decorator.ts
+++ b/src/register-decorator.ts
@@ -7,6 +7,7 @@ import { ValidationArguments } from './validation/ValidationArguments';
 import { getFromContainer } from './container';
 import { MetadataStorage, getMetadataStorage } from './metadata/MetadataStorage';
 import { ValidationOptions } from './decorator/ValidationOptions';
+import { TranslateFunction } from './validation/ValidationExecutor';
 
 export interface ValidationDecoratorOptions {
   /**
@@ -63,9 +64,9 @@ export function registerDecorator(options: ValidationDecoratorOptions): void {
         return validator.validate(value, validationArguments);
       }
 
-      defaultMessage(validationArguments?: ValidationArguments): string {
+      defaultMessage(validationArguments: ValidationArguments, translate: TranslateFunction): string {
         if (validator.defaultMessage) {
-          return validator.defaultMessage(validationArguments);
+          return validator.defaultMessage(validationArguments, translate);
         }
 
         return '';
diff --git a/src/translator/Translator.ts b/src/translator/Translator.ts
new file mode 100644
index 0000000000..b2eaaad7ec
--- /dev/null
+++ b/src/translator/Translator.ts
@@ -0,0 +1,24 @@
+import { getGlobal } from '../utils';
+import { DefaultDriver } from './drivers/DefaultDriver';
+
+export function setTranslatorDriver(driver: TranslatorDriver) {
+  const global = getGlobal();
+  global.classValidatorTranslatorDriver = driver;
+}
+
+export function translate(key: string, language: string | null = null): string {
+  const translatorDriver = getTranslatorDriver();
+  return translatorDriver.translate(`class-validator.${key}`, language);
+}
+
+export function getTranslatorDriver(): TranslatorDriver {
+  const global = getGlobal();
+  if (!global.classValidatorTranslatorDriver) {
+    global.classValidatorTranslatorDriver = new DefaultDriver();
+  }
+  return global.classValidatorTranslatorDriver;
+}
+
+export interface TranslatorDriver {
+  translate(key: string, language?: string | null): string
+}
diff --git a/src/translator/drivers/DefaultDriver.ts b/src/translator/drivers/DefaultDriver.ts
new file mode 100644
index 0000000000..0e3745a3cf
--- /dev/null
+++ b/src/translator/drivers/DefaultDriver.ts
@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { TranslatorDriver } from '../Translator';
+
+export type DefaultDriverOptions = {
+  defaultLanguage?: string
+}
+
+type Translations = {
+  [key: string]: string
+}
+
+export class DefaultDriver implements TranslatorDriver {
+  constructor(protected readonly options: DefaultDriverOptions = {}) {}
+
+  translate(key: string, language?: string | null): string {
+    const translations = this.getTranslations(language ?? this.getDefaultLanguage());
+    return translations && translations[key] ? translations[key] : key;
+  }
+
+  protected getDefaultLanguage(): string {
+    return this.options.defaultLanguage ?? 'en';
+  }
+
+  protected getTranslations(language: string): Translations | null {
+    const fileContent = this.getContentFromLocaleFile(language);
+    return fileContent ? JSON.parse(fileContent) : null;
+  }
+
+  protected getContentFromLocaleFile(locale: string): string | null {
+    const basePath = join(__dirname, '..', '..', '..', 'locales');
+    const filePath = join(basePath, `${locale}.json`);
+    if (dirname(filePath) !== basePath) {
+      return null;
+    }
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    const fileContent = readFileSync(filePath);
+    return fileContent ? fileContent.toString() : null;
+  }
+}
diff --git a/src/translator/drivers/I18nDriver.ts b/src/translator/drivers/I18nDriver.ts
new file mode 100644
index 0000000000..a97469f1f8
--- /dev/null
+++ b/src/translator/drivers/I18nDriver.ts
@@ -0,0 +1,24 @@
+import { TranslatorDriver } from '../Translator';
+
+type I18n = {
+  __(phraseOrOptions: string | TranslateOptions): string;
+}
+
+type TranslateOptions  = {
+    phrase: string;
+    locale?: string | undefined;
+};
+
+export class I18nDriver implements TranslatorDriver {
+  constructor(private readonly i18n: I18n) { }
+
+  translate(key: string, locale?: string | null): string {
+    if (locale != null) {
+      return this.i18n.__({
+        phrase: key,
+        locale
+      });
+    }
+    return this.i18n.__(key);
+  }
+}
diff --git a/src/translator/drivers/NestI18nDriver.ts b/src/translator/drivers/NestI18nDriver.ts
new file mode 100644
index 0000000000..c107671658
--- /dev/null
+++ b/src/translator/drivers/NestI18nDriver.ts
@@ -0,0 +1,21 @@
+import { TranslatorDriver } from '../Translator';
+
+type I18nService = {
+  translate(key: string, options?: TranslateOptions): string;
+}
+
+export type TranslateOptions = {
+    lang?: string;
+};
+
+export class NestI18nDriver implements TranslatorDriver {
+  constructor(private readonly i18nService: I18nService) { }
+
+  translate(key: string, language?: string | null): string {
+    const options: TranslateOptions = {};
+    if (language != null) {
+        options.lang = language;
+    }
+    return this.i18nService.translate(key, options);
+  }
+}
diff --git a/src/validation/ValidationExecutor.ts b/src/validation/ValidationExecutor.ts
index 98d09fce27..5a69ab5a50 100644
--- a/src/validation/ValidationExecutor.ts
+++ b/src/validation/ValidationExecutor.ts
@@ -8,6 +8,7 @@ import { ValidationArguments } from './ValidationArguments';
 import { ValidationUtils } from './ValidationUtils';
 import { isPromise, convertToArray } from '../utils';
 import { getMetadataStorage } from '../metadata/MetadataStorage';
+import { translate } from '../translator/Translator';
 
 /**
  * Executes validation over given object.
@@ -414,7 +415,11 @@ export class ValidationExecutor {
       (!this.validatorOptions || (this.validatorOptions && !this.validatorOptions.dismissDefaultMessages))
     ) {
       if (customValidatorMetadata && customValidatorMetadata.instance.defaultMessage instanceof Function) {
-        message = customValidatorMetadata.instance.defaultMessage(validationArguments);
+        const translator: TranslateFunction = (key: string): string => {
+          return translate(key, this.getLanguage());
+        };
+
+        message = customValidatorMetadata.instance.defaultMessage(validationArguments, translator);
       }
     }
 
@@ -426,4 +431,16 @@ export class ValidationExecutor {
     const type = customValidatorMetadata && customValidatorMetadata.name ? customValidatorMetadata.name : metadata.type;
     return type;
   }
+
+  private getLanguage(): string | null {
+    let language = this.validatorOptions?.language;
+
+    if (typeof language === 'function') {
+      language = language();
+    }
+
+    return language ?? null;
+  }
 }
+
+export type TranslateFunction = (key: string) => string;
diff --git a/src/validation/ValidationUtils.ts b/src/validation/ValidationUtils.ts
index c67e8bcf1c..9d7782f3ad 100644
--- a/src/validation/ValidationUtils.ts
+++ b/src/validation/ValidationUtils.ts
@@ -12,6 +12,10 @@ export function constraintToString(constraint: unknown): string {
     constraint = constraint.description;
   }
 
+  if (typeof constraint === 'function' && constraint.name) {
+    constraint = constraint.name;
+  }
+
   return `${constraint}`;
 }
 
diff --git a/src/validation/ValidatorConstraintInterface.ts b/src/validation/ValidatorConstraintInterface.ts
index f29ce2f6fe..c4dc8727ce 100644
--- a/src/validation/ValidatorConstraintInterface.ts
+++ b/src/validation/ValidatorConstraintInterface.ts
@@ -11,5 +11,5 @@ export interface ValidatorConstraintInterface {
   /**
    * Gets default message when validation for this constraint fail.
    */
-  defaultMessage?(validationArguments?: ValidationArguments): string;
+  defaultMessage?(args: any, translate: (key: string) => string): string;
 }
diff --git a/src/validation/ValidatorOptions.ts b/src/validation/ValidatorOptions.ts
index f33d8927f5..b0f0320eda 100644
--- a/src/validation/ValidatorOptions.ts
+++ b/src/validation/ValidatorOptions.ts
@@ -1,3 +1,5 @@
+export type LanguageFunction = () => string;
+
 /**
  * Options passed to validator during validation.
  */
@@ -86,4 +88,9 @@ export interface ValidatorOptions {
    * When set to true, validation of the given property will stop after encountering the first error. Defaults to false.
    */
   stopAtFirstError?: boolean;
+
+  /**
+   * Defines the language that will be used in the translation.
+   */
+  language?: string | LanguageFunction;
 }
diff --git a/test/functional/translator-driver.spec.ts b/test/functional/translator-driver.spec.ts
new file mode 100644
index 0000000000..17acf0e556
--- /dev/null
+++ b/test/functional/translator-driver.spec.ts
@@ -0,0 +1,93 @@
+import { DefaultDriver, getTranslatorDriver, setTranslatorDriver } from '../../src';
+import { Validator } from '../../src/validation/Validator';
+
+const validator = new Validator();
+
+describe('translator driver', () => {
+  it('should not return any instance other than the default instance of the driver', () => {
+    const translatorDriver = getTranslatorDriver();
+
+    expect(translatorDriver).toBeInstanceOf(DefaultDriver);
+  });
+
+  it('should not perform translation into any language other than the driver\'s default language (English) when none is specified', () => {
+    const translatorDriver = getTranslatorDriver();
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty');
+
+    expect(text).toEqual('$property should not be empty');
+  });
+
+  it('should not perform translation into any language other than the specified language', () => {
+    const translatorDriver = getTranslatorDriver();
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty', 'en');
+
+    expect(text).toEqual('$property should not be empty');
+  });
+
+  it('should not translate the message if enter an unsupported language', () => {
+    const translatorDriver = getTranslatorDriver();
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty', 'xx');
+
+    expect(text).toEqual('class-validator.is-not-empty');
+  });
+
+  it('should not return an instance other than the custom driver instance.', () => {
+    class CustomDriver extends DefaultDriver {
+    }
+
+    setTranslatorDriver(new CustomDriver());
+
+    const translatorDriver = getTranslatorDriver();
+
+    expect(translatorDriver).toBeInstanceOf(CustomDriver);
+  });
+});
+
+describe('default driver', () => {
+  it('should not perform translation into any language other than the language specified as default in the driver options', () => {
+    const translatorDriver = new DefaultDriver({
+      defaultLanguage: 'en'
+    });
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty');
+
+    expect(text).toEqual('$property should not be empty');
+  });
+
+  it('should not translate the message if enter an unsupported language specified as default in the driver options', () => {
+    const translatorDriver = new DefaultDriver({
+      defaultLanguage: 'xx'
+    });
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty');
+
+    expect(text).toEqual('class-validator.is-not-empty');
+  });
+
+  it('should not perform translation into any language other than the driver\'s default language (English) when none is specified', () => {
+    const translatorDriver = new DefaultDriver();
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty');
+
+    expect(text).toEqual('$property should not be empty');
+  });
+
+  it('should not perform translation into any language other than the language specified', () => {
+    const translatorDriver = new DefaultDriver();
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty', 'en');
+
+    expect(text).toEqual('$property should not be empty');
+  });
+
+  it('should not translate the message if enter an unsupported language specified', () => {
+    const translatorDriver = new DefaultDriver();
+
+    const text: string = translatorDriver.translate('class-validator.is-not-empty', 'xx');
+
+    expect(text).toEqual('class-validator.is-not-empty');
+  });
+});
\ No newline at end of file
diff --git a/test/functional/validation-functions-and-decorators.spec.ts b/test/functional/validation-functions-and-decorators.spec.ts
index 78ceddcd6d..5c5b2fe89b 100644
--- a/test/functional/validation-functions-and-decorators.spec.ts
+++ b/test/functional/validation-functions-and-decorators.spec.ts
@@ -1813,7 +1813,7 @@ describe('IsBtcAddress', () => {
 
   it('should return error object with proper data', () => {
     const validationType = 'isBtcAddress';
-    const message = 'someProperty must be a BTC address';
+    const message = 'class-validator.is-btc-address';
     checkReturnedError(new MyClass(), invalidValues, validationType, message);
   });
 });
diff --git a/test/functional/validator-options.spec.ts b/test/functional/validator-options.spec.ts
index ed4b6f3d45..ea0850d7b4 100644
--- a/test/functional/validator-options.spec.ts
+++ b/test/functional/validator-options.spec.ts
@@ -83,4 +83,52 @@ describe('validator options', () => {
       expect(errors[0].constraints).toEqual({ unknownValue: 'an unknown value was passed to the validate function' });
     });
   });
+
+  it('should not perform translation to any language other than the driver default language when none is specifie', () => {
+    class MyClass {
+      @IsNotEmpty()
+      title: string = '';
+    }
+
+    const model = new MyClass();
+    model.title = '';
+    return validator
+      .validate(model)
+      .then(errors => {
+        expect(errors.length).toEqual(1);
+        expect(errors[0].constraints).toEqual({ isNotEmpty: 'title should not be empty' });
+      });
+  });
+
+  it('should not perform the translation to any language other than the specified language', () => {
+    class MyClass {
+      @IsNotEmpty()
+      title: string = '';
+    }
+
+    const model = new MyClass();
+    model.title = '';
+    return validator
+      .validate(model, { language: 'en' })
+      .then(errors => {
+        expect(errors.length).toEqual(1);
+        expect(errors[0].constraints).toEqual({ isNotEmpty: 'title should not be empty' });
+      });
+  });
+
+  it('should not translate the error if enter an unsupported language', () => {
+    class MyClass {
+      @IsNotEmpty()
+      title: string = '';
+    }
+
+    const model = new MyClass();
+    model.title = '';
+    return validator
+      .validate(model, { language: 'xx' })
+      .then(errors => {
+        expect(errors.length).toEqual(1);
+        expect(errors[0].constraints).toEqual({ isNotEmpty: 'class-validator.is-not-empty' });
+      });
+  });
 });