@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/locales/fi.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const fi = {
+    // String validation messages
+    invalidString: 'Virheellinen merkkijono',
+    stringMin: (min) => `Merkkijonon tulee olla vähintään ${min} merkkiä pitkä`,
+    stringMax: (max) => `Merkkijono saa olla enintään ${max} merkkiä pitkä`,
+    stringLength: (length) => `Merkkijonon tulee olla täsmälleen ${length} merkkiä pitkä`,
+    stringEmail: 'Virheellinen sähköpostiosoite',
+    stringUrl: 'Virheellinen URL',
+    stringUuid: 'Virheellinen UUID',
+    stringRegex: 'Virheellinen muoto',
+    stringStartsWith: (prefix) => `Merkkijonon tulee alkaa merkeillä "${prefix}"`,
+    stringEndsWith: (suffix) => `Merkkijonon tulee päättyä merkkeihin "${suffix}"`,
+    stringIncludes: (substring) => `Merkkijonon tulee sisältää "${substring}"`,
+    stringIp: 'Virheellinen IP-osoite',
+    stringIpv4: 'Virheellinen IPv4-osoite',
+    stringIpv6: 'Virheellinen IPv6-osoite',
+    stringEmpty: 'Merkkijono ei saa olla tyhjä',
+    // Number validation messages
+    invalidNumber: 'Virheellinen luku',
+    numberMin: (min) => `Luvun tulee olla vähintään ${min}`,
+    numberMax: (max) => `Luku saa olla enintään ${max}`,
+    numberInt: 'Luvun tulee olla kokonaisluku',
+    numberPositive: 'Luvun tulee olla positiivinen',
+    numberNegative: 'Luvun tulee olla negatiivinen',
+    numberNonnegative: 'Luku ei saa olla negatiivinen',
+    numberNonpositive: 'Luku ei saa olla positiivinen',
+    numberFinite: 'Luvun tulee olla äärellinen',
+    numberSafe: 'Luvun tulee olla turvallinen kokonaisluku',
+    numberMultipleOf: (value) => `Luvun tulee olla ${value}:n kerrannainen`,
+    // Boolean validation messages
+    invalidBoolean: 'Virheellinen totuusarvo',
+    // Date validation messages
+    invalidDate: 'Virheellinen päivämäärä',
+    dateMin: (date) => `Päivämäärän tulee olla ${date.toISOString()} jälkeen`,
+    dateMax: (date) => `Päivämäärän tulee olla ennen ${date.toISOString()}`,
+    // Object validation messages
+    invalidObject: 'Virheellinen objekti',
+    unexpectedKeys: (keys) => `Odottamattomat avaimet: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'Virheellinen taulukko',
+    arrayMin: (min) => `Taulukossa tulee olla vähintään ${min} alkiota`,
+    arrayMax: (max) => `Taulukossa saa olla enintään ${max} alkiota`,
+    arrayLength: (length) => `Taulukossa tulee olla täsmälleen ${length} alkiota`,
+    arrayEmpty: 'Taulukko ei saa olla tyhjä',
+    arrayItem: (index, error) => `Virheellinen alkio indeksissä ${index}: ${error}`,
+    // Object field validation
+    objectField: (field, error) => `Virheellinen kenttä "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `Mikään union-jäsen ei täsmännyt: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `Intersection validointi epäonnistui: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `Odotettiin ${expected}, saatiin ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `Odotettiin yhtä arvoista [${values.join(', ')}], saatiin ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'Odotettiin undefined',
+    neverType: 'Never-tyyppiä ei voida jäsentää',
+    // New advanced type validation messages
+    invalidBigint: 'Virheellinen bigint',
+    invalidSymbol: 'Virheellinen symboli',
+    invalidTuple: 'Virheellinen monikko',
+    tupleLength: (expected, received) => `Monikossa tulee olla täsmälleen ${expected} alkiota, saatiin ${received}`,
+    invalidRecord: 'Virheellinen tietue',
+    invalidSet: 'Virheellinen Set',
+    invalidMap: 'Virheellinen Map',
+    // Transformation and refinement messages
+    transformError: (error) => `Muunnos epäonnistui: ${error}`,
+    refinementError: (error) => `Hiominen epäonnistui: ${error}`,
+    customValidationError: (error) => `Mukautettu validointi epäonnistui: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `Arvoa ${JSON.stringify(value)} ei voida pakottaa tyyppiin ${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) => `Odotettiin ${expected}, saatiin ${received}`,
+    stringBoolExpected: (validValues, received) => `Virheellinen boolean-merkkijono. Yksi seuraavista odotettu: ${validValues}, saatiin: "${received}"`,
+    invalidJson: 'Virheellinen JSON',
+    stringPatternInvalid: 'Merkkijono ei vastaa vaadittua kuviota',
+    // 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: 'Funktiota odotetaan',
+    // CIDR validation messages
+    stringCidrv4: 'Virheellinen IPv4 CIDR-lohko',
+    stringCidrv6: 'Virheellinen IPv6 CIDR-lohko',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `Olemassa olevia avaimia ei voi ylikirjoittaa: ${keys.join(', ')}. Käytä extend() ylikirjoittamiseen.`
+};
+
+exports.fi = fi;

