@tmlmobilidade/go-utils-validation 0.0.0-stage → 20261109.1101.19

package/dist/index.js

@@ -0,0 +1,127 @@
+import { createInstance } from 'i18next';
+import ICU from 'i18next-icu';
+import { z } from 'zod';
+import { makeZodI18nMap } from 'zod-i18n-map';
+import en from './locales/en.json' with { type: 'json' };
+import es from './locales/es.json' with { type: 'json' };
+import pt from './locales/pt.json' with { type: 'json' };
+export const validationResources = { en: { validation: en }, es: { validation: es }, pt: { validation: pt } };
+const instance = createInstance();
+instance.use(new ICU({ parseErrorHandler: () => '' }));
+void instance.init({
+    defaultNS: 'validation',
+    fallbackLng: 'pt',
+    initAsync: false,
+    interpolation: { escapeValue: false },
+    lng: 'pt',
+    resources: validationResources,
+});
+function getLocale(locale) {
+    const language = locale.toLowerCase().split(/[-_]/)[0];
+    return Object.hasOwn(validationResources, language) ? language : 'pt';
+}
+function getUnionTypeLabel(branches, locale) {
+    if (!branches.length)
+        return undefined;
+    const expected = branches.map(branch => branch.length === 1 && branch[0].code === 'invalid_type' && !branch[0].path?.length ? branch[0].expected : undefined);
+    if (!expected.every(value => value !== undefined))
+        return undefined;
+    const t = instance.getFixedT(locale, 'validation');
+    return [...new Set(expected)].map((type) => {
+        const key = `types.${type}`;
+        const label = t(key);
+        return label === key ? type : label;
+    }).join(' / ');
+}
+/** Translate a rule outside parsing, for example a password requirement checklist. */
+export function translateValidationMessage(key, values = {}, locale = 'pt') {
+    const message = instance.getFixedT(getLocale(locale), 'validation')(key, values);
+    return typeof message === 'string' && message.length > 0 && message !== key
+        ? message
+        : instance.getFixedT('pt', 'validation')('errors.custom');
+}
+/** Locale-neutral custom issue options for refine(), superRefine() and addIssue(). */
+export function validationParams(key, values = {}) {
+    return { params: { i18n: { key, values } } };
+}
+/**
+ * Custom wording for a built-in check such as min() or regex(). Leave translation
+ * to the per-parse map: a schema-level string would override the caller's locale.
+ */
+export function validationMessage(key, values = {}) {
+    return (issue) => {
+        Object.assign(issue, { validation: { key, values } });
+        return undefined;
+    };
+}
+/** Adapt an existing throwing validator to the Zod issue protocol. */
+export function validationTransform(validate, key, values = {}) {
+    return (value, context) => {
+        try {
+            return validate(value);
+        }
+        catch {
+            context.addIssue({ code: 'custom', ...validationParams(key, values) });
+            return z.NEVER;
+        }
+    };
+}
+/** A fixed-language map. Safe to use concurrently without changing global language. */
+export function createValidationErrorMap(locale = 'pt') {
+    const language = getLocale(locale);
+    const base = makeZodI18nMap({ handlePath: false, ns: 'validation', t: instance.getFixedT(language, 'validation') });
+    const resolve = (issue) => {
+        if ('validation' in issue) {
+            const metadata = issue.validation;
+            return base.key(metadata.key, metadata.values)(issue);
+        }
+        if (issue.input === undefined && ['invalid_type', 'invalid_union', 'invalid_value'].includes(issue.code)) {
+            return base.key('errors.invalid_type_received_undefined')(issue);
+        }
+        // Null is a type error unless the schema preprocesses it to undefined.
+        if (issue.code === 'invalid_type' && issue.input === null) {
+            return base.key('errors.invalid_type')(issue);
+        }
+        if (issue.code === 'invalid_union') {
+            const expected = getUnionTypeLabel(issue.errors, language);
+            if (expected) {
+                return base.key('errors.invalid_union_type', { expected })(issue);
+            }
+        }
+        return base(issue) || translateValidationMessage('errors.custom', {}, language);
+    };
+    const map = (issue) => {
+        const result = resolve(issue);
+        const message = typeof result === 'string' ? result : result?.message;
+        return message?.trim() ? message : translateValidationMessage('errors.custom', {}, language);
+    };
+    return Object.assign(map, {
+        translate: (issue) => {
+            const metadata = ('zodI18n' in issue ? issue.zodI18n : undefined);
+            if (issue.code === 'invalid_union' && metadata?.custom?.key === 'errors.invalid_union_type') {
+                const expected = getUnionTypeLabel(issue.errors, language);
+                if (expected) {
+                    return translateValidationMessage('errors.invalid_union_type', { expected }, language);
+                }
+            }
+            const message = base.translate(issue);
+            return message?.trim() ? message : translateValidationMessage('errors.custom', {}, language);
+        },
+    });
+}
+/** Format an existing Zod error for an API's error:string response or a worker log. */
+export function formatValidationError(error, locale = 'pt') {
+    const map = createValidationErrorMap(locale);
+    return error.issues.map(issue => `${issue.path.length ? `${issue.path.map(String).join('.')}: ` : ''}${map.translate(issue)}`).join('; ');
+}
+/** Synchronous form resolver preserving Zod paths, including nested array fields. */
+export function createValidationResolver(schema, locale = 'pt') {
+    const error = createValidationErrorMap(locale);
+    return (values) => {
+        const result = schema.safeParse(values, { error });
+        return result.success ? {} : Object.fromEntries(result.error.issues.map(issue => [issue.path.map(String).join('.'), issue.message]));
+    };
+}
+// A fixed Portuguese default for existing parse()/safeParse() callers. Forms and
+// requests override it per parse; they never mutate this global configuration.
+z.config({ customError: createValidationErrorMap() });

