@oxog/vld 1.5.0 → 2.0.1

package/dist/locales.js

@@ -1,732 +0,0 @@
-const locales = {
-    // English
-    en: {
-        invalidString: 'Invalid string',
-        stringMin: (min) => `String must be at least ${min} characters`,
-        stringMax: (max) => `String must be at most ${max} characters`,
-        stringLength: (length) => `String must be exactly ${length} characters`,
-        stringEmail: 'Invalid email address',
-        stringUrl: 'Invalid URL',
-        stringUuid: 'Invalid UUID',
-        stringRegex: 'Invalid format',
-        stringStartsWith: (str) => `String must start with "${str}"`,
-        stringEndsWith: (str) => `String must end with "${str}"`,
-        stringIncludes: (str) => `String must include "${str}"`,
-        stringIp: 'Invalid IP address',
-        stringIpv4: 'Invalid IPv4 address',
-        stringIpv6: 'Invalid IPv6 address',
-        stringEmpty: 'String must not be empty',
-        invalidNumber: 'Invalid number',
-        numberMin: (min) => `Number must be at least ${min}`,
-        numberMax: (max) => `Number must be at most ${max}`,
-        numberInt: 'Number must be an integer',
-        numberPositive: 'Number must be positive',
-        numberNegative: 'Number must be negative',
-        numberNonnegative: 'Number must be non-negative',
-        numberNonpositive: 'Number must be non-positive',
-        numberFinite: 'Number must be finite',
-        numberSafe: 'Number must be a safe integer',
-        numberMultipleOf: (multiple) => `Number must be a multiple of ${multiple}`,
-        invalidBoolean: 'Invalid boolean',
-        invalidDate: 'Invalid date',
-        dateMin: (date) => `Date must be after ${date.toISOString()}`,
-        dateMax: (date) => `Date must be before ${date.toISOString()}`,
-        invalidObject: 'Invalid object',
-        unexpectedKeys: (keys) => `Unexpected keys: ${keys.join(', ')}`,
-        invalidArray: 'Invalid array',
-        arrayMin: (min) => `Array must have at least ${min} items`,
-        arrayMax: (max) => `Array must have at most ${max} items`,
-        arrayLength: (length) => `Array must have exactly ${length} items`,
-        arrayEmpty: 'Array must not be empty',
-        arrayItem: (index, error) => `Invalid item at index ${index}: ${error}`,
-        objectField: (field, error) => `Invalid field "${field}": ${error}`,
-        unionNoMatch: (errors) => `No union member matched: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Expected one of [${values.join(', ')}], got ${JSON.stringify(got)}`,
-        expectedUndefined: 'Expected undefined',
-        neverType: 'Never type cannot be parsed'
-    },
-    // Turkish
-    tr: {
-        invalidString: 'Geçersiz metin',
-        stringMin: (min) => `Metin en az ${min} karakter olmalı`,
-        stringMax: (max) => `Metin en fazla ${max} karakter olmalı`,
-        stringLength: (length) => `Metin tam olarak ${length} karakter olmalı`,
-        stringEmail: 'Geçersiz e-posta adresi',
-        stringUrl: 'Geçersiz URL',
-        stringUuid: 'Geçersiz UUID',
-        stringRegex: 'Geçersiz format',
-        stringStartsWith: (str) => `Metin "${str}" ile başlamalı`,
-        stringEndsWith: (str) => `Metin "${str}" ile bitmeli`,
-        stringIncludes: (str) => `Metin "${str}" içermeli`,
-        stringIp: 'Geçersiz IP adresi',
-        stringIpv4: 'Geçersiz IPv4 adresi',
-        stringIpv6: 'Geçersiz IPv6 adresi',
-        stringEmpty: 'Metin boş olmamalı',
-        invalidNumber: 'Geçersiz sayı',
-        numberMin: (min) => `Sayı en az ${min} olmalı`,
-        numberMax: (max) => `Sayı en fazla ${max} olmalı`,
-        numberInt: 'Sayı tam sayı olmalı',
-        numberPositive: 'Sayı pozitif olmalı',
-        numberNegative: 'Sayı negatif olmalı',
-        numberNonnegative: 'Sayı negatif olmamalı',
-        numberNonpositive: 'Sayı pozitif olmamalı',
-        numberFinite: 'Sayı sonlu olmalı',
-        numberSafe: 'Sayı güvenli tam sayı olmalı',
-        numberMultipleOf: (multiple) => `Sayı ${multiple} katı olmalı`,
-        invalidBoolean: 'Geçersiz boolean',
-        invalidDate: 'Geçersiz tarih',
-        dateMin: (date) => `Tarih ${date.toISOString()} sonrası olmalı`,
-        dateMax: (date) => `Tarih ${date.toISOString()} öncesi olmalı`,
-        invalidObject: 'Geçersiz nesne',
-        unexpectedKeys: (keys) => `Beklenmeyen anahtarlar: ${keys.join(', ')}`,
-        invalidArray: 'Geçersiz dizi',
-        arrayMin: (min) => `Dizi en az ${min} öğe içermeli`,
-        arrayMax: (max) => `Dizi en fazla ${max} öğe içermeli`,
-        arrayLength: (length) => `Dizi tam olarak ${length} öğe içermeli`,
-        arrayEmpty: 'Dizi boş olmamalı',
-        arrayItem: (index, error) => `${index}. öğede hata: ${error}`,
-        objectField: (field, error) => `"${field}" alanında hata: ${error}`,
-        unionNoMatch: (errors) => `Hiçbir seçenek eşleşmedi: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `${JSON.stringify(expected)} bekleniyordu, ${JSON.stringify(got)} geldi`,
-        enumExpected: (values, got) => `[${values.join(', ')}] değerlerinden biri bekleniyordu, ${JSON.stringify(got)} geldi`,
-        expectedUndefined: 'Undefined bekleniyordu',
-        neverType: 'Never tipi parse edilemez'
-    },
-    // Spanish
-    es: {
-        invalidString: 'Cadena inválida',
-        stringMin: (min) => `La cadena debe tener al menos ${min} caracteres`,
-        stringMax: (max) => `La cadena debe tener como máximo ${max} caracteres`,
-        stringLength: (length) => `La cadena debe tener exactamente ${length} caracteres`,
-        stringEmail: 'Dirección de correo inválida',
-        stringUrl: 'URL inválida',
-        stringUuid: 'UUID inválido',
-        stringRegex: 'Formato inválido',
-        stringStartsWith: (str) => `La cadena debe comenzar con "${str}"`,
-        stringEndsWith: (str) => `La cadena debe terminar con "${str}"`,
-        stringIncludes: (str) => `La cadena debe incluir "${str}"`,
-        stringIp: 'Dirección IP inválida',
-        stringIpv4: 'Dirección IPv4 inválida',
-        stringIpv6: 'Dirección IPv6 inválida',
-        stringEmpty: 'La cadena no debe estar vacía',
-        invalidNumber: 'Número inválido',
-        numberMin: (min) => `El número debe ser al menos ${min}`,
-        numberMax: (max) => `El número debe ser como máximo ${max}`,
-        numberInt: 'El número debe ser entero',
-        numberPositive: 'El número debe ser positivo',
-        numberNegative: 'El número debe ser negativo',
-        numberNonnegative: 'El número debe ser no negativo',
-        numberNonpositive: 'El número debe ser no positivo',
-        numberFinite: 'El número debe ser finito',
-        numberSafe: 'El número debe ser un entero seguro',
-        numberMultipleOf: (multiple) => `El número debe ser múltiplo de ${multiple}`,
-        invalidBoolean: 'Booleano inválido',
-        invalidDate: 'Fecha inválida',
-        dateMin: (date) => `La fecha debe ser posterior a ${date.toISOString()}`,
-        dateMax: (date) => `La fecha debe ser anterior a ${date.toISOString()}`,
-        invalidObject: 'Objeto inválido',
-        unexpectedKeys: (keys) => `Claves inesperadas: ${keys.join(', ')}`,
-        invalidArray: 'Array inválido',
-        arrayMin: (min) => `El array debe tener al menos ${min} elementos`,
-        arrayMax: (max) => `El array debe tener como máximo ${max} elementos`,
-        arrayLength: (length) => `El array debe tener exactamente ${length} elementos`,
-        arrayEmpty: 'El array no debe estar vacío',
-        arrayItem: (index, error) => `Elemento inválido en índice ${index}: ${error}`,
-        objectField: (field, error) => `Campo inválido "${field}": ${error}`,
-        unionNoMatch: (errors) => `Ningún miembro de la unión coincidió: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Se esperaba ${JSON.stringify(expected)}, se obtuvo ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Se esperaba uno de [${values.join(', ')}], se obtuvo ${JSON.stringify(got)}`,
-        expectedUndefined: 'Se esperaba undefined',
-        neverType: 'El tipo never no puede ser parseado'
-    },
-    // French
-    fr: {
-        invalidString: 'Chaîne invalide',
-        stringMin: (min) => `La chaîne doit contenir au moins ${min} caractères`,
-        stringMax: (max) => `La chaîne doit contenir au plus ${max} caractères`,
-        stringLength: (length) => `La chaîne doit contenir exactement ${length} caractères`,
-        stringEmail: 'Adresse e-mail invalide',
-        stringUrl: 'URL invalide',
-        stringUuid: 'UUID invalide',
-        stringRegex: 'Format invalide',
-        stringStartsWith: (str) => `La chaîne doit commencer par "${str}"`,
-        stringEndsWith: (str) => `La chaîne doit se terminer par "${str}"`,
-        stringIncludes: (str) => `La chaîne doit inclure "${str}"`,
-        stringIp: 'Adresse IP invalide',
-        stringIpv4: 'Adresse IPv4 invalide',
-        stringIpv6: 'Adresse IPv6 invalide',
-        stringEmpty: 'La chaîne ne doit pas être vide',
-        invalidNumber: 'Nombre invalide',
-        numberMin: (min) => `Le nombre doit être au moins ${min}`,
-        numberMax: (max) => `Le nombre doit être au plus ${max}`,
-        numberInt: 'Le nombre doit être un entier',
-        numberPositive: 'Le nombre doit être positif',
-        numberNegative: 'Le nombre doit être négatif',
-        numberNonnegative: 'Le nombre doit être non négatif',
-        numberNonpositive: 'Le nombre doit être non positif',
-        numberFinite: 'Le nombre doit être fini',
-        numberSafe: 'Le nombre doit être un entier sûr',
-        numberMultipleOf: (multiple) => `Le nombre doit être un multiple de ${multiple}`,
-        invalidBoolean: 'Booléen invalide',
-        invalidDate: 'Date invalide',
-        dateMin: (date) => `La date doit être après ${date.toISOString()}`,
-        dateMax: (date) => `La date doit être avant ${date.toISOString()}`,
-        invalidObject: 'Objet invalide',
-        unexpectedKeys: (keys) => `Clés inattendues: ${keys.join(', ')}`,
-        invalidArray: 'Tableau invalide',
-        arrayMin: (min) => `Le tableau doit avoir au moins ${min} éléments`,
-        arrayMax: (max) => `Le tableau doit avoir au plus ${max} éléments`,
-        arrayLength: (length) => `Le tableau doit avoir exactement ${length} éléments`,
-        arrayEmpty: 'Le tableau ne doit pas être vide',
-        arrayItem: (index, error) => `Élément invalide à l'index ${index}: ${error}`,
-        objectField: (field, error) => `Champ invalide "${field}": ${error}`,
-        unionNoMatch: (errors) => `Aucun membre de l'union ne correspond: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Attendu ${JSON.stringify(expected)}, reçu ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Attendu l'un de [${values.join(', ')}], reçu ${JSON.stringify(got)}`,
-        expectedUndefined: 'Undefined attendu',
-        neverType: 'Le type never ne peut pas être analysé'
-    },
-    // German
-    de: {
-        invalidString: 'Ungültiger String',
-        stringMin: (min) => `String muss mindestens ${min} Zeichen haben`,
-        stringMax: (max) => `String darf maximal ${max} Zeichen haben`,
-        stringLength: (length) => `String muss genau ${length} Zeichen haben`,
-        stringEmail: 'Ungültige E-Mail-Adresse',
-        stringUrl: 'Ungültige URL',
-        stringUuid: 'Ungültige UUID',
-        stringRegex: 'Ungültiges Format',
-        stringStartsWith: (str) => `String muss mit "${str}" beginnen`,
-        stringEndsWith: (str) => `String muss mit "${str}" enden`,
-        stringIncludes: (str) => `String muss "${str}" enthalten`,
-        stringIp: 'Ungültige IP-Adresse',
-        stringIpv4: 'Ungültige IPv4-Adresse',
-        stringIpv6: 'Ungültige IPv6-Adresse',
-        stringEmpty: 'String darf nicht leer sein',
-        invalidNumber: 'Ungültige Zahl',
-        numberMin: (min) => `Zahl muss mindestens ${min} sein`,
-        numberMax: (max) => `Zahl darf maximal ${max} sein`,
-        numberInt: 'Zahl muss eine Ganzzahl sein',
-        numberPositive: 'Zahl muss positiv sein',
-        numberNegative: 'Zahl muss negativ sein',
-        numberNonnegative: 'Zahl darf nicht negativ sein',
-        numberNonpositive: 'Zahl darf nicht positiv sein',
-        numberFinite: 'Zahl muss endlich sein',
-        numberSafe: 'Zahl muss eine sichere Ganzzahl sein',
-        numberMultipleOf: (multiple) => `Zahl muss ein Vielfaches von ${multiple} sein`,
-        invalidBoolean: 'Ungültiger Boolean',
-        invalidDate: 'Ungültiges Datum',
-        dateMin: (date) => `Datum muss nach ${date.toISOString()} sein`,
-        dateMax: (date) => `Datum muss vor ${date.toISOString()} sein`,
-        invalidObject: 'Ungültiges Objekt',
-        unexpectedKeys: (keys) => `Unerwartete Schlüssel: ${keys.join(', ')}`,
-        invalidArray: 'Ungültiges Array',
-        arrayMin: (min) => `Array muss mindestens ${min} Elemente haben`,
-        arrayMax: (max) => `Array darf maximal ${max} Elemente haben`,
-        arrayLength: (length) => `Array muss genau ${length} Elemente haben`,
-        arrayEmpty: 'Array darf nicht leer sein',
-        arrayItem: (index, error) => `Ungültiges Element bei Index ${index}: ${error}`,
-        objectField: (field, error) => `Ungültiges Feld "${field}": ${error}`,
-        unionNoMatch: (errors) => `Kein Union-Mitglied passt: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Erwartet ${JSON.stringify(expected)}, erhalten ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Erwartet eines von [${values.join(', ')}], erhalten ${JSON.stringify(got)}`,
-        expectedUndefined: 'Undefined erwartet',
-        neverType: 'Never-Typ kann nicht geparst werden'
-    },
-    // Italian
-    it: {
-        invalidString: 'Stringa non valida',
-        stringMin: (min) => `La stringa deve avere almeno ${min} caratteri`,
-        stringMax: (max) => `La stringa deve avere al massimo ${max} caratteri`,
-        stringLength: (length) => `La stringa deve avere esattamente ${length} caratteri`,
-        stringEmail: 'Indirizzo email non valido',
-        stringUrl: 'URL non valido',
-        stringUuid: 'UUID non valido',
-        stringRegex: 'Formato non valido',
-        stringStartsWith: (str) => `La stringa deve iniziare con "${str}"`,
-        stringEndsWith: (str) => `La stringa deve terminare con "${str}"`,
-        stringIncludes: (str) => `La stringa deve includere "${str}"`,
-        stringIp: 'Indirizzo IP non valido',
-        stringIpv4: 'Indirizzo IPv4 non valido',
-        stringIpv6: 'Indirizzo IPv6 non valido',
-        stringEmpty: 'La stringa non deve essere vuota',
-        invalidNumber: 'Numero non valido',
-        numberMin: (min) => `Il numero deve essere almeno ${min}`,
-        numberMax: (max) => `Il numero deve essere al massimo ${max}`,
-        numberInt: 'Il numero deve essere intero',
-        numberPositive: 'Il numero deve essere positivo',
-        numberNegative: 'Il numero deve essere negativo',
-        numberNonnegative: 'Il numero deve essere non negativo',
-        numberNonpositive: 'Il numero deve essere non positivo',
-        numberFinite: 'Il numero deve essere finito',
-        numberSafe: 'Il numero deve essere un intero sicuro',
-        numberMultipleOf: (multiple) => `Il numero deve essere un multiplo di ${multiple}`,
-        invalidBoolean: 'Booleano non valido',
-        invalidDate: 'Data non valida',
-        dateMin: (date) => `La data deve essere dopo ${date.toISOString()}`,
-        dateMax: (date) => `La data deve essere prima di ${date.toISOString()}`,
-        invalidObject: 'Oggetto non valido',
-        unexpectedKeys: (keys) => `Chiavi inaspettate: ${keys.join(', ')}`,
-        invalidArray: 'Array non valido',
-        arrayMin: (min) => `L'array deve avere almeno ${min} elementi`,
-        arrayMax: (max) => `L'array deve avere al massimo ${max} elementi`,
-        arrayLength: (length) => `L'array deve avere esattamente ${length} elementi`,
-        arrayEmpty: `L'array non deve essere vuoto`,
-        arrayItem: (index, error) => `Elemento non valido all'indice ${index}: ${error}`,
-        objectField: (field, error) => `Campo non valido "${field}": ${error}`,
-        unionNoMatch: (errors) => `Nessun membro dell'unione corrisponde: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Atteso ${JSON.stringify(expected)}, ricevuto ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Atteso uno tra [${values.join(', ')}], ricevuto ${JSON.stringify(got)}`,
-        expectedUndefined: 'Atteso undefined',
-        neverType: 'Il tipo never non può essere analizzato'
-    },
-    // Portuguese
-    pt: {
-        invalidString: 'String inválida',
-        stringMin: (min) => `String deve ter pelo menos ${min} caracteres`,
-        stringMax: (max) => `String deve ter no máximo ${max} caracteres`,
-        stringLength: (length) => `String deve ter exatamente ${length} caracteres`,
-        stringEmail: 'Endereço de e-mail inválido',
-        stringUrl: 'URL inválida',
-        stringUuid: 'UUID inválido',
-        stringRegex: 'Formato inválido',
-        stringStartsWith: (str) => `String deve começar com "${str}"`,
-        stringEndsWith: (str) => `String deve terminar com "${str}"`,
-        stringIncludes: (str) => `String deve incluir "${str}"`,
-        stringIp: 'Endereço IP inválido',
-        stringIpv4: 'Endereço IPv4 inválido',
-        stringIpv6: 'Endereço IPv6 inválido',
-        stringEmpty: 'String não deve estar vazia',
-        invalidNumber: 'Número inválido',
-        numberMin: (min) => `Número deve ser pelo menos ${min}`,
-        numberMax: (max) => `Número deve ser no máximo ${max}`,
-        numberInt: 'Número deve ser inteiro',
-        numberPositive: 'Número deve ser positivo',
-        numberNegative: 'Número deve ser negativo',
-        numberNonnegative: 'Número deve ser não negativo',
-        numberNonpositive: 'Número deve ser não positivo',
-        numberFinite: 'Número deve ser finito',
-        numberSafe: 'Número deve ser um inteiro seguro',
-        numberMultipleOf: (multiple) => `Número deve ser múltiplo de ${multiple}`,
-        invalidBoolean: 'Booleano inválido',
-        invalidDate: 'Data inválida',
-        dateMin: (date) => `Data deve ser após ${date.toISOString()}`,
-        dateMax: (date) => `Data deve ser antes de ${date.toISOString()}`,
-        invalidObject: 'Objeto inválido',
-        unexpectedKeys: (keys) => `Chaves inesperadas: ${keys.join(', ')}`,
-        invalidArray: 'Array inválido',
-        arrayMin: (min) => `Array deve ter pelo menos ${min} itens`,
-        arrayMax: (max) => `Array deve ter no máximo ${max} itens`,
-        arrayLength: (length) => `Array deve ter exatamente ${length} itens`,
-        arrayEmpty: 'Array não deve estar vazio',
-        arrayItem: (index, error) => `Item inválido no índice ${index}: ${error}`,
-        objectField: (field, error) => `Campo inválido "${field}": ${error}`,
-        unionNoMatch: (errors) => `Nenhum membro da união correspondeu: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Esperado ${JSON.stringify(expected)}, recebido ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Esperado um de [${values.join(', ')}], recebido ${JSON.stringify(got)}`,
-        expectedUndefined: 'Esperado undefined',
-        neverType: 'Tipo never não pode ser analisado'
-    },
-    // Russian
-    ru: {
-        invalidString: 'Недопустимая строка',
-        stringMin: (min) => `Строка должна содержать не менее ${min} символов`,
-        stringMax: (max) => `Строка должна содержать не более ${max} символов`,
-        stringLength: (length) => `Строка должна содержать ровно ${length} символов`,
-        stringEmail: 'Недопустимый адрес электронной почты',
-        stringUrl: 'Недопустимый URL',
-        stringUuid: 'Недопустимый UUID',
-        stringRegex: 'Недопустимый формат',
-        stringStartsWith: (str) => `Строка должна начинаться с "${str}"`,
-        stringEndsWith: (str) => `Строка должна заканчиваться на "${str}"`,
-        stringIncludes: (str) => `Строка должна содержать "${str}"`,
-        stringIp: 'Недопустимый IP-адрес',
-        stringIpv4: 'Недопустимый IPv4-адрес',
-        stringIpv6: 'Недопустимый IPv6-адрес',
-        stringEmpty: 'Строка не должна быть пустой',
-        invalidNumber: 'Недопустимое число',
-        numberMin: (min) => `Число должно быть не менее ${min}`,
-        numberMax: (max) => `Число должно быть не более ${max}`,
-        numberInt: 'Число должно быть целым',
-        numberPositive: 'Число должно быть положительным',
-        numberNegative: 'Число должно быть отрицательным',
-        numberNonnegative: 'Число должно быть неотрицательным',
-        numberNonpositive: 'Число должно быть неположительным',
-        numberFinite: 'Число должно быть конечным',
-        numberSafe: 'Число должно быть безопасным целым',
-        numberMultipleOf: (multiple) => `Число должно быть кратным ${multiple}`,
-        invalidBoolean: 'Недопустимое логическое значение',
-        invalidDate: 'Недопустимая дата',
-        dateMin: (date) => `Дата должна быть после ${date.toISOString()}`,
-        dateMax: (date) => `Дата должна быть до ${date.toISOString()}`,
-        invalidObject: 'Недопустимый объект',
-        unexpectedKeys: (keys) => `Неожиданные ключи: ${keys.join(', ')}`,
-        invalidArray: 'Недопустимый массив',
-        arrayMin: (min) => `Массив должен содержать не менее ${min} элементов`,
-        arrayMax: (max) => `Массив должен содержать не более ${max} элементов`,
-        arrayLength: (length) => `Массив должен содержать ровно ${length} элементов`,
-        arrayEmpty: 'Массив не должен быть пустым',
-        arrayItem: (index, error) => `Недопустимый элемент с индексом ${index}: ${error}`,
-        objectField: (field, error) => `Недопустимое поле "${field}": ${error}`,
-        unionNoMatch: (errors) => `Ни один член объединения не подошел: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Ожидалось ${JSON.stringify(expected)}, получено ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Ожидалось одно из [${values.join(', ')}], получено ${JSON.stringify(got)}`,
-        expectedUndefined: 'Ожидалось undefined',
-        neverType: 'Тип never не может быть проанализирован'
-    },
-    // Japanese
-    ja: {
-        invalidString: '無効な文字列',
-        stringMin: (min) => `文字列は${min}文字以上である必要があります`,
-        stringMax: (max) => `文字列は${max}文字以下である必要があります`,
-        stringLength: (length) => `文字列はちょうど${length}文字である必要があります`,
-        stringEmail: '無効なメールアドレス',
-        stringUrl: '無効なURL',
-        stringUuid: '無効なUUID',
-        stringRegex: '無効な形式',
-        stringStartsWith: (str) => `文字列は"${str}"で始まる必要があります`,
-        stringEndsWith: (str) => `文字列は"${str}"で終わる必要があります`,
-        stringIncludes: (str) => `文字列は"${str}"を含む必要があります`,
-        stringIp: '無効なIPアドレス',
-        stringIpv4: '無効なIPv4アドレス',
-        stringIpv6: '無効なIPv6アドレス',
-        stringEmpty: '文字列は空であってはなりません',
-        invalidNumber: '無効な数値',
-        numberMin: (min) => `数値は${min}以上である必要があります`,
-        numberMax: (max) => `数値は${max}以下である必要があります`,
-        numberInt: '数値は整数である必要があります',
-        numberPositive: '数値は正である必要があります',
-        numberNegative: '数値は負である必要があります',
-        numberNonnegative: '数値は非負である必要があります',
-        numberNonpositive: '数値は非正である必要があります',
-        numberFinite: '数値は有限である必要があります',
-        numberSafe: '数値は安全な整数である必要があります',
-        numberMultipleOf: (multiple) => `数値は${multiple}の倍数である必要があります`,
-        invalidBoolean: '無効なブール値',
-        invalidDate: '無効な日付',
-        dateMin: (date) => `日付は${date.toISOString()}より後である必要があります`,
-        dateMax: (date) => `日付は${date.toISOString()}より前である必要があります`,
-        invalidObject: '無効なオブジェクト',
-        unexpectedKeys: (keys) => `予期しないキー: ${keys.join(', ')}`,
-        invalidArray: '無効な配列',
-        arrayMin: (min) => `配列は少なくとも${min}個の要素を持つ必要があります`,
-        arrayMax: (max) => `配列は最大${max}個の要素を持つ必要があります`,
-        arrayLength: (length) => `配列はちょうど${length}個の要素を持つ必要があります`,
-        arrayEmpty: '配列は空であってはなりません',
-        arrayItem: (index, error) => `インデックス${index}の無効な要素: ${error}`,
-        objectField: (field, error) => `無効なフィールド"${field}": ${error}`,
-        unionNoMatch: (errors) => `ユニオンメンバーが一致しませんでした: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `${JSON.stringify(expected)}が期待されましたが、${JSON.stringify(got)}を受け取りました`,
-        enumExpected: (values, got) => `[${values.join(', ')}]のいずれかが期待されましたが、${JSON.stringify(got)}を受け取りました`,
-        expectedUndefined: 'undefinedが期待されました',
-        neverType: 'never型は解析できません'
-    },
-    // Korean
-    ko: {
-        invalidString: '유효하지 않은 문자열',
-        stringMin: (min) => `문자열은 최소 ${min}자여야 합니다`,
-        stringMax: (max) => `문자열은 최대 ${max}자여야 합니다`,
-        stringLength: (length) => `문자열은 정확히 ${length}자여야 합니다`,
-        stringEmail: '유효하지 않은 이메일 주소',
-        stringUrl: '유효하지 않은 URL',
-        stringUuid: '유효하지 않은 UUID',
-        stringRegex: '유효하지 않은 형식',
-        stringStartsWith: (str) => `문자열은 "${str}"로 시작해야 합니다`,
-        stringEndsWith: (str) => `문자열은 "${str}"로 끝나야 합니다`,
-        stringIncludes: (str) => `문자열은 "${str}"를 포함해야 합니다`,
-        stringIp: '유효하지 않은 IP 주소',
-        stringIpv4: '유효하지 않은 IPv4 주소',
-        stringIpv6: '유효하지 않은 IPv6 주소',
-        stringEmpty: '문자열은 비어있으면 안 됩니다',
-        invalidNumber: '유효하지 않은 숫자',
-        numberMin: (min) => `숫자는 최소 ${min}이어야 합니다`,
-        numberMax: (max) => `숫자는 최대 ${max}이어야 합니다`,
-        numberInt: '숫자는 정수여야 합니다',
-        numberPositive: '숫자는 양수여야 합니다',
-        numberNegative: '숫자는 음수여야 합니다',
-        numberNonnegative: '숫자는 음이 아니어야 합니다',
-        numberNonpositive: '숫자는 양이 아니어야 합니다',
-        numberFinite: '숫자는 유한해야 합니다',
-        numberSafe: '숫자는 안전한 정수여야 합니다',
-        numberMultipleOf: (multiple) => `숫자는 ${multiple}의 배수여야 합니다`,
-        invalidBoolean: '유효하지 않은 불린',
-        invalidDate: '유효하지 않은 날짜',
-        dateMin: (date) => `날짜는 ${date.toISOString()} 이후여야 합니다`,
-        dateMax: (date) => `날짜는 ${date.toISOString()} 이전이어야 합니다`,
-        invalidObject: '유효하지 않은 객체',
-        unexpectedKeys: (keys) => `예상치 못한 키: ${keys.join(', ')}`,
-        invalidArray: '유효하지 않은 배열',
-        arrayMin: (min) => `배열은 최소 ${min}개의 요소를 가져야 합니다`,
-        arrayMax: (max) => `배열은 최대 ${max}개의 요소를 가져야 합니다`,
-        arrayLength: (length) => `배열은 정확히 ${length}개의 요소를 가져야 합니다`,
-        arrayEmpty: '배열은 비어있으면 안 됩니다',
-        arrayItem: (index, error) => `인덱스 ${index}의 유효하지 않은 요소: ${error}`,
-        objectField: (field, error) => `유효하지 않은 필드 "${field}": ${error}`,
-        unionNoMatch: (errors) => `일치하는 유니온 멤버가 없습니다: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `${JSON.stringify(expected)}가 예상되었지만 ${JSON.stringify(got)}를 받았습니다`,
-        enumExpected: (values, got) => `[${values.join(', ')}] 중 하나가 예상되었지만 ${JSON.stringify(got)}를 받았습니다`,
-        expectedUndefined: 'undefined가 예상되었습니다',
-        neverType: 'never 타입은 파싱할 수 없습니다'
-    },
-    // Chinese
-    zh: {
-        invalidString: '无效的字符串',
-        stringMin: (min) => `字符串至少需要${min}个字符`,
-        stringMax: (max) => `字符串最多${max}个字符`,
-        stringLength: (length) => `字符串必须正好${length}个字符`,
-        stringEmail: '无效的电子邮件地址',
-        stringUrl: '无效的URL',
-        stringUuid: '无效的UUID',
-        stringRegex: '无效的格式',
-        stringStartsWith: (str) => `字符串必须以"${str}"开头`,
-        stringEndsWith: (str) => `字符串必须以"${str}"结尾`,
-        stringIncludes: (str) => `字符串必须包含"${str}"`,
-        stringIp: '无效的IP地址',
-        stringIpv4: '无效的IPv4地址',
-        stringIpv6: '无效的IPv6地址',
-        stringEmpty: '字符串不能为空',
-        invalidNumber: '无效的数字',
-        numberMin: (min) => `数字至少为${min}`,
-        numberMax: (max) => `数字最多为${max}`,
-        numberInt: '数字必须是整数',
-        numberPositive: '数字必须是正数',
-        numberNegative: '数字必须是负数',
-        numberNonnegative: '数字必须是非负数',
-        numberNonpositive: '数字必须是非正数',
-        numberFinite: '数字必须是有限的',
-        numberSafe: '数字必须是安全整数',
-        numberMultipleOf: (multiple) => `数字必须是${multiple}的倍数`,
-        invalidBoolean: '无效的布尔值',
-        invalidDate: '无效的日期',
-        dateMin: (date) => `日期必须在${date.toISOString()}之后`,
-        dateMax: (date) => `日期必须在${date.toISOString()}之前`,
-        invalidObject: '无效的对象',
-        unexpectedKeys: (keys) => `意外的键: ${keys.join(', ')}`,
-        invalidArray: '无效的数组',
-        arrayMin: (min) => `数组至少需要${min}个元素`,
-        arrayMax: (max) => `数组最多${max}个元素`,
-        arrayLength: (length) => `数组必须正好${length}个元素`,
-        arrayEmpty: '数组不能为空',
-        arrayItem: (index, error) => `索引${index}处的无效元素: ${error}`,
-        objectField: (field, error) => `无效字段"${field}": ${error}`,
-        unionNoMatch: (errors) => `没有匹配的联合成员: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `期望${JSON.stringify(expected)}，得到${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `期望[${values.join(', ')}]之一，得到${JSON.stringify(got)}`,
-        expectedUndefined: '期望undefined',
-        neverType: 'never类型无法解析'
-    },
-    // Arabic
-    ar: {
-        invalidString: 'نص غير صالح',
-        stringMin: (min) => `يجب أن يحتوي النص على ${min} حرف على الأقل`,
-        stringMax: (max) => `يجب أن يحتوي النص على ${max} حرف كحد أقصى`,
-        stringLength: (length) => `يجب أن يحتوي النص على ${length} حرف بالضبط`,
-        stringEmail: 'عنوان بريد إلكتروني غير صالح',
-        stringUrl: 'عنوان URL غير صالح',
-        stringUuid: 'UUID غير صالح',
-        stringRegex: 'تنسيق غير صالح',
-        stringStartsWith: (str) => `يجب أن يبدأ النص بـ "${str}"`,
-        stringEndsWith: (str) => `يجب أن ينتهي النص بـ "${str}"`,
-        stringIncludes: (str) => `يجب أن يحتوي النص على "${str}"`,
-        stringIp: 'عنوان IP غير صالح',
-        stringIpv4: 'عنوان IPv4 غير صالح',
-        stringIpv6: 'عنوان IPv6 غير صالح',
-        stringEmpty: 'يجب ألا يكون النص فارغًا',
-        invalidNumber: 'رقم غير صالح',
-        numberMin: (min) => `يجب أن يكون الرقم ${min} على الأقل`,
-        numberMax: (max) => `يجب أن يكون الرقم ${max} كحد أقصى`,
-        numberInt: 'يجب أن يكون الرقم صحيحًا',
-        numberPositive: 'يجب أن يكون الرقم موجبًا',
-        numberNegative: 'يجب أن يكون الرقم سالبًا',
-        numberNonnegative: 'يجب أن يكون الرقم غير سالب',
-        numberNonpositive: 'يجب أن يكون الرقم غير موجب',
-        numberFinite: 'يجب أن يكون الرقم محدودًا',
-        numberSafe: 'يجب أن يكون الرقم صحيحًا آمنًا',
-        numberMultipleOf: (multiple) => `يجب أن يكون الرقم من مضاعفات ${multiple}`,
-        invalidBoolean: 'قيمة منطقية غير صالحة',
-        invalidDate: 'تاريخ غير صالح',
-        dateMin: (date) => `يجب أن يكون التاريخ بعد ${date.toISOString()}`,
-        dateMax: (date) => `يجب أن يكون التاريخ قبل ${date.toISOString()}`,
-        invalidObject: 'كائن غير صالح',
-        unexpectedKeys: (keys) => `مفاتيح غير متوقعة: ${keys.join(', ')}`,
-        invalidArray: 'مصفوفة غير صالحة',
-        arrayMin: (min) => `يجب أن تحتوي المصفوفة على ${min} عنصر على الأقل`,
-        arrayMax: (max) => `يجب أن تحتوي المصفوفة على ${max} عنصر كحد أقصى`,
-        arrayLength: (length) => `يجب أن تحتوي المصفوفة على ${length} عنصر بالضبط`,
-        arrayEmpty: 'يجب ألا تكون المصفوفة فارغة',
-        arrayItem: (index, error) => `عنصر غير صالح في الفهرس ${index}: ${error}`,
-        objectField: (field, error) => `حقل غير صالح "${field}": ${error}`,
-        unionNoMatch: (errors) => `لا يوجد عضو اتحاد مطابق: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `متوقع ${JSON.stringify(expected)}، حصلت على ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `متوقع واحد من [${values.join(', ')}]، حصلت على ${JSON.stringify(got)}`,
-        expectedUndefined: 'متوقع undefined',
-        neverType: 'لا يمكن تحليل النوع never'
-    },
-    // Hindi
-    hi: {
-        invalidString: 'अमान्य स्ट्रिंग',
-        stringMin: (min) => `स्ट्रिंग में कम से कम ${min} अक्षर होने चाहिए`,
-        stringMax: (max) => `स्ट्रिंग में अधिकतम ${max} अक्षर होने चाहिए`,
-        stringLength: (length) => `स्ट्रिंग में ठीक ${length} अक्षर होने चाहिए`,
-        stringEmail: 'अमान्य ईमेल पता',
-        stringUrl: 'अमान्य URL',
-        stringUuid: 'अमान्य UUID',
-        stringRegex: 'अमान्य प्रारूप',
-        stringStartsWith: (str) => `स्ट्रिंग "${str}" से शुरू होनी चाहिए`,
-        stringEndsWith: (str) => `स्ट्रिंग "${str}" पर समाप्त होनी चाहिए`,
-        stringIncludes: (str) => `स्ट्रिंग में "${str}" शामिल होना चाहिए`,
-        stringIp: 'अमान्य IP पता',
-        stringIpv4: 'अमान्य IPv4 पता',
-        stringIpv6: 'अमान्य IPv6 पता',
-        stringEmpty: 'स्ट्रिंग खाली नहीं होनी चाहिए',
-        invalidNumber: 'अमान्य संख्या',
-        numberMin: (min) => `संख्या कम से कम ${min} होनी चाहिए`,
-        numberMax: (max) => `संख्या अधिकतम ${max} होनी चाहिए`,
-        numberInt: 'संख्या पूर्णांक होनी चाहिए',
-        numberPositive: 'संख्या धनात्मक होनी चाहिए',
-        numberNegative: 'संख्या ऋणात्मक होनी चाहिए',
-        numberNonnegative: 'संख्या गैर-ऋणात्मक होनी चाहिए',
-        numberNonpositive: 'संख्या गैर-धनात्मक होनी चाहिए',
-        numberFinite: 'संख्या परिमित होनी चाहिए',
-        numberSafe: 'संख्या सुरक्षित पूर्णांक होनी चाहिए',
-        numberMultipleOf: (multiple) => `संख्या ${multiple} का गुणज होनी चाहिए`,
-        invalidBoolean: 'अमान्य बूलियन',
-        invalidDate: 'अमान्य तारीख',
-        dateMin: (date) => `तारीख ${date.toISOString()} के बाद होनी चाहिए`,
-        dateMax: (date) => `तारीख ${date.toISOString()} से पहले होनी चाहिए`,
-        invalidObject: 'अमान्य ऑब्जेक्ट',
-        unexpectedKeys: (keys) => `अप्रत्याशित कुंजियाँ: ${keys.join(', ')}`,
-        invalidArray: 'अमान्य सरणी',
-        arrayMin: (min) => `सरणी में कम से कम ${min} तत्व होने चाहिए`,
-        arrayMax: (max) => `सरणी में अधिकतम ${max} तत्व होने चाहिए`,
-        arrayLength: (length) => `सरणी में ठीक ${length} तत्व होने चाहिए`,
-        arrayEmpty: 'सरणी खाली नहीं होनी चाहिए',
-        arrayItem: (index, error) => `इंडेक्स ${index} पर अमान्य तत्व: ${error}`,
-        objectField: (field, error) => `अमान्य फील्ड "${field}": ${error}`,
-        unionNoMatch: (errors) => `कोई यूनियन सदस्य मेल नहीं खाता: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `${JSON.stringify(expected)} की उम्मीद थी, ${JSON.stringify(got)} मिला`,
-        enumExpected: (values, got) => `[${values.join(', ')}] में से एक की उम्मीद थी, ${JSON.stringify(got)} मिला`,
-        expectedUndefined: 'undefined की उम्मीद थी',
-        neverType: 'never प्रकार को पार्स नहीं किया जा सकता'
-    },
-    // Dutch
-    nl: {
-        invalidString: 'Ongeldige string',
-        stringMin: (min) => `String moet minstens ${min} tekens bevatten`,
-        stringMax: (max) => `String mag maximaal ${max} tekens bevatten`,
-        stringLength: (length) => `String moet precies ${length} tekens bevatten`,
-        stringEmail: 'Ongeldig e-mailadres',
-        stringUrl: 'Ongeldige URL',
-        stringUuid: 'Ongeldige UUID',
-        stringRegex: 'Ongeldig formaat',
-        stringStartsWith: (str) => `String moet beginnen met "${str}"`,
-        stringEndsWith: (str) => `String moet eindigen met "${str}"`,
-        stringIncludes: (str) => `String moet "${str}" bevatten`,
-        stringIp: 'Ongeldig IP-adres',
-        stringIpv4: 'Ongeldig IPv4-adres',
-        stringIpv6: 'Ongeldig IPv6-adres',
-        stringEmpty: 'String mag niet leeg zijn',
-        invalidNumber: 'Ongeldig nummer',
-        numberMin: (min) => `Nummer moet minstens ${min} zijn`,
-        numberMax: (max) => `Nummer mag maximaal ${max} zijn`,
-        numberInt: 'Nummer moet een geheel getal zijn',
-        numberPositive: 'Nummer moet positief zijn',
-        numberNegative: 'Nummer moet negatief zijn',
-        numberNonnegative: 'Nummer mag niet negatief zijn',
-        numberNonpositive: 'Nummer mag niet positief zijn',
-        numberFinite: 'Nummer moet eindig zijn',
-        numberSafe: 'Nummer moet een veilig geheel getal zijn',
-        numberMultipleOf: (multiple) => `Nummer moet een veelvoud van ${multiple} zijn`,
-        invalidBoolean: 'Ongeldige boolean',
-        invalidDate: 'Ongeldige datum',
-        dateMin: (date) => `Datum moet na ${date.toISOString()} zijn`,
-        dateMax: (date) => `Datum moet voor ${date.toISOString()} zijn`,
-        invalidObject: 'Ongeldig object',
-        unexpectedKeys: (keys) => `Onverwachte sleutels: ${keys.join(', ')}`,
-        invalidArray: 'Ongeldige array',
-        arrayMin: (min) => `Array moet minstens ${min} elementen bevatten`,
-        arrayMax: (max) => `Array mag maximaal ${max} elementen bevatten`,
-        arrayLength: (length) => `Array moet precies ${length} elementen bevatten`,
-        arrayEmpty: 'Array mag niet leeg zijn',
-        arrayItem: (index, error) => `Ongeldig element op index ${index}: ${error}`,
-        objectField: (field, error) => `Ongeldig veld "${field}": ${error}`,
-        unionNoMatch: (errors) => `Geen union-lid kwam overeen: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Verwachtte ${JSON.stringify(expected)}, kreeg ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Verwachtte een van [${values.join(', ')}], kreeg ${JSON.stringify(got)}`,
-        expectedUndefined: 'Verwachtte undefined',
-        neverType: 'Never type kan niet worden geparseerd'
-    },
-    // Polish
-    pl: {
-        invalidString: 'Nieprawidłowy ciąg znaków',
-        stringMin: (min) => `Ciąg znaków musi mieć co najmniej ${min} znaków`,
-        stringMax: (max) => `Ciąg znaków może mieć maksymalnie ${max} znaków`,
-        stringLength: (length) => `Ciąg znaków musi mieć dokładnie ${length} znaków`,
-        stringEmail: 'Nieprawidłowy adres e-mail',
-        stringUrl: 'Nieprawidłowy URL',
-        stringUuid: 'Nieprawidłowy UUID',
-        stringRegex: 'Nieprawidłowy format',
-        stringStartsWith: (str) => `Ciąg znaków musi zaczynać się od "${str}"`,
-        stringEndsWith: (str) => `Ciąg znaków musi kończyć się na "${str}"`,
-        stringIncludes: (str) => `Ciąg znaków musi zawierać "${str}"`,
-        stringIp: 'Nieprawidłowy adres IP',
-        stringIpv4: 'Nieprawidłowy adres IPv4',
-        stringIpv6: 'Nieprawidłowy adres IPv6',
-        stringEmpty: 'Ciąg znaków nie może być pusty',
-        invalidNumber: 'Nieprawidłowa liczba',
-        numberMin: (min) => `Liczba musi wynosić co najmniej ${min}`,
-        numberMax: (max) => `Liczba może wynosić maksymalnie ${max}`,
-        numberInt: 'Liczba musi być liczbą całkowitą',
-        numberPositive: 'Liczba musi być dodatnia',
-        numberNegative: 'Liczba musi być ujemna',
-        numberNonnegative: 'Liczba nie może być ujemna',
-        numberNonpositive: 'Liczba nie może być dodatnia',
-        numberFinite: 'Liczba musi być skończona',
-        numberSafe: 'Liczba musi być bezpieczną liczbą całkowitą',
-        numberMultipleOf: (multiple) => `Liczba musi być wielokrotnością ${multiple}`,
-        invalidBoolean: 'Nieprawidłowa wartość logiczna',
-        invalidDate: 'Nieprawidłowa data',
-        dateMin: (date) => `Data musi być po ${date.toISOString()}`,
-        dateMax: (date) => `Data musi być przed ${date.toISOString()}`,
-        invalidObject: 'Nieprawidłowy obiekt',
-        unexpectedKeys: (keys) => `Nieoczekiwane klucze: ${keys.join(', ')}`,
-        invalidArray: 'Nieprawidłowa tablica',
-        arrayMin: (min) => `Tablica musi mieć co najmniej ${min} elementów`,
-        arrayMax: (max) => `Tablica może mieć maksymalnie ${max} elementów`,
-        arrayLength: (length) => `Tablica musi mieć dokładnie ${length} elementów`,
-        arrayEmpty: 'Tablica nie może być pusta',
-        arrayItem: (index, error) => `Nieprawidłowy element o indeksie ${index}: ${error}`,
-        objectField: (field, error) => `Nieprawidłowe pole "${field}": ${error}`,
-        unionNoMatch: (errors) => `Żaden członek unii nie pasuje: ${errors.join(', ')}`,
-        literalExpected: (expected, got) => `Oczekiwano ${JSON.stringify(expected)}, otrzymano ${JSON.stringify(got)}`,
-        enumExpected: (values, got) => `Oczekiwano jednej z [${values.join(', ')}], otrzymano ${JSON.stringify(got)}`,
-        expectedUndefined: 'Oczekiwano undefined',
-        neverType: 'Typ never nie może być analizowany'
-    }
-};
-// Global locale state
-let currentLocale = 'en';
-// Set locale
-export function setLocale(locale) {
-    if (locales[locale]) {
-        currentLocale = locale;
-    }
-    else {
-        throw new Error(`Unsupported locale: ${locale}`);
-    }
-}
-// Get current locale
-export function getLocale() {
-    return currentLocale;
-}
-// Get messages for current locale
-export function getMessages() {
-    return locales[currentLocale];
-}
-// Get message for specific locale
-export function getMessagesForLocale(locale) {
-    return locales[locale] || locales.en;
-}
-export default locales;
-//# sourceMappingURL=locales.js.map