package/dist/cjs/locales/fr.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+const 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 maximum ${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: (prefix) => `La chaîne doit commencer par "${prefix}"`,
+    stringEndsWith: (suffix) => `La chaîne doit se terminer par "${suffix}"`,
+    stringIncludes: (substring) => `La chaîne doit contenir "${substring}"`,
+    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 d'au moins ${min}`,
+    numberMax: (max) => `Le nombre doit être d'au maximum ${max}`,
+    numberInt: 'Le nombre doit être un entier',
+    numberPositive: 'Le nombre doit être positif',
+    numberNegative: 'Le nombre doit être négatif',
+    numberNonnegative: 'Le nombre ne doit pas être négatif',
+    numberNonpositive: 'Le nombre ne doit pas être positif',
+    numberFinite: 'Le nombre doit être fini',
+    numberSafe: 'Le nombre doit être un entier sûr',
+    numberMultipleOf: (value) => `Le nombre doit être un multiple de ${value}`,
+    invalidBoolean: 'Boolean invalide',
+    invalidDate: 'Date invalide',
+    dateMin: (date) => `La date doit être postérieure à ${date.toISOString()}`,
+    dateMax: (date) => `La date doit être antérieure à ${date.toISOString()}`,
+    invalidObject: 'Objet invalide',
+    unexpectedKeys: (keys) => `Clés inattendues: ${keys.join(', ')}`,
+    invalidArray: 'Tableau invalide',
+    arrayMin: (min) => `Le tableau doit contenir au moins ${min} éléments`,
+    arrayMax: (max) => `Le tableau doit contenir au maximum ${max} éléments`,
+    arrayLength: (length) => `Le tableau doit contenir 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 n'a correspondu: ${errors.join(', ')}`,
+    intersectionError: (error) => `Échec de validation d'intersection: ${error}`,
+    literalExpected: (expected, received) => `Attendu ${expected}, reçu ${received}`,
+    enumExpected: (values, received) => `Attendu un de [${values.join(', ')}], reçu ${received}`,
+    expectedUndefined: 'Undefined attendu',
+    neverType: 'Le type never ne peut pas être analysé',
+    // New advanced type validation messages
+    invalidBigint: 'Bigint invalide',
+    invalidSymbol: 'Symbole invalide',
+    invalidTuple: 'Tuple invalide',
+    tupleLength: (expected, received) => `Le tuple doit contenir exactement ${expected} éléments, ${received} reçus`,
+    invalidRecord: 'Enregistrement invalide',
+    invalidSet: 'Set invalide',
+    invalidMap: 'Map invalide',
+    // Transformation and refinement messages
+    transformError: (error) => `Transformation échouée : ${error}`,
+    refinementError: (error) => `Raffinement échoué : ${error}`,
+    customValidationError: (error) => `Validation personnalisée échouée : ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `Impossible de convertir ${JSON.stringify(value)} en ${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) => `Attendu: ${expected}, reçu: ${received}`,
+    stringBoolExpected: (validValues, received) => `Chaîne booléenne invalide. Attendu: l'un de ${validValues}, reçu: "${received}"`,
+    invalidJson: 'JSON invalide',
+    stringPatternInvalid: 'La chaîne ne correspond pas au modèle requis',
+    // 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: 'Une fonction est attendue',
+    // CIDR validation messages
+    stringCidrv4: 'Bloc CIDR IPv4 invalide',
+    stringCidrv6: 'Bloc CIDR IPv6 invalide',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `Impossible de remplacer les clés existantes: ${keys.join(', ')}. Utilisez extend() pour remplacer.`
+};
+
+exports.fr = fr;

