@oxog/vld 2.0.3 → 2.1.0

package/dist/cjs/locales/bn.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const bn = {
+    // String validation messages
+    invalidString: 'অবৈধ স্ট্রিং',
+    stringMin: (min) => `স্ট্রিং কমপক্ষে ${min} অক্ষরের হতে হবে`,
+    stringMax: (max) => `স্ট্রিং সর্বোচ্চ ${max} অক্ষরের হতে পারে`,
+    stringLength: (length) => `স্ট্রিং ঠিক ${length} অক্ষরের হতে হবে`,
+    stringEmail: 'অবৈধ ইমেইল ঠিকানা',
+    stringUrl: 'অবৈধ URL',
+    stringUuid: 'অবৈধ UUID',
+    stringRegex: 'অবৈধ ফরম্যাট',
+    stringStartsWith: (prefix) => `স্ট্রিং "${prefix}" দিয়ে শুরু হতে হবে`,
+    stringEndsWith: (suffix) => `স্ট্রিং "${suffix}" দিয়ে শেষ হতে হবে`,
+    stringIncludes: (substring) => `স্ট্রিং-এ "${substring}" থাকতে হবে`,
+    stringIp: 'অবৈধ IP ঠিকানা',
+    stringIpv4: 'অবৈধ IPv4 ঠিকানা',
+    stringIpv6: 'অবৈধ IPv6 ঠিকানা',
+    stringEmpty: 'স্ট্রিং খালি হতে পারবে না',
+    // Number validation messages
+    invalidNumber: 'অবৈধ সংখ্যা',
+    numberMin: (min) => `সংখ্যা কমপক্ষে ${min} হতে হবে`,
+    numberMax: (max) => `সংখ্যা সর্বোচ্চ ${max} হতে পারে`,
+    numberInt: 'সংখ্যাটি একটি পূর্ণসংখ্যা হতে হবে',
+    numberPositive: 'সংখ্যাটি ধনাত্মক হতে হবে',
+    numberNegative: 'সংখ্যাটি ঋণাত্মক হতে হবে',
+    numberNonnegative: 'সংখ্যাটি ঋণাত্মক হতে পারবে না',
+    numberNonpositive: 'সংখ্যাটি ধনাত্মক হতে পারবে না',
+    numberFinite: 'সংখ্যাটি সসীম হতে হবে',
+    numberSafe: 'সংখ্যাটি একটি নিরাপদ পূর্ণসংখ্যা হতে হবে',
+    numberMultipleOf: (value) => `সংখ্যাটি ${value} এর গুণিতক হতে হবে`,
+    // Boolean validation messages
+    invalidBoolean: 'অবৈধ বুলিয়ান মান',
+    // Date validation messages
+    invalidDate: 'অবৈধ তারিখ',
+    dateMin: (date) => `তারিখ ${date.toISOString()} এর পরে হতে হবে`,
+    dateMax: (date) => `তারিখ ${date.toISOString()} এর আগে হতে হবে`,
+    // Object validation messages
+    invalidObject: 'অবৈধ অবজেক্ট',
+    unexpectedKeys: (keys) => `অপ্রত্যাশিত কী: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'অবৈধ অ্যারে',
+    arrayMin: (min) => `অ্যারে-তে কমপক্ষে ${min}টি উপাদান থাকতে হবে`,
+    arrayMax: (max) => `অ্যারে-তে সর্বোচ্চ ${max}টি উপাদান থাকতে পারে`,
+    arrayLength: (length) => `অ্যারে-তে ঠিক ${length}টি উপাদান থাকতে হবে`,
+    arrayEmpty: 'অ্যারে খালি হতে পারবে না',
+    arrayItem: (index, error) => `${index} ইনডেক্সে অবৈধ উপাদান: ${error}`,
+    // Object field validation
+    objectField: (field, error) => `অবৈধ ফিল্ড "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `কোন ইউনিয়ন সদস্য মিলেনি: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `ইন্টারসেকশন যাচাই ব্যর্থ: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `প্রত্যাশিত ${expected}, পেয়েছি ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `[${values.join(', ')}] এর মধ্যে একটি প্রত্যাশিত, পেয়েছি ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'undefined প্রত্যাশিত',
+    neverType: 'Never টাইপ পার্স করা যায় না',
+    // New advanced type validation messages
+    invalidBigint: 'অবৈধ bigint',
+    invalidSymbol: 'অবৈধ সিম্বল',
+    invalidTuple: 'অবৈধ টুপল',
+    tupleLength: (expected, received) => `টুপলে ঠিক ${expected}টি উপাদান থাকতে হবে, পেয়েছি ${received}`,
+    invalidRecord: 'অবৈধ রেকর্ড',
+    invalidSet: 'অবৈধ Set',
+    invalidMap: 'অবৈধ Map',
+    // Transformation and refinement messages
+    transformError: (error) => `রূপান্তর ব্যর্থ: ${error}`,
+    refinementError: (error) => `পরিমার্জনা ব্যর্থ: ${error}`,
+    customValidationError: (error) => `কাস্টম যাচাইকরণ ব্যর্থ: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `${JSON.stringify(value)} কে ${type} এ রূপান্তর করা যায়নি`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `প্রত্যাশিত ${expected}, পেয়েছি ${received}`,
+    stringBoolExpected: (validValues, received) => `অবৈধ বুলিয়ান স্ট্রিং। নিম্নলিখিতগুলির একটি প্রত্যাশিত: ${validValues}, পেয়েছি: "${received}"`,
+    invalidJson: 'অবৈধ JSON',
+    stringPatternInvalid: 'স্ট্রিংটি প্রয়োজনীয় প্যাটার্নের সাথে মেলে না',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
+    // Function validation messages
+    invalidFunction: 'একটি ফাংশন প্রত্যাশিত',
+    // CIDR validation messages
+    stringCidrv4: 'অবৈধ IPv4 CIDR ব্লক',
+    stringCidrv6: 'অবৈধ IPv6 CIDR ব্লক',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `বিদ্যমান কীগুলি ওভাররাইড করা যায় না: ${keys.join(', ')}। ওভাররাইড করতে extend() ব্যবহার করুন।`
+};
+
+exports.bn = bn;

package/dist/cjs/locales/da.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const da = {
+    // String validation messages
+    invalidString: 'Ugyldig streng',
+    stringMin: (min) => `Streng skal være mindst ${min} tegn lang`,
+    stringMax: (max) => `Streng må højst være ${max} tegn lang`,
+    stringLength: (length) => `Streng skal være præcis ${length} tegn lang`,
+    stringEmail: 'Ugyldig e-mailadresse',
+    stringUrl: 'Ugyldig URL',
+    stringUuid: 'Ugyldig UUID',
+    stringRegex: 'Ugyldigt format',
+    stringStartsWith: (prefix) => `Streng skal starte med "${prefix}"`,
+    stringEndsWith: (suffix) => `Streng skal slutte med "${suffix}"`,
+    stringIncludes: (substring) => `Streng skal indeholde "${substring}"`,
+    stringIp: 'Ugyldig IP-adresse',
+    stringIpv4: 'Ugyldig IPv4-adresse',
+    stringIpv6: 'Ugyldig IPv6-adresse',
+    stringEmpty: 'Streng må ikke være tom',
+    // Number validation messages
+    invalidNumber: 'Ugyldigt tal',
+    numberMin: (min) => `Tal skal være mindst ${min}`,
+    numberMax: (max) => `Tal må højst være ${max}`,
+    numberInt: 'Tal skal være et heltal',
+    numberPositive: 'Tal skal være positivt',
+    numberNegative: 'Tal skal være negativt',
+    numberNonnegative: 'Tal må ikke være negativt',
+    numberNonpositive: 'Tal må ikke være positivt',
+    numberFinite: 'Tal skal være endeligt',
+    numberSafe: 'Tal skal være et sikkert heltal',
+    numberMultipleOf: (value) => `Tal skal være et multiplum af ${value}`,
+    // Boolean validation messages
+    invalidBoolean: 'Ugyldig boolean-værdi',
+    // Date validation messages
+    invalidDate: 'Ugyldig dato',
+    dateMin: (date) => `Dato skal være efter ${date.toISOString()}`,
+    dateMax: (date) => `Dato skal være før ${date.toISOString()}`,
+    // Object validation messages
+    invalidObject: 'Ugyldigt objekt',
+    unexpectedKeys: (keys) => `Uventede nøgler: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'Ugyldigt array',
+    arrayMin: (min) => `Array skal have mindst ${min} elementer`,
+    arrayMax: (max) => `Array må højst have ${max} elementer`,
+    arrayLength: (length) => `Array skal have præcis ${length} elementer`,
+    arrayEmpty: 'Array må ikke være tomt',
+    arrayItem: (index, error) => `Ugyldigt element ved indeks ${index}: ${error}`,
+    // Object field validation
+    objectField: (field, error) => `Ugyldigt felt "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `Intet union-medlem matchede: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `Intersection validering fejlede: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `Forventede ${expected}, fik ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `Forventede en af [${values.join(', ')}], fik ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'Forventede undefined',
+    neverType: 'Never-type kan ikke parses',
+    // New advanced type validation messages
+    invalidBigint: 'Ugyldig bigint',
+    invalidSymbol: 'Ugyldigt symbol',
+    invalidTuple: 'Ugyldig tupel',
+    tupleLength: (expected, received) => `Tupel skal have præcis ${expected} elementer, fik ${received}`,
+    invalidRecord: 'Ugyldig post',
+    invalidSet: 'Ugyldigt Set',
+    invalidMap: 'Ugyldig Map',
+    // Transformation and refinement messages
+    transformError: (error) => `Transformation fejlede: ${error}`,
+    refinementError: (error) => `Forfinelse fejlede: ${error}`,
+    customValidationError: (error) => `Brugerdefineret validering mislykkedes: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `Kan ikke konvertere ${JSON.stringify(value)} til ${type}`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `Forventede ${expected}, fik ${received}`,
+    stringBoolExpected: (validValues, received) => `Ugyldig boolean streng. En af følgende forventet: ${validValues}, fik: "${received}"`,
+    invalidJson: 'Ugyldig JSON',
+    stringPatternInvalid: 'Streng matcher ikke det krævede mønster',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
+    // Function validation messages
+    invalidFunction: 'En funktion forventes',
+    // CIDR validation messages
+    stringCidrv4: 'Ugyldig IPv4 CIDR-blok',
+    stringCidrv6: 'Ugyldig IPv6 CIDR-blok',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `Kan ikke overskrive eksisterende nøgler: ${keys.join(', ')}. Brug extend() for at overskrive.`
+};
+
+exports.da = da;