package/dist/locales/en.json

@@ -0,0 +1,226 @@
+{
+    "custom": {
+        "banner": {
+            "link": "Banner links must use HTTP or HTTPS"
+        },
+        "dates": {
+            "event_id": "Must be uppercase letters, numbers, or underscores",
+            "overlap": "Dates cannot be added and removed in the same request: {dates}",
+            "period_name": "Enter a period name",
+            "period_required": "Select a period"
+        },
+        "documents": {
+            "changes_required": "multiple_fields requires metadata.changes array",
+            "different_values": "curr_value and prev_value must differ",
+            "null_values": "multiple_fields must have null curr_value and prev_value"
+        },
+        "feedback": {
+            "duplicate_reason": "Reason \"{reason}\" cannot be selected more than once.",
+            "reason": "Reason \"{reason}\" is not valid for {entity} feedback."
+        },
+        "formats": {
+            "date": "Expected a date in the format {format}",
+            "hex_color": "Expected a hex color in the format {format}",
+            "hhmm": "Expected a time in the format {format} between {minimum} and {maximum}",
+            "operational_date": "Expected a date in the format {format} or {alternative}",
+            "operational_time": "Expected a time in the format {format}, with minutes and seconds between 00 and 59",
+            "unix_milliseconds": "Expected a valid Unix timestamp in milliseconds, at least {minimum}",
+            "unix_seconds": "Expected a valid Unix timestamp in seconds, at least {minimum}"
+        },
+        "geo": {
+            "coordinate": "Invalid coordinate",
+            "encoded_polyline": "Invalid encoded polyline",
+            "latitude": "Latitude must be between {minimum} and {maximum}",
+            "linear_ring": "The first and last points of a linear ring must match",
+            "longitude": "Longitude must be between {minimum} and {maximum}"
+        },
+        "network": {
+            "agency_required": "At least one agency ID is required",
+            "anchor": "An anchor must identify both ends of one path segment.",
+            "default_required": "A default parameter is required.",
+            "default_unique": "Only one default parameter is allowed.",
+            "parameters_path": "Travel-time parameters must match each path occurrence in order.",
+            "path_ids": "Path occurrence IDs must be unique.",
+            "shape_distances": "Shape distances must not decrease along the path.",
+            "shape_sequences": "Shape point sequences must be unique.",
+            "stop_distances": "Stop distances must not decrease along the path.",
+            "stop_sequences": "Stop sequences must be unique.",
+            "weekdays": "Select at least one weekday.",
+            "year_periods": "Select at least one year period."
+        },
+        "password": {
+            "lowercase": "Password must contain at least one lowercase character",
+            "min_length": "Password must be at least {minimum} characters long",
+            "mismatch": "Passwords do not match",
+            "number": "Password must contain at least one number",
+            "requirements": "Password requirements",
+            "special": "Password must contain at least one special character",
+            "uppercase": "Password must contain at least one uppercase character"
+        },
+        "schedule": {
+            "active_period": "The active period end date must be on or after the start date",
+            "end_after_start": "The end must be after the start",
+            "publication": "The publication end date must be on or after the start date"
+        },
+        "unique": {
+            "changelog_items": "Change item IDs must be unique within a changelog",
+            "module_ids": "Module IDs must be unique",
+            "release_ids": "Release IDs must be unique"
+        }
+    },
+    "errors": {
+        "custom": "Invalid input",
+        "invalid_element": "Invalid value in {origin}",
+        "invalid_format": {
+            "default": "Invalid {format}",
+            "ends_with": "Must end with \"{suffix}\"",
+            "includes": "Must include \"{includes}\"",
+            "lowercase": "Must be lowercase",
+            "regex": "Invalid format",
+            "starts_with": "Must start with \"{prefix}\"",
+            "uppercase": "Must be uppercase"
+        },
+        "invalid_key": "Invalid key in {origin}",
+        "invalid_type": "Expected {expected}, received {received}",
+        "invalid_type_received_null": "Expected {expected}, received {received}",
+        "invalid_type_received_undefined": "Required",
+        "invalid_union": "Invalid input",
+        "invalid_union_discriminator": "Invalid discriminator value. Expected {options}",
+        "invalid_union_type": "Expected {expected}",
+        "invalid_value": "Invalid option: expected one of {options}",
+        "invalid_value_single": "Invalid input: expected {expected}",
+        "not_multiple_of": "Number must be a multiple of {divisor}",
+        "too_big": {
+            "array": {
+                "exact": "{count, plural, one {Array must contain exactly {count} element} other {Array must contain exactly {count} elements}}",
+                "inclusive": "{count, plural, one {Array must contain at most {count} element} other {Array must contain at most {count} elements}}",
+                "not_inclusive": "{count, plural, one {Array must contain fewer than {count} element} other {Array must contain fewer than {count} elements}}"
+            },
+            "date": {
+                "exact": "Date must be exactly {maximum, date}",
+                "inclusive": "Date must be on or before {maximum, date}",
+                "not_inclusive": "Date must be before {maximum, date}"
+            },
+            "file": {
+                "exact": "{count, plural, one {File must be exactly {count} byte} other {File must be exactly {count} bytes}}",
+                "inclusive": "{count, plural, one {File must be at most {count} byte} other {File must be at most {count} bytes}}",
+                "not_inclusive": "{count, plural, one {File must be smaller than {count} byte} other {File must be smaller than {count} bytes}}"
+            },
+            "map": {
+                "exact": "{count, plural, one {Map must contain exactly {count} entry} other {Map must contain exactly {count} entries}}",
+                "inclusive": "{count, plural, one {Map must contain at most {count} entry} other {Map must contain at most {count} entries}}",
+                "not_inclusive": "{count, plural, one {Map must contain fewer than {count} entry} other {Map must contain fewer than {count} entries}}"
+            },
+            "number": {
+                "exact": "Number must be exactly {maximum}",
+                "inclusive": "Number must be less than or equal to {maximum}",
+                "not_inclusive": "Number must be less than {maximum}"
+            },
+            "set": {
+                "exact": "{count, plural, one {Set must contain exactly {count} item} other {Set must contain exactly {count} items}}",
+                "inclusive": "{count, plural, one {Set must contain at most {count} item} other {Set must contain at most {count} items}}",
+                "not_inclusive": "{count, plural, one {Set must contain fewer than {count} item} other {Set must contain fewer than {count} items}}"
+            },
+            "string": {
+                "exact": "{count, plural, one {String must contain exactly {count} character} other {String must contain exactly {count} characters}}",
+                "inclusive": "{count, plural, one {String must contain at most {count} character} other {String must contain at most {count} characters}}",
+                "not_inclusive": "{count, plural, one {String must contain fewer than {count} character} other {String must contain fewer than {count} characters}}"
+            }
+        },
+        "too_small": {
+            "array": {
+                "exact": "{count, plural, one {Array must contain exactly {count} element} other {Array must contain exactly {count} elements}}",
+                "inclusive": "{count, plural, one {Array must contain at least {count} element} other {Array must contain at least {count} elements}}",
+                "not_inclusive": "{count, plural, one {Array must contain more than {count} element} other {Array must contain more than {count} elements}}"
+            },
+            "date": {
+                "exact": "Date must be exactly {minimum, date}",
+                "inclusive": "Date must be on or after {minimum, date}",
+                "not_inclusive": "Date must be after {minimum, date}"
+            },
+            "file": {
+                "exact": "{count, plural, one {File must be exactly {count} byte} other {File must be exactly {count} bytes}}",
+                "inclusive": "{count, plural, one {File must be at least {count} byte} other {File must be at least {count} bytes}}",
+                "not_inclusive": "{count, plural, one {File must be larger than {count} byte} other {File must be larger than {count} bytes}}"
+            },
+            "map": {
+                "exact": "{count, plural, one {Map must contain exactly {count} entry} other {Map must contain exactly {count} entries}}",
+                "inclusive": "{count, plural, one {Map must contain at least {count} entry} other {Map must contain at least {count} entries}}",
+                "not_inclusive": "{count, plural, one {Map must contain more than {count} entry} other {Map must contain more than {count} entries}}"
+            },
+            "number": {
+                "exact": "Number must be exactly {minimum}",
+                "inclusive": "Number must be greater than or equal to {minimum}",
+                "not_inclusive": "Number must be greater than {minimum}"
+            },
+            "set": {
+                "exact": "{count, plural, one {Set must contain exactly {count} item} other {Set must contain exactly {count} items}}",
+                "inclusive": "{count, plural, one {Set must contain at least {count} item} other {Set must contain at least {count} items}}",
+                "not_inclusive": "{count, plural, one {Set must contain more than {count} item} other {Set must contain more than {count} items}}"
+            },
+            "string": {
+                "exact": "{count, plural, one {String must contain exactly {count} character} other {String must contain exactly {count} characters}}",
+                "inclusive": "{count, plural, one {String must contain at least {count} character} other {String must contain at least {count} characters}}",
+                "not_inclusive": "{count, plural, one {String must contain more than {count} character} other {String must contain more than {count} characters}}"
+            }
+        },
+        "unrecognized_keys": "{count, plural, one {Unrecognized key in object: {keys}} other {Unrecognized keys in object: {keys}}}"
+    },
+    "formats": {
+        "base64": "base64-encoded string",
+        "base64url": "base64url-encoded string",
+        "cidrv4": "IPv4 range",
+        "cidrv6": "IPv6 range",
+        "credit_card": "credit card number",
+        "cuid": "cuid",
+        "cuid2": "cuid2",
+        "currency_code": "currency code",
+        "date": "ISO date",
+        "datetime": "ISO datetime",
+        "duration": "ISO duration",
+        "e164": "E.164 phone number",
+        "email": "email address",
+        "emoji": "emoji",
+        "guid": "GUID",
+        "hash": "hash",
+        "hex": "hexadecimal string",
+        "hostname": "hostname",
+        "iban": "IBAN",
+        "ipv4": "IPv4 address",
+        "ipv6": "IPv6 address",
+        "json_string": "JSON string",
+        "jwt": "JWT",
+        "ksuid": "KSUID",
+        "mac": "MAC address",
+        "nanoid": "nanoid",
+        "template_literal": "input",
+        "time": "ISO time",
+        "ulid": "ULID",
+        "url": "URL",
+        "uuid": "UUID",
+        "xid": "XID"
+    },
+    "types": {
+        "array": "array",
+        "bigint": "bigint",
+        "boolean": "boolean",
+        "date": "date",
+        "file": "file",
+        "function": "function",
+        "int": "integer",
+        "map": "map",
+        "nan": "NaN",
+        "never": "never",
+        "null": "null",
+        "number": "number",
+        "object": "object",
+        "promise": "promise",
+        "record": "record",
+        "set": "set",
+        "string": "string",
+        "symbol": "symbol",
+        "tuple": "tuple",
+        "undefined": "undefined",
+        "void": "void"
+    }
+}

