typebox 1.0.31 → 1.0.33

package/build/cjs/system/hashing/hash.js

@@ -0,0 +1,236 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashCode = HashCode;
+exports.Hash = Hash;
+const index_1 = require("../unreachable/index");
+const index_2 = require("../../guard/index");
+// ------------------------------------------------------------------
+// InstanceKeys
+//
+// Retrieves all enumerable and non-enumerable own property keys 
+// and inherited prototype keys (excluding symbols and the 'constructor') 
+// from an object instance.
+//
+// This function is useful for differentiating between class instances 
+// based on their structural keys rather than relying on the 
+// constructor name. It provides a more reliable structural comparison 
+// by capturing both own and prototype properties.
+//
+// ------------------------------------------------------------------
+function InstanceKeys(value) {
+    const propertyKeys = new Set();
+    let current = value;
+    while (current && current !== Object.prototype) {
+        for (const key of Reflect.ownKeys(current)) {
+            if (key !== 'constructor' && typeof key !== 'symbol')
+                propertyKeys.add(key);
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return [...propertyKeys];
+}
+// ------------------------------------------------------------------
+// IsIEEE754
+//
+// TypeBox guards do not consider +/- Infinity or NaN as valid
+// numbers, but they are valid IEEE754 numbers. We use a special
+// guard to ensure these numbers are considered for hashing.
+//
+// ------------------------------------------------------------------
+function IsIEEE754(value) {
+    return typeof value === 'number';
+}
+// ------------------------------------------------------------------
+// ByteMarker
+// ------------------------------------------------------------------
+var ByteMarker;
+(function (ByteMarker) {
+    ByteMarker[ByteMarker["Array"] = 0] = "Array";
+    ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
+    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+    ByteMarker[ByteMarker["Date"] = 3] = "Date";
+    ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
+    ByteMarker[ByteMarker["Function"] = 5] = "Function";
+    ByteMarker[ByteMarker["Null"] = 6] = "Null";
+    ByteMarker[ByteMarker["Number"] = 7] = "Number";
+    ByteMarker[ByteMarker["Object"] = 8] = "Object";
+    ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
+    ByteMarker[ByteMarker["String"] = 10] = "String";
+    ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
+    ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
+    ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
+// ------------------------------------------------------------------
+// State
+// ------------------------------------------------------------------
+let Accumulator = BigInt('14695981039346656037');
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+const F64In = new DataView(F64.buffer);
+const F64Out = new Uint8Array(F64.buffer);
+// ------------------------------------------------------------------
+// Operation
+// ------------------------------------------------------------------
+function FNV1A64_OP(byte) {
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    FNV1A64_OP(ByteMarker.Array);
+    for (const item of value) {
+        FromValue(item);
+    }
+}
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    FNV1A64_OP(ByteMarker.BigInt);
+    F64In.setBigInt64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    FNV1A64_OP(ByteMarker.Boolean);
+    FNV1A64_OP(value ? 1 : 0);
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+function FromConstructor(value) {
+    FNV1A64_OP(ByteMarker.Constructor);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+function FromDate(value) {
+    FNV1A64_OP(ByteMarker.Date);
+    FromValue(value.getTime());
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+function FromFunction(value) {
+    FNV1A64_OP(ByteMarker.Function);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(_value) {
+    FNV1A64_OP(ByteMarker.Null);
+}
+// ------------------------------------------------------------------
+// Number | IEEE754
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    FNV1A64_OP(ByteMarker.Number);
+    F64In.setFloat64(0, value, true /* little-endian */);
+    for (const byte of F64Out) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    FNV1A64_OP(ByteMarker.Object);
+    for (const key of InstanceKeys(value).sort()) {
+        FromValue(key);
+        FromValue(value[key]);
+    }
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+function FromRegExp(value) {
+    FNV1A64_OP(ByteMarker.RegExp);
+    FromString(value.toString());
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+const encoder = new TextEncoder();
+function FromString(value) {
+    FNV1A64_OP(ByteMarker.String);
+    for (const byte of encoder.encode(value)) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+function FromSymbol(value) {
+    FNV1A64_OP(ByteMarker.Symbol);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypeArray(value) {
+    FNV1A64_OP(ByteMarker.TypeArray);
+    const buffer = new Uint8Array(value.buffer);
+    for (let i = 0; i < buffer.length; i++) {
+        FNV1A64_OP(buffer[i]);
+    }
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(_value) {
+    return FNV1A64_OP(ByteMarker.Undefined);
+}
+// ------------------------------------------------------------------
+// Hash
+//
+// deno-coverage-ignore-start - unreachable
+//
+// This function should all JavaScript values so we can't reach the
+// fall-through. We use Unreachable to assert that no values pass
+// through. We will need to handle these should they arise.
+//
+// ------------------------------------------------------------------
+function FromValue(value) {
+    return (index_2.GlobalsGuard.IsTypeArray(value) ? FromTypeArray(value) :
+        index_2.GlobalsGuard.IsDate(value) ? FromDate(value) :
+            index_2.GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+                index_2.GlobalsGuard.IsBoolean(value) ? FromBoolean(value.valueOf()) :
+                    index_2.GlobalsGuard.IsString(value) ? FromString(value.valueOf()) :
+                        index_2.GlobalsGuard.IsNumber(value) ? FromNumber(value.valueOf()) :
+                            IsIEEE754(value) ? FromNumber(value) :
+                                index_2.Guard.IsArray(value) ? FromArray(value) :
+                                    index_2.Guard.IsBoolean(value) ? FromBoolean(value) :
+                                        index_2.Guard.IsBigInt(value) ? FromBigInt(value) :
+                                            index_2.Guard.IsConstructor(value) ? FromConstructor(value) :
+                                                index_2.Guard.IsNull(value) ? FromNull(value) :
+                                                    index_2.Guard.IsObject(value) ? FromObject(value) :
+                                                        index_2.Guard.IsString(value) ? FromString(value) :
+                                                            index_2.Guard.IsSymbol(value) ? FromSymbol(value) :
+                                                                index_2.Guard.IsUndefined(value) ? FromUndefined(value) :
+                                                                    index_2.Guard.IsFunction(value) ? FromFunction(value) :
+                                                                        (0, index_1.Unreachable)());
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Hash
+// ------------------------------------------------------------------
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+function HashCode(value) {
+    Accumulator = BigInt('14695981039346656037');
+    FromValue(value);
+    return Accumulator;
+}
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+function Hash(value) {
+    return HashCode(value).toString(16).padStart(16, '0');
+}

package/build/cjs/system/hashing/index.d.ts

@@ -0,0 +1 @@
+export * as Hashing from './hash';

package/build/cjs/system/hashing/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hashing = void 0;
+exports.Hashing = require("./hash");

package/build/cjs/system/index.d.ts

@@ -0,0 +1,4 @@
+export * from './system';
+export * as System from './system';
+import * as System from './system';
+export default System;

package/build/cjs/system/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.System = void 0;
+__exportStar(require("./system"), exports);
+exports.System = require("./system");
+const System = require("./system");
+exports.default = System;

package/build/cjs/system/locale/_config.d.ts

@@ -0,0 +1,7 @@
+import { TLocalizedValidationMessageCallback } from '../../error/index';
+/** Sets the locale */
+export declare function Set(callback: TLocalizedValidationMessageCallback): void;
+/** Gets the locale */
+export declare function Get(): TLocalizedValidationMessageCallback;
+/** Resets the locale to `en_US` */
+export declare function Reset(): void;

package/build/cjs/system/locale/_config.js

@@ -0,0 +1,20 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Set = Set;
+exports.Get = Get;
+exports.Reset = Reset;
+const en_US_1 = require("./en_US");
+let locale = en_US_1.en_US;
+/** Sets the locale */
+function Set(callback) {
+    locale = callback;
+}
+/** Gets the locale */
+function Get() {
+    return locale;
+}
+/** Resets the locale to `en_US` */
+function Reset() {
+    Set(en_US_1.en_US);
+}

package/build/cjs/system/locale/_locale.d.ts

@@ -0,0 +1,40 @@
+export * from './_config';
+export * from './ar_001';
+export * from './bn_BD';
+export * from './cs_CZ';
+export * from './de_DE';
+export * from './el_GR';
+export * from './en_US';
+export * from './es_419';
+export * from './es_AR';
+export * from './es_ES';
+export * from './es_MX';
+export * from './fa_IR';
+export * from './fil_PH';
+export * from './fr_CA';
+export * from './fr_CA';
+export * from './fr_FR';
+export * from './ha_NG';
+export * from './hi_IN';
+export * from './hu_HU';
+export * from './id_ID';
+export * from './it_IT';
+export * from './ja_JP';
+export * from './ko_KR';
+export * from './ms_MY';
+export * from './nl_NL';
+export * from './pl_PL';
+export * from './pt_BR';
+export * from './pt_PT';
+export * from './ro_RO';
+export * from './ru_RU';
+export * from './sv_SE';
+export * from './sw_TZ';
+export * from './th_TH';
+export * from './tr_TR';
+export * from './uk_UA';
+export * from './ur_PK';
+export * from './vi_VN';
+export * from './yo_NG';
+export * from './zh_Hans';
+export * from './zh_Hant';

package/build/cjs/system/locale/_locale.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./_config"), exports);
+__exportStar(require("./ar_001"), exports);
+__exportStar(require("./bn_BD"), exports);
+__exportStar(require("./cs_CZ"), exports);
+__exportStar(require("./de_DE"), exports);
+__exportStar(require("./el_GR"), exports);
+__exportStar(require("./en_US"), exports);
+__exportStar(require("./es_419"), exports);
+__exportStar(require("./es_AR"), exports);
+__exportStar(require("./es_ES"), exports);
+__exportStar(require("./es_MX"), exports);
+__exportStar(require("./fa_IR"), exports);
+__exportStar(require("./fil_PH"), exports);
+__exportStar(require("./fr_CA"), exports);
+__exportStar(require("./fr_CA"), exports);
+__exportStar(require("./fr_FR"), exports);
+__exportStar(require("./ha_NG"), exports);
+__exportStar(require("./hi_IN"), exports);
+__exportStar(require("./hu_HU"), exports);
+__exportStar(require("./id_ID"), exports);
+__exportStar(require("./it_IT"), exports);
+__exportStar(require("./ja_JP"), exports);
+__exportStar(require("./ko_KR"), exports);
+__exportStar(require("./ms_MY"), exports);
+__exportStar(require("./nl_NL"), exports);
+__exportStar(require("./pl_PL"), exports);
+__exportStar(require("./pt_BR"), exports);
+__exportStar(require("./pt_PT"), exports);
+__exportStar(require("./ro_RO"), exports);
+__exportStar(require("./ru_RU"), exports);
+__exportStar(require("./sv_SE"), exports);
+__exportStar(require("./sw_TZ"), exports);
+__exportStar(require("./th_TH"), exports);
+__exportStar(require("./tr_TR"), exports);
+__exportStar(require("./uk_UA"), exports);
+__exportStar(require("./ur_PK"), exports);
+__exportStar(require("./vi_VN"), exports);
+__exportStar(require("./yo_NG"), exports);
+__exportStar(require("./zh_Hans"), exports);
+__exportStar(require("./zh_Hant"), exports);

package/build/cjs/system/locale/ar_001.d.ts

@@ -0,0 +1,3 @@
+import { TValidationError } from '../../error/index';
+/** Arabic (World) - ISO 639-1 language code 'ar' with UN M.49 region code '001' for World. */
+export declare function ar_001(error: TValidationError): string;

package/build/cjs/system/locale/ar_001.js

@@ -0,0 +1,44 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ar_001 = ar_001;
+/** Arabic (World) - ISO 639-1 language code 'ar' with UN M.49 region code '001' for World. */
+function ar_001(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'يجب ألا يحتوي على خصائص إضافية';
+        case 'anyOf': return 'يجب أن يتطابق مع مخطط في أيٍ مما يلي';
+        case 'boolean': return 'المخطط خاطئ';
+        case 'const': return 'يجب أن يكون مساويًا للثابت';
+        case 'contains': return 'يجب أن يحتوي على عنصر واحد صحيح على الأقل';
+        case 'dependencies': return `يجب أن يحتوي على الخصائص ${error.params.dependencies.join(', ')} عندما تكون الخاصية ${error.params.property} موجودة`;
+        case 'dependentRequired': return `يجب أن يحتوي على الخصائص ${error.params.dependencies.join(', ')} عندما تكون الخاصية ${error.params.property} موجودة`;
+        case 'enum': return 'يجب أن يكون مساويًا لإحدى القيم المسموح بها';
+        case 'exclusiveMaximum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `يجب أن يتطابق مع التنسيق "${error.params.format}"`;
+        case 'if': return `يجب أن يتطابق مع مخطط "${error.params.failingKeyword}"`;
+        case 'maxItems': return `يجب ألا يحتوي على أكثر من ${error.params.limit} عناصر`;
+        case 'maxLength': return `يجب ألا يحتوي على أكثر من ${error.params.limit} أحرف`;
+        case 'maxProperties': return `يجب ألا يحتوي على أكثر من ${error.params.limit} خصائص`;
+        case 'maximum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `يجب ألا يحتوي على أقل من ${error.params.limit} عناصر`;
+        case 'minLength': return `يجب ألا يحتوي على أقل من ${error.params.limit} أحرف`;
+        case 'minProperties': return `يجب ألا يحتوي على أقل من ${error.params.limit} خصائص`;
+        case 'minimum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `يجب أن يكون مضاعفًا لـ ${error.params.multipleOf}`;
+        case 'not': return 'يجب ألا يكون صالحًا';
+        case 'oneOf': return 'يجب أن يتطابق مع مخطط واحد بالضبط في واحد مما يلي';
+        case 'pattern': return `يجب أن يتطابق مع النمط "${error.params.pattern}"`;
+        case 'propertyNames': return `أسماء الخصائص ${error.params.propertyNames.join(', ')} غير صالحة`;
+        case 'required': return `يجب أن يحتوي على الخصائص المطلوبة ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `يجب أن يكون ${error.params.type}` : `يجب أن يكون إما ${error.params.type.join(' أو ')}`;
+        case 'unevaluatedItems': return 'يجب ألا يحتوي على عناصر غير مقيمة';
+        case 'unevaluatedProperties': return 'يجب ألا يحتوي على خصائص غير مقيمة';
+        case 'uniqueItems': return `يجب ألا يحتوي على عناصر مكررة`;
+        case '~guard': return `يجب أن يتطابق مع دالة الفحص`;
+        case '~refine': return error.params.message;
+        default: return 'حدث خطأ غير معروف في التحقق من الصحة';
+    }
+}
+// deno-coverage-ignore-stop

package/build/cjs/system/locale/bn_BD.d.ts

@@ -0,0 +1,3 @@
+import { TValidationError } from '../../error/index';
+/** Bengali (Bangladesh) - ISO 639-1 language code 'bn' with ISO 3166-1 alpha-2 country code 'BD' for Bangladesh. */
+export declare function bn_BD(error: TValidationError): string;

package/build/cjs/system/locale/bn_BD.js

@@ -0,0 +1,44 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bn_BD = bn_BD;
+/** Bengali (Bangladesh) - ISO 639-1 language code 'bn' with ISO 3166-1 alpha-2 country code 'BD' for Bangladesh. */
+function bn_BD(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'অতিরিক্ত বৈশিষ্ট্য থাকতে পারবে না';
+        case 'anyOf': return 'anyOf-এর একটি স্কিমার সাথে মিলতে হবে';
+        case 'boolean': return 'স্কিমা মিথ্যা';
+        case 'const': return 'ধ্রুবকের সমান হতে হবে';
+        case 'contains': return 'অন্তত 1টি বৈধ আইটেম থাকতে হবে';
+        case 'dependencies': return `যখন ${error.params.property} বৈশিষ্ট্য বিদ্যমান থাকে, তখন ${error.params.dependencies.join(', ')} বৈশিষ্ট্য থাকতে হবে`;
+        case 'dependentRequired': return `যখন ${error.params.property} বৈশিষ্ট্য বিদ্যমান থাকে, তখন ${error.params.dependencies.join(', ')} বৈশিষ্ট্য থাকতে হবে`;
+        case 'enum': return 'অনুমোদিত মানগুলির একটির সমান হতে হবে';
+        case 'exclusiveMaximum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'exclusiveMinimum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'format': return `অবশ্যই "${error.params.format}" ফরম্যাটের সাথে মিলতে হবে`;
+        case 'if': return `অবশ্যই "${error.params.failingKeyword}" স্কিমার সাথে মিলতে হবে`;
+        case 'maxItems': return `${error.params.limit}টির বেশি আইটেম থাকতে পারবে না`;
+        case 'maxLength': return `${error.params.limit}টির বেশি অক্ষর থাকতে পারবে না`;
+        case 'maxProperties': return `${error.params.limit}টির বেশি বৈশিষ্ট্য থাকতে পারবে না`;
+        case 'maximum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'minItems': return `${error.params.limit}টির কম আইটেম থাকতে পারবে না`;
+        case 'minLength': return `${error.params.limit}টির কম অক্ষর থাকতে পারবে না`;
+        case 'minProperties': return `${error.params.limit}টির কম বৈশিষ্ট্য থাকতে পারবে না`;
+        case 'minimum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'multipleOf': return `${error.params.multipleOf}-এর গুণিতক হতে হবে`;
+        case 'not': return 'বৈধ হতে পারবে না';
+        case 'oneOf': return 'oneOf-এর শুধুমাত্র একটি স্কিমার সাথে মিলতে হবে';
+        case 'pattern': return `অবশ্যই "${error.params.pattern}" প্যাটার্নের সাথে মিলতে হবে`;
+        case 'propertyNames': return `বৈশিষ্ট্য নাম ${error.params.propertyNames.join(', ')} অবৈধ`;
+        case 'required': return `প্রয়োজনীয় বৈশিষ্ট্য ${error.params.requiredProperties.join(', ')} থাকতে হবে`;
+        case 'type': return typeof error.params.type === 'string' ? `অবশ্যই ${error.params.type} হতে হবে` : `অবশ্যই ${error.params.type.join(' অথবা ')} হতে হবে`;
+        case 'unevaluatedItems': return 'অবমূল্যায়িত আইটেম থাকতে পারবে না';
+        case 'unevaluatedProperties': return 'অবমূল্যায়িত বৈশিষ্ট্য থাকতে পারবে না';
+        case 'uniqueItems': return `অনুলিপি আইটেম থাকতে পারবে না`;
+        case '~guard': return `চেক ফাংশনের সাথে মেলাতে হবে`;
+        case '~refine': return error.params.message;
+        default: return 'একটি অজানা বৈধকরণ ত্রুটি ঘটেছে';
+    }
+}
+// deno-coverage-ignore-stop

package/build/cjs/system/locale/cs_CZ.d.ts

@@ -0,0 +1,3 @@
+import { TValidationError } from '../../error/index';
+/** Czech (Czech Republic) - ISO 639-1 language code 'cs' with ISO 3166-1 alpha-2 country code 'CZ' for Czech Republic. */
+export declare function cs_CZ(error: TValidationError): string;

package/build/cjs/system/locale/cs_CZ.js

@@ -0,0 +1,44 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cs_CZ = cs_CZ;
+/** Czech (Czech Republic) - ISO 639-1 language code 'cs' with ISO 3166-1 alpha-2 country code 'CZ' for Czech Republic. */
+function cs_CZ(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'nesmí mít další vlastnosti';
+        case 'anyOf': return 'musí odpovídat schématu v anyOf';
+        case 'boolean': return 'schéma je nepravdivé';
+        case 'const': return 'musí být rovno konstantě';
+        case 'contains': return 'musí obsahovat alespoň 1 platnou položku';
+        case 'dependencies': return `musí mít vlastnosti ${error.params.dependencies.join(', ')}, pokud je vlastnost ${error.params.property} přítomna`;
+        case 'dependentRequired': return `musí mít vlastnosti ${error.params.dependencies.join(', ')}, pokud je vlastnost ${error.params.property} přítomna`;
+        case 'enum': return 'musí být rovno jedné z povolených hodnot';
+        case 'exclusiveMaximum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `musí odpovídat formátu "${error.params.format}"`;
+        case 'if': return `musí odpovídat schématu "${error.params.failingKeyword}"`;
+        case 'maxItems': return `nesmí mít více než ${error.params.limit} položek`;
+        case 'maxLength': return `nesmí mít více než ${error.params.limit} znaků`;
+        case 'maxProperties': return `nesmí mít více než ${error.params.limit} vlastností`;
+        case 'maximum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `nesmí mít méně než ${error.params.limit} položek`;
+        case 'minLength': return `nesmí mít méně než ${error.params.limit} znaků`;
+        case 'minProperties': return `nesmí mít méně než ${error.params.limit} vlastností`;
+        case 'minimum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `musí být násobkem ${error.params.multipleOf}`;
+        case 'not': return 'nesmí být platné';
+        case 'oneOf': return 'musí odpovídat přesně jednomu schématu v oneOf';
+        case 'pattern': return `musí odpovídat vzoru "${error.params.pattern}"`;
+        case 'propertyNames': return `názvy vlastností ${error.params.propertyNames.join(', ')} jsou neplatné`;
+        case 'required': return `musí mít povinné vlastnosti ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `musí být ${error.params.type}` : `musí být ${error.params.type.join(' nebo ')}`;
+        case 'unevaluatedItems': return 'nesmí mít nevyhodnocené položky';
+        case 'unevaluatedProperties': return 'nesmí mít nevyhodnocené vlastnosti';
+        case 'uniqueItems': return `nesmí mít duplicitní položky`;
+        case '~guard': return `musí odpovídat kontrolní funkci`;
+        case '~refine': return error.params.message;
+        default: return 'došlo k neznámé chybě ověření';
+    }
+}
+// deno-coverage-ignore-stop

package/build/cjs/system/locale/de_DE.d.ts

@@ -0,0 +1,3 @@
+import { TValidationError } from '../../error/index';
+/**  German (Germany) - ISO 639-1 language code 'de' with ISO 3166-1 alpha-2 country code 'DE' for Germany. */
+export declare function de_DE(error: TValidationError): string;

package/build/cjs/system/locale/de_DE.js

@@ -0,0 +1,44 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.de_DE = de_DE;
+/**  German (Germany) - ISO 639-1 language code 'de' with ISO 3166-1 alpha-2 country code 'DE' for Germany. */
+function de_DE(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'darf keine zusätzlichen Eigenschaften haben';
+        case 'anyOf': return 'muss einem Schema in „anyOf“ entsprechen';
+        case 'boolean': return 'Schema ist falsch';
+        case 'const': return 'muss gleich der Konstante sein';
+        case 'contains': return 'muss mindestens 1 gültiges Element enthalten';
+        case 'dependencies': return `muss die Eigenschaften ${error.params.dependencies.join(', ')} haben, wenn Eigenschaft ${error.params.property} vorhanden ist`;
+        case 'dependentRequired': return `muss die Eigenschaften ${error.params.dependencies.join(', ')} haben, wenn Eigenschaft ${error.params.property} vorhanden ist`;
+        case 'enum': return 'muss einem der erlaubten Werte entsprechen';
+        case 'exclusiveMaximum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'exclusiveMinimum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'format': return `muss dem Format "${error.params.format}" entsprechen`;
+        case 'if': return `muss dem Schema "${error.params.failingKeyword}" entsprechen`;
+        case 'maxItems': return `darf nicht mehr als ${error.params.limit} Elemente haben`;
+        case 'maxLength': return `darf nicht mehr als ${error.params.limit} Zeichen haben`;
+        case 'maxProperties': return `darf nicht mehr als ${error.params.limit} Eigenschaften haben`;
+        case 'maximum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'minItems': return `darf nicht weniger als ${error.params.limit} Elemente haben`;
+        case 'minLength': return `darf nicht weniger als ${error.params.limit} Zeichen haben`;
+        case 'minProperties': return `darf nicht weniger als ${error.params.limit} Eigenschaften haben`;
+        case 'minimum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'multipleOf': return `muss ein Vielfaches von ${error.params.multipleOf} sein`;
+        case 'not': return 'darf nicht gültig sein';
+        case 'oneOf': return 'muss genau einem Schema in „oneOf“ entsprechen';
+        case 'pattern': return `muss dem Muster "${error.params.pattern}" entsprechen`;
+        case 'propertyNames': return `Eigenschaftsnamen ${error.params.propertyNames.join(', ')} sind ungültig`;
+        case 'required': return `muss die erforderlichen Eigenschaften ${error.params.requiredProperties.join(', ')} haben`;
+        case 'type': return typeof error.params.type === 'string' ? `muss ${error.params.type} sein` : `muss entweder ${error.params.type.join(' oder ')} sein`;
+        case 'unevaluatedItems': return 'darf keine unbewerteten Elemente haben';
+        case 'unevaluatedProperties': return 'darf keine unbewerteten Eigenschaften haben';
+        case 'uniqueItems': return `darf keine doppelten Elemente haben`;
+        case '~guard': return `muss der Prüffunktion entsprechen`;
+        case '~refine': return error.params.message;
+        default: return 'ein unbekannter Validierungsfehler ist aufgetreten';
+    }
+}
+// deno-coverage-ignore-stop

package/build/cjs/system/locale/el_GR.d.ts

@@ -0,0 +1,3 @@
+import { TValidationError } from '../../error/index';
+/** Greek (Greece) - ISO 639-1 language code 'el' with ISO 3166-1 alpha-2 country code 'GR' for Greece. */
+export declare function el_GR(error: TValidationError): string;