package/dist/cjs/locales/de.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const de = {
+    // String validation messages
+    invalidString: 'Ungültiger String',
+    stringMin: (min) => `String muss mindestens ${min} Zeichen lang sein`,
+    stringMax: (max) => `String darf höchstens ${max} Zeichen lang sein`,
+    stringLength: (length) => `String muss genau ${length} Zeichen lang sein`,
+    stringEmail: 'Ungültige E-Mail-Adresse',
+    stringUrl: 'Ungültige URL',
+    stringUuid: 'Ungültige UUID',
+    stringRegex: 'Ungültiges Format',
+    stringStartsWith: (prefix) => `String muss mit "${prefix}" beginnen`,
+    stringEndsWith: (suffix) => `String muss mit "${suffix}" enden`,
+    stringIncludes: (substring) => `String muss "${substring}" enthalten`,
+    stringIp: 'Ungültige IP-Adresse',
+    stringIpv4: 'Ungültige IPv4-Adresse',
+    stringIpv6: 'Ungültige IPv6-Adresse',
+    stringEmpty: 'String darf nicht leer sein',
+    // Number validation messages
+    invalidNumber: 'Ungültige Nummer',
+    numberMin: (min) => `Nummer muss mindestens ${min} betragen`,
+    numberMax: (max) => `Nummer darf höchstens ${max} betragen`,
+    numberInt: 'Nummer muss eine ganze Zahl sein',
+    numberPositive: 'Nummer muss positiv sein',
+    numberNegative: 'Nummer muss negativ sein',
+    numberNonnegative: 'Nummer darf nicht negativ sein',
+    numberNonpositive: 'Nummer darf nicht positiv sein',
+    numberFinite: 'Nummer muss endlich sein',
+    numberSafe: 'Nummer muss eine sichere ganze Zahl sein',
+    numberMultipleOf: (value) => `Nummer muss ein Vielfaches von ${value} sein`,
+    // Boolean validation messages
+    invalidBoolean: 'Ungültiger Boolean-Wert',
+    // Date validation messages
+    invalidDate: 'Ungültiges Datum',
+    dateMin: (date) => `Datum muss nach ${date.toISOString()} liegen`,
+    dateMax: (date) => `Datum muss vor ${date.toISOString()} liegen`,
+    // Object validation messages
+    invalidObject: 'Ungültiges Objekt',
+    unexpectedKeys: (keys) => `Unerwartete Schlüssel: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'Ungültiges Array',
+    arrayMin: (min) => `Array muss mindestens ${min} Elemente haben`,
+    arrayMax: (max) => `Array darf höchstens ${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}`,
+    // Object field validation
+    objectField: (field, error) => `Ungültiges Feld "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `Kein Union-Mitglied passte: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `Intersection-Validierung fehlgeschlagen: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `Erwartet ${expected}, erhalten ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `Erwartet einer von [${values.join(', ')}], erhalten ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'Undefined erwartet',
+    neverType: 'Never-Typ kann nicht geparst werden',
+    // New advanced type validation messages
+    invalidBigint: 'Ungültiger Bigint',
+    invalidSymbol: 'Ungültiges Symbol',
+    invalidTuple: 'Ungültiges Tupel',
+    tupleLength: (expected, received) => `Tupel muss genau ${expected} Elemente haben, ${received} erhalten`,
+    invalidRecord: 'Ungültiger Datensatz',
+    invalidSet: 'Ungültiges Set',
+    invalidMap: 'Ungültige Map',
+    // Transformation and refinement messages
+    transformError: (error) => `Transformation fehlgeschlagen: ${error}`,
+    refinementError: (error) => `Verfeinerung fehlgeschlagen: ${error}`,
+    customValidationError: (error) => `Benutzerdefinierte Validierung fehlgeschlagen: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `Kann ${JSON.stringify(value)} nicht zu ${type} konvertieren`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `${expected} erwartet, ${received} erhalten`,
+    stringBoolExpected: (validValues, received) => `Ungültige Boolean-Zeichenkette. Eines von erwartet: ${validValues}, erhalten: "${received}"`,
+    invalidJson: 'Ungültiges JSON',
+    stringPatternInvalid: 'Zeichenfolge entspricht nicht dem erforderlichen Muster',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
+    // Function validation messages
+    invalidFunction: 'Eine Funktion erwartet',
+    // CIDR validation messages
+    stringCidrv4: 'Ungültiger IPv4 CIDR-Block',
+    stringCidrv6: 'Ungültiger IPv6 CIDR-Block',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `Bestehende Schlüssel können nicht überschrieben werden: ${keys.join(', ')}. Verwenden Sie extend() zum Überschreiben.`
+};
+
+exports.de = de;

package/dist/cjs/locales/en.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const en = {
+    // String validation messages
+    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: (prefix) => `String must start with "${prefix}"`,
+    stringEndsWith: (suffix) => `String must end with "${suffix}"`,
+    stringIncludes: (substring) => `String must include "${substring}"`,
+    stringIp: 'Invalid IP address',
+    stringIpv4: 'Invalid IPv4 address',
+    stringIpv6: 'Invalid IPv6 address',
+    stringEmpty: 'String must not be empty',
+    // Number validation messages
+    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: (value) => `Number must be a multiple of ${value}`,
+    // Boolean validation messages
+    invalidBoolean: 'Invalid boolean',
+    // Date validation messages
+    invalidDate: 'Invalid date',
+    dateMin: (date) => `Date must be after ${date.toISOString()}`,
+    dateMax: (date) => `Date must be before ${date.toISOString()}`,
+    // Object validation messages
+    invalidObject: 'Invalid object',
+    unexpectedKeys: (keys) => `Unexpected keys: ${keys.join(', ')}`,
+    // Array validation messages
+    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}`,
+    // Object field validation
+    objectField: (field, error) => `Invalid field "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `No union member matched: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `Intersection validation failed: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `Expected ${expected}, got ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `Expected one of [${values.join(', ')}], got ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'Expected undefined',
+    neverType: 'Never type cannot be parsed',
+    // New advanced type validation messages
+    invalidBigint: 'Invalid bigint',
+    invalidSymbol: 'Invalid symbol',
+    invalidTuple: 'Invalid tuple',
+    tupleLength: (expected, received) => `Tuple must have exactly ${expected} elements, got ${received}`,
+    invalidRecord: 'Invalid record',
+    invalidSet: 'Invalid set',
+    invalidMap: 'Invalid map',
+    // Transformation and refinement messages
+    transformError: (error) => `Transform failed: ${error}`,
+    refinementError: (error) => `Refinement failed: ${error}`,
+    customValidationError: (error) => `Custom validation failed: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `Cannot coerce ${JSON.stringify(value)} to ${type}`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `Expected ${expected}, got ${received}`,
+    stringBoolExpected: (validValues, received) => `Invalid boolean string. Expected one of: ${validValues}, got "${received}"`,
+    invalidJson: 'Invalid JSON',
+    stringPatternInvalid: 'String does not match the required pattern',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(', ')}`,
+    // Function validation messages
+    invalidFunction: 'Expected a function',
+    // CIDR validation messages
+    stringCidrv4: 'Invalid IPv4 CIDR block',
+    stringCidrv6: 'Invalid IPv6 CIDR block',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `Cannot override existing keys: ${keys.join(', ')}. Use extend() if you want to override.`
+};
+
+exports.en = en;

package/dist/cjs/locales/es-MX.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const esMX = {
+    // String validation messages
+    invalidString: 'Cadena inválida',
+    stringMin: (min) => `La cadena debe tener al menos ${min} caracteres`,
+    stringMax: (max) => `La cadena no puede tener más de ${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: (prefix) => `La cadena debe empezar con "${prefix}"`,
+    stringEndsWith: (suffix) => `La cadena debe terminar con "${suffix}"`,
+    stringIncludes: (substring) => `La cadena debe incluir "${substring}"`,
+    stringIp: 'Dirección IP inválida',
+    stringIpv4: 'Dirección IPv4 inválida',
+    stringIpv6: 'Dirección IPv6 inválida',
+    stringEmpty: 'La cadena no puede estar vacía',
+    // Number validation messages
+    invalidNumber: 'Número inválido',
+    numberMin: (min) => `El número debe ser al menos ${min}`,
+    numberMax: (max) => `El número no puede ser mayor a ${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 no puede ser negativo',
+    numberNonpositive: 'El número no puede ser positivo',
+    numberFinite: 'El número debe ser finito',
+    numberSafe: 'El número debe ser un entero seguro',
+    numberMultipleOf: (value) => `El número debe ser múltiplo de ${value}`,
+    // Boolean validation messages
+    invalidBoolean: 'Valor booleano inválido',
+    // Date validation messages
+    invalidDate: 'Fecha inválida',
+    dateMin: (date) => `La fecha debe ser después de ${date.toISOString()}`,
+    dateMax: (date) => `La fecha debe ser antes de ${date.toISOString()}`,
+    // Object validation messages
+    invalidObject: 'Objeto inválido',
+    unexpectedKeys: (keys) => `Claves inesperadas: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'Array inválido',
+    arrayMin: (min) => `El array debe tener al menos ${min} elementos`,
+    arrayMax: (max) => `El array no puede tener más de ${max} elementos`,
+    arrayLength: (length) => `El array debe tener exactamente ${length} elementos`,
+    arrayEmpty: 'El array no puede estar vacío',
+    arrayItem: (index, error) => `Elemento inválido en índice ${index}: ${error}`,
+    // Object field validation
+    objectField: (field, error) => `Campo inválido "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `Ningún miembro de la unión coincidió: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `Error de validación de intersección: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `Se esperaba ${expected}, se recibió ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `Se esperaba uno de [${values.join(', ')}], se recibió ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'Se esperaba undefined',
+    neverType: 'El tipo never no se puede analizar',
+    // New advanced type validation messages
+    invalidBigint: 'Bigint inválido',
+    invalidSymbol: 'Símbolo inválido',
+    invalidTuple: 'Tupla inválida',
+    tupleLength: (expected, received) => `La tupla debe tener exactamente ${expected} elementos, se recibieron ${received}`,
+    invalidRecord: 'Registro inválido',
+    invalidSet: 'Set inválido',
+    invalidMap: 'Map inválido',
+    // Transformation and refinement messages
+    transformError: (error) => `Transformación falló: ${error}`,
+    refinementError: (error) => `Refinamiento falló: ${error}`,
+    customValidationError: (error) => `Validación personalizada falló: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `No se puede coaccionar ${JSON.stringify(value)} a ${type}`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `Se esperaba ${expected}, se recibió ${received}`,
+    stringBoolExpected: (validValues, received) => `Cadena booleana no válida. Se esperaba uno de: ${validValues}, se recibió: "${received}"`,
+    invalidJson: 'JSON no válido',
+    stringPatternInvalid: 'La cadena no coincide con el patrón requerido',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(', ')}`,
+    invalidFunction: 'Se esperaba una función',
+    // CIDR validation messages
+    stringCidrv4: 'Bloque CIDR IPv4 inválido',
+    stringCidrv6: 'Bloque CIDR IPv6 inválido',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `No se pueden sobrescribir las claves existentes: ${keys.join(', ')}. Use extend() si desea sobrescribir.`
+};
+
+exports.esMX = esMX;

package/dist/cjs/locales/es.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+const 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: (prefix) => `La cadena debe comenzar con "${prefix}"`,
+    stringEndsWith: (suffix) => `La cadena debe terminar con "${suffix}"`,
+    stringIncludes: (substring) => `La cadena debe incluir "${substring}"`,
+    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 un 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: (value) => `El número debe ser múltiplo de ${value}`,
+    invalidBoolean: 'Boolean 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(', ')}`,
+    intersectionError: (error) => `Error de validación de intersección: ${error}`,
+    literalExpected: (expected, received) => `Se esperaba ${expected}, se recibió ${received}`,
+    enumExpected: (values, received) => `Se esperaba uno de [${values.join(', ')}], se recibió ${received}`,
+    expectedUndefined: 'Se esperaba undefined',
+    neverType: 'El tipo never no puede ser parseado',
+    // New advanced type validation messages
+    invalidBigint: 'Bigint inválido',
+    invalidSymbol: 'Símbolo inválido',
+    invalidTuple: 'Tupla inválida',
+    tupleLength: (expected, received) => `La tupla debe tener exactamente ${expected} elementos, se recibieron ${received}`,
+    invalidRecord: 'Registro inválido',
+    invalidSet: 'Set inválido',
+    invalidMap: 'Map inválido',
+    // Transformation and refinement messages
+    transformError: (error) => `Transformación fallida: ${error}`,
+    refinementError: (error) => `Refinamiento fallido: ${error}`,
+    customValidationError: (error) => `Validación personalizada falló: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `No se puede coaccionar ${JSON.stringify(value)} a ${type}`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `Se esperaba ${expected}, se obtuvo ${received}`,
+    stringBoolExpected: (validValues, received) => `Cadena booleana no válida. Se esperaba uno de: ${validValues}, se obtuvo "${received}"`,
+    invalidJson: 'JSON no válido',
+    stringPatternInvalid: 'La cadena no coincide con el patrón requerido',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
+    // Function validation messages
+    invalidFunction: 'Se esperaba una función',
+    // CIDR validation messages
+    stringCidrv4: 'Bloque CIDR IPv4 inválido',
+    stringCidrv6: 'Bloque CIDR IPv6 inválido',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `No se pueden sobrescribir las claves existentes: ${keys.join(', ')}. Use extend() si desea sobrescribir.`
+};
+
+exports.es = es;