package/dist/cjs/locales/hi.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const hi = {
+    // 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.hi = hi;

package/dist/cjs/locales/id.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const id = {
+    // String validation messages
+    invalidString: 'String tidak valid',
+    stringMin: (min) => `String harus memiliki minimal ${min} karakter`,
+    stringMax: (max) => `String tidak boleh lebih dari ${max} karakter`,
+    stringLength: (length) => `String harus memiliki tepat ${length} karakter`,
+    stringEmail: 'Alamat email tidak valid',
+    stringUrl: 'URL tidak valid',
+    stringUuid: 'UUID tidak valid',
+    stringRegex: 'Format tidak valid',
+    stringStartsWith: (prefix) => `String harus diawali dengan "${prefix}"`,
+    stringEndsWith: (suffix) => `String harus diakhiri dengan "${suffix}"`,
+    stringIncludes: (substring) => `String harus mengandung "${substring}"`,
+    stringIp: 'Alamat IP tidak valid',
+    stringIpv4: 'Alamat IPv4 tidak valid',
+    stringIpv6: 'Alamat IPv6 tidak valid',
+    stringEmpty: 'String tidak boleh kosong',
+    // Number validation messages
+    invalidNumber: 'Angka tidak valid',
+    numberMin: (min) => `Angka harus minimal ${min}`,
+    numberMax: (max) => `Angka tidak boleh lebih dari ${max}`,
+    numberInt: 'Angka harus berupa bilangan bulat',
+    numberPositive: 'Angka harus positif',
+    numberNegative: 'Angka harus negatif',
+    numberNonnegative: 'Angka tidak boleh negatif',
+    numberNonpositive: 'Angka tidak boleh positif',
+    numberFinite: 'Angka harus terhingga',
+    numberSafe: 'Angka harus berupa bilangan bulat yang aman',
+    numberMultipleOf: (value) => `Angka harus kelipatan dari ${value}`,
+    // Boolean validation messages
+    invalidBoolean: 'Nilai boolean tidak valid',
+    // Date validation messages
+    invalidDate: 'Tanggal tidak valid',
+    dateMin: (date) => `Tanggal harus setelah ${date.toISOString()}`,
+    dateMax: (date) => `Tanggal harus sebelum ${date.toISOString()}`,
+    // Object validation messages
+    invalidObject: 'Object tidak valid',
+    unexpectedKeys: (keys) => `Kunci yang tidak diharapkan: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'Array tidak valid',
+    arrayMin: (min) => `Array harus memiliki minimal ${min} elemen`,
+    arrayMax: (max) => `Array tidak boleh lebih dari ${max} elemen`,
+    arrayLength: (length) => `Array harus memiliki tepat ${length} elemen`,
+    arrayEmpty: 'Array tidak boleh kosong',
+    arrayItem: (index, error) => `Elemen tidak valid pada indeks ${index}: ${error}`,
+    // Object field validation
+    objectField: (field, error) => `Field "${field}" tidak valid: ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `Tidak ada anggota union yang cocok: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `Validasi intersection gagal: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `Diharapkan ${expected}, diterima ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `Diharapkan salah satu dari [${values.join(', ')}], diterima ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'Diharapkan undefined',
+    neverType: 'Tipe never tidak dapat diparse',
+    // New advanced type validation messages
+    invalidBigint: 'Bigint tidak valid',
+    invalidSymbol: 'Simbol tidak valid',
+    invalidTuple: 'Tuple tidak valid',
+    tupleLength: (expected, received) => `Tuple harus memiliki tepat ${expected} elemen, diterima ${received}`,
+    invalidRecord: 'Record tidak valid',
+    invalidSet: 'Set tidak valid',
+    invalidMap: 'Map tidak valid',
+    // Transformation and refinement messages
+    transformError: (error) => `Transformasi gagal: ${error}`,
+    refinementError: (error) => `Penyempurnaan gagal: ${error}`,
+    customValidationError: (error) => `Validasi kustom gagal: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `Tidak dapat memaksa ${JSON.stringify(value)} menjadi ${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) => `Diharapkan ${expected}, diterima ${received}`,
+    stringBoolExpected: (validValues, received) => `String boolean tidak valid. Salah satu dari berikut diharapkan: ${validValues}, diterima: "${received}"`,
+    invalidJson: 'JSON tidak valid',
+    stringPatternInvalid: 'String tidak cocok dengan pola yang diperlukan',
+    // 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: 'Fungsi diharapkan',
+    // CIDR validation messages
+    stringCidrv4: 'Blok CIDR IPv4 tidak valid',
+    stringCidrv6: 'Blok CIDR IPv6 tidak valid',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `Tidak dapat menimpa kunci yang sudah ada: ${keys.join(', ')}. Gunakan extend() untuk menimpa.`
+};
+
+exports.id = id;