package/dist/locales/es.json

@@ -0,0 +1,226 @@
+{
+    "custom": {
+        "banner": {
+            "link": "Los enlaces de los avisos deben usar HTTP o HTTPS"
+        },
+        "dates": {
+            "event_id": "Debe contener letras mayúsculas, números o guiones bajos",
+            "overlap": "No se pueden añadir y eliminar fechas en la misma solicitud: {dates}",
+            "period_name": "Introduzca un nombre para el período",
+            "period_required": "Seleccione un período"
+        },
+        "documents": {
+            "changes_required": "multiple_fields requiere el array metadata.changes",
+            "different_values": "curr_value y prev_value deben ser diferentes",
+            "null_values": "multiple_fields debe tener curr_value y prev_value nulos"
+        },
+        "feedback": {
+            "duplicate_reason": "El motivo «{reason}» no puede seleccionarse más de una vez.",
+            "reason": "El motivo «{reason}» no es válido para comentarios de {entity}."
+        },
+        "formats": {
+            "date": "Se esperaba una fecha con el formato {format}",
+            "hex_color": "Se esperaba un color hexadecimal con el formato {format}",
+            "hhmm": "Se esperaba una hora con el formato {format} entre {minimum} y {maximum}",
+            "operational_date": "Se esperaba una fecha con el formato {format} o {alternative}",
+            "operational_time": "Se esperaba una hora con el formato {format}, con minutos y segundos entre 00 y 59",
+            "unix_milliseconds": "Se esperaba una marca de tiempo Unix válida en milisegundos, como mínimo {minimum}",
+            "unix_seconds": "Se esperaba una marca de tiempo Unix válida en segundos, como mínimo {minimum}"
+        },
+        "geo": {
+            "coordinate": "Coordenada no válida",
+            "encoded_polyline": "Polilínea codificada no válida",
+            "latitude": "La latitud debe estar entre {minimum} y {maximum}",
+            "linear_ring": "El primer y el último punto de un anillo deben coincidir",
+            "longitude": "La longitud debe estar entre {minimum} y {maximum}"
+        },
+        "network": {
+            "agency_required": "Se requiere al menos un identificador de agencia",
+            "anchor": "Un anclaje debe identificar ambos extremos de un segmento del recorrido.",
+            "default_required": "Es obligatorio un parámetro «default».",
+            "default_unique": "Solo se permite un parámetro «default».",
+            "parameters_path": "Los parámetros de tiempo de viaje deben coincidir con cada ocurrencia del recorrido en orden.",
+            "path_ids": "Los identificadores de las ocurrencias del recorrido deben ser únicos.",
+            "shape_distances": "Las distancias del trazado no deben disminuir a lo largo del recorrido.",
+            "shape_sequences": "Las secuencias de puntos del trazado deben ser únicas.",
+            "stop_distances": "Las distancias de las paradas no deben disminuir a lo largo del recorrido.",
+            "stop_sequences": "Las secuencias de paradas deben ser únicas.",
+            "weekdays": "Seleccione al menos un día de la semana.",
+            "year_periods": "Seleccione al menos un período del año."
+        },
+        "password": {
+            "lowercase": "La contraseña debe contener al menos una letra minúscula",
+            "min_length": "La contraseña debe tener al menos {minimum} caracteres",
+            "mismatch": "Las contraseñas no coinciden",
+            "number": "La contraseña debe contener al menos un número",
+            "requirements": "Requisitos de la contraseña",
+            "special": "La contraseña debe contener al menos un carácter especial",
+            "uppercase": "La contraseña debe contener al menos una letra mayúscula"
+        },
+        "schedule": {
+            "active_period": "La fecha final del período activo debe ser igual o posterior a la inicial",
+            "end_after_start": "El final debe ser posterior al inicio",
+            "publication": "La fecha final de publicación debe ser igual o posterior a la inicial"
+        },
+        "unique": {
+            "changelog_items": "Los identificadores de cambios deben ser únicos dentro de un registro",
+            "module_ids": "Los identificadores de módulos deben ser únicos",
+            "release_ids": "Los identificadores de versión deben ser únicos"
+        }
+    },
+    "errors": {
+        "custom": "Valor no válido",
+        "invalid_element": "Elemento no válido en el valor de tipo {origin}",
+        "invalid_format": {
+            "default": "Formato de {format} no válido",
+            "ends_with": "Debe terminar en \"{suffix}\"",
+            "includes": "Debe incluir \"{includes}\"",
+            "lowercase": "Debe estar en minúsculas",
+            "regex": "Formato no válido",
+            "starts_with": "Debe empezar por \"{prefix}\"",
+            "uppercase": "Debe estar en mayúsculas"
+        },
+        "invalid_key": "Clave no válida en el valor de tipo {origin}",
+        "invalid_type": "El valor debe ser de tipo {expected} (tipo recibido: {received})",
+        "invalid_type_received_null": "El valor debe ser de tipo {expected} (tipo recibido: {received})",
+        "invalid_type_received_undefined": "Este campo es obligatorio",
+        "invalid_union": "Valor no válido",
+        "invalid_union_discriminator": "El valor debe ser uno de los siguientes: {options}",
+        "invalid_union_type": "Se esperaba {expected}",
+        "invalid_value": "El valor debe ser uno de los siguientes: {options}",
+        "invalid_value_single": "El valor debe ser {expected}",
+        "not_multiple_of": "El número debe ser múltiplo de {divisor}",
+        "too_big": {
+            "array": {
+                "exact": "{count, plural, one {La lista debe contener exactamente {count} elemento} many {La lista debe contener exactamente {count} elementos} other {La lista debe contener exactamente {count} elementos}}",
+                "inclusive": "{count, plural, one {La lista debe contener como máximo {count} elemento} many {La lista debe contener como máximo {count} elementos} other {La lista debe contener como máximo {count} elementos}}",
+                "not_inclusive": "{count, plural, one {La lista debe contener menos de {count} elemento} many {La lista debe contener menos de {count} elementos} other {La lista debe contener menos de {count} elementos}}"
+            },
+            "date": {
+                "exact": "La fecha debe ser el {maximum, date}",
+                "inclusive": "La fecha debe ser igual o anterior al {maximum, date}",
+                "not_inclusive": "La fecha debe ser anterior al {maximum, date}"
+            },
+            "file": {
+                "exact": "{count, plural, one {El archivo debe tener exactamente {count} byte} many {El archivo debe tener exactamente {count} bytes} other {El archivo debe tener exactamente {count} bytes}}",
+                "inclusive": "{count, plural, one {El archivo debe tener como máximo {count} byte} many {El archivo debe tener como máximo {count} bytes} other {El archivo debe tener como máximo {count} bytes}}",
+                "not_inclusive": "{count, plural, one {El archivo debe tener menos de {count} byte} many {El archivo debe tener menos de {count} bytes} other {El archivo debe tener menos de {count} bytes}}"
+            },
+            "map": {
+                "exact": "{count, plural, one {El mapa debe contener exactamente {count} entrada} many {El mapa debe contener exactamente {count} entradas} other {El mapa debe contener exactamente {count} entradas}}",
+                "inclusive": "{count, plural, one {El mapa debe contener como máximo {count} entrada} many {El mapa debe contener como máximo {count} entradas} other {El mapa debe contener como máximo {count} entradas}}",
+                "not_inclusive": "{count, plural, one {El mapa debe contener menos de {count} entrada} many {El mapa debe contener menos de {count} entradas} other {El mapa debe contener menos de {count} entradas}}"
+            },
+            "number": {
+                "exact": "El número debe ser exactamente {maximum}",
+                "inclusive": "El número debe ser menor o igual que {maximum}",
+                "not_inclusive": "El número debe ser menor que {maximum}"
+            },
+            "set": {
+                "exact": "{count, plural, one {El conjunto debe contener exactamente {count} elemento} many {El conjunto debe contener exactamente {count} elementos} other {El conjunto debe contener exactamente {count} elementos}}",
+                "inclusive": "{count, plural, one {El conjunto debe contener como máximo {count} elemento} many {El conjunto debe contener como máximo {count} elementos} other {El conjunto debe contener como máximo {count} elementos}}",
+                "not_inclusive": "{count, plural, one {El conjunto debe contener menos de {count} elemento} many {El conjunto debe contener menos de {count} elementos} other {El conjunto debe contener menos de {count} elementos}}"
+            },
+            "string": {
+                "exact": "{count, plural, one {El texto debe contener exactamente {count} carácter} many {El texto debe contener exactamente {count} caracteres} other {El texto debe contener exactamente {count} caracteres}}",
+                "inclusive": "{count, plural, one {El texto debe contener como máximo {count} carácter} many {El texto debe contener como máximo {count} caracteres} other {El texto debe contener como máximo {count} caracteres}}",
+                "not_inclusive": "{count, plural, one {El texto debe contener menos de {count} carácter} many {El texto debe contener menos de {count} caracteres} other {El texto debe contener menos de {count} caracteres}}"
+            }
+        },
+        "too_small": {
+            "array": {
+                "exact": "{count, plural, one {La lista debe contener exactamente {count} elemento} many {La lista debe contener exactamente {count} elementos} other {La lista debe contener exactamente {count} elementos}}",
+                "inclusive": "{count, plural, one {La lista debe contener al menos {count} elemento} many {La lista debe contener al menos {count} elementos} other {La lista debe contener al menos {count} elementos}}",
+                "not_inclusive": "{count, plural, one {La lista debe contener más de {count} elemento} many {La lista debe contener más de {count} elementos} other {La lista debe contener más de {count} elementos}}"
+            },
+            "date": {
+                "exact": "La fecha debe ser el {minimum, date}",
+                "inclusive": "La fecha debe ser igual o posterior al {minimum, date}",
+                "not_inclusive": "La fecha debe ser posterior al {minimum, date}"
+            },
+            "file": {
+                "exact": "{count, plural, one {El archivo debe tener exactamente {count} byte} many {El archivo debe tener exactamente {count} bytes} other {El archivo debe tener exactamente {count} bytes}}",
+                "inclusive": "{count, plural, one {El archivo debe tener al menos {count} byte} many {El archivo debe tener al menos {count} bytes} other {El archivo debe tener al menos {count} bytes}}",
+                "not_inclusive": "{count, plural, one {El archivo debe tener más de {count} byte} many {El archivo debe tener más de {count} bytes} other {El archivo debe tener más de {count} bytes}}"
+            },
+            "map": {
+                "exact": "{count, plural, one {El mapa debe contener exactamente {count} entrada} many {El mapa debe contener exactamente {count} entradas} other {El mapa debe contener exactamente {count} entradas}}",
+                "inclusive": "{count, plural, one {El mapa debe contener al menos {count} entrada} many {El mapa debe contener al menos {count} entradas} other {El mapa debe contener al menos {count} entradas}}",
+                "not_inclusive": "{count, plural, one {El mapa debe contener más de {count} entrada} many {El mapa debe contener más de {count} entradas} other {El mapa debe contener más de {count} entradas}}"
+            },
+            "number": {
+                "exact": "El número debe ser exactamente {minimum}",
+                "inclusive": "El número debe ser mayor o igual que {minimum}",
+                "not_inclusive": "El número debe ser mayor que {minimum}"
+            },
+            "set": {
+                "exact": "{count, plural, one {El conjunto debe contener exactamente {count} elemento} many {El conjunto debe contener exactamente {count} elementos} other {El conjunto debe contener exactamente {count} elementos}}",
+                "inclusive": "{count, plural, one {El conjunto debe contener al menos {count} elemento} many {El conjunto debe contener al menos {count} elementos} other {El conjunto debe contener al menos {count} elementos}}",
+                "not_inclusive": "{count, plural, one {El conjunto debe contener más de {count} elemento} many {El conjunto debe contener más de {count} elementos} other {El conjunto debe contener más de {count} elementos}}"
+            },
+            "string": {
+                "exact": "{count, plural, one {El texto debe contener exactamente {count} carácter} many {El texto debe contener exactamente {count} caracteres} other {El texto debe contener exactamente {count} caracteres}}",
+                "inclusive": "{count, plural, one {El texto debe contener al menos {count} carácter} many {El texto debe contener al menos {count} caracteres} other {El texto debe contener al menos {count} caracteres}}",
+                "not_inclusive": "{count, plural, one {El texto debe contener más de {count} carácter} many {El texto debe contener más de {count} caracteres} other {El texto debe contener más de {count} caracteres}}"
+            }
+        },
+        "unrecognized_keys": "{count, plural, one {Clave no reconocida: {keys}} many {Claves no reconocidas: {keys}} other {Claves no reconocidas: {keys}}}"
+    },
+    "formats": {
+        "base64": "texto codificado en base64",
+        "base64url": "texto codificado en base64url",
+        "cidrv4": "rango IPv4",
+        "cidrv6": "rango IPv6",
+        "credit_card": "número de tarjeta de crédito",
+        "cuid": "cuid",
+        "cuid2": "cuid2",
+        "currency_code": "código de moneda",
+        "date": "fecha ISO",
+        "datetime": "fecha y hora ISO",
+        "duration": "duración ISO",
+        "e164": "número de teléfono E.164",
+        "email": "dirección de correo electrónico",
+        "emoji": "emoji",
+        "guid": "GUID",
+        "hash": "hash",
+        "hex": "texto hexadecimal",
+        "hostname": "nombre de host",
+        "iban": "IBAN",
+        "ipv4": "dirección IPv4",
+        "ipv6": "dirección IPv6",
+        "json_string": "texto JSON",
+        "jwt": "JWT",
+        "ksuid": "KSUID",
+        "mac": "dirección MAC",
+        "nanoid": "nanoid",
+        "template_literal": "valor",
+        "time": "hora ISO",
+        "ulid": "ULID",
+        "url": "URL",
+        "uuid": "UUID",
+        "xid": "XID"
+    },
+    "types": {
+        "array": "lista",
+        "bigint": "entero grande",
+        "boolean": "booleano",
+        "date": "fecha",
+        "file": "archivo",
+        "function": "función",
+        "int": "número entero",
+        "map": "mapa",
+        "nan": "NaN",
+        "never": "never",
+        "null": "nulo",
+        "number": "número",
+        "object": "objeto",
+        "promise": "promesa",
+        "record": "objeto",
+        "set": "conjunto",
+        "string": "texto",
+        "symbol": "símbolo",
+        "tuple": "tupla",
+        "undefined": "indefinido",
+        "void": "void"
+    }
+}