@openclaw/discord 2026.5.20 → 2026.5.22

package/node_modules/typebox/build/system/locale/id_ID.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Indonesian (Indonesia) - ISO 639-1 language code 'id' with ISO 3166-1 alpha-2 country code 'ID' for Indonesia. */
+export function id_ID(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'tidak boleh memiliki properti tambahan';
+        case 'anyOf': return 'harus cocok dengan skema di anyOf';
+        case 'boolean': return 'skema salah';
+        case 'const': return 'harus sama dengan konstanta';
+        case 'contains': return 'harus mengandung setidaknya 1 item yang valid';
+        case 'dependencies': return `harus memiliki properti ${error.params.dependencies.join(', ')} ketika properti ${error.params.property} ada`;
+        case 'dependentRequired': return `harus memiliki properti ${error.params.dependencies.join(', ')} ketika properti ${error.params.property} ada`;
+        case 'enum': return 'harus sama dengan salah satu nilai yang diizinkan';
+        case 'exclusiveMaximum': return `harus ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `harus ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `harus cocok dengan format "${error.params.format}"`;
+        case 'if': return `harus cocok dengan skema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `tidak boleh memiliki lebih dari ${error.params.limit} item`;
+        case 'maxLength': return `tidak boleh memiliki lebih dari ${error.params.limit} karakter`;
+        case 'maxProperties': return `tidak boleh memiliki lebih dari ${error.params.limit} properti`;
+        case 'maximum': return `harus ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `tidak boleh memiliki kurang dari ${error.params.limit} item`;
+        case 'minLength': return `tidak boleh memiliki kurang dari ${error.params.limit} karakter`;
+        case 'minProperties': return `tidak boleh memiliki kurang dari ${error.params.limit} properti`;
+        case 'minimum': return `harus ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `harus kelipatan dari ${error.params.multipleOf}`;
+        case 'not': return 'tidak boleh valid';
+        case 'oneOf': return 'harus cocok persis dengan satu skema di oneOf';
+        case 'pattern': return `harus cocok dengan pola "${error.params.pattern}"`;
+        case 'propertyNames': return `nama properti ${error.params.propertyNames.join(', ')} tidak valid`;
+        case 'required': return `harus memiliki properti yang wajib diisi ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `harus berupa ${error.params.type}` : `harus berupa ${error.params.type.join(' atau ')}`;
+        case 'unevaluatedItems': return 'tidak boleh memiliki item yang belum dievaluasi';
+        case 'unevaluatedProperties': return 'tidak boleh memiliki properti yang belum dievaluasi';
+        case 'uniqueItems': return `tidak boleh memiliki item duplikat`;
+        case '~guard': return `harus sesuai dengan fungsi pemeriksaan`;
+        case '~refine': return error.params.message;
+        default: return 'terjadi kesalahan validasi yang tidak diketahui';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/index.d.mts

@@ -0,0 +1 @@
+export * as Locale from './_locale.mjs';

package/node_modules/typebox/build/system/locale/index.mjs

@@ -0,0 +1 @@
+export * as Locale from './_locale.mjs';

package/node_modules/typebox/build/system/locale/it_IT.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Italian (Italy) - ISO 639-1 language code 'it' with ISO 3166-1 alpha-2 country code 'IT' for Italy. */
+export declare function it_IT(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/it_IT.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Italian (Italy) - ISO 639-1 language code 'it' with ISO 3166-1 alpha-2 country code 'IT' for Italy. */
+export function it_IT(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'non deve avere proprietà aggiuntive';
+        case 'anyOf': return 'deve corrispondere a uno schema in anyOf';
+        case 'boolean': return 'lo schema è falso';
+        case 'const': return 'deve essere uguale alla costante';
+        case 'contains': return 'deve contenere almeno 1 elemento valido';
+        case 'dependencies': return `deve avere le proprietà ${error.params.dependencies.join(', ')} quando la proprietà ${error.params.property} è presente`;
+        case 'dependentRequired': return `deve avere le proprietà ${error.params.dependencies.join(', ')} quando la proprietà ${error.params.property} è presente`;
+        case 'enum': return 'deve essere uguale a uno dei valori consentiti';
+        case 'exclusiveMaximum': return `deve essere ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `deve essere ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `deve corrispondere al formato "${error.params.format}"`;
+        case 'if': return `deve corrispondere allo schema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `non deve avere più di ${error.params.limit} elementi`;
+        case 'maxLength': return `non deve avere più di ${error.params.limit} caratteri`;
+        case 'maxProperties': return `non deve avere più di ${error.params.limit} proprietà`;
+        case 'maximum': return `deve essere ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `non deve avere meno di ${error.params.limit} elementi`;
+        case 'minLength': return `non deve avere meno di ${error.params.limit} caratteri`;
+        case 'minProperties': return `non deve avere meno di ${error.params.limit} proprietà`;
+        case 'minimum': return `deve essere ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `deve essere un multiplo di ${error.params.multipleOf}`;
+        case 'not': return 'non deve essere valido';
+        case 'oneOf': return 'deve corrispondere esattamente a uno schema in oneOf';
+        case 'pattern': return `deve corrispondere al pattern "${error.params.pattern}"`;
+        case 'propertyNames': return `i nomi delle proprietà ${error.params.propertyNames.join(', ')} non sono validi`;
+        case 'required': return `deve avere le proprietà richieste ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `deve essere ${error.params.type}` : `deve essere ${error.params.type.join(' o ')}`;
+        case 'unevaluatedItems': return 'non deve avere elementi non valutati';
+        case 'unevaluatedProperties': return 'non deve avere proprietà non valutate';
+        case 'uniqueItems': return `non deve avere elementi duplicati`;
+        case '~guard': return `deve corrispondere alla funzione di controllo`;
+        case '~refine': return error.params.message;
+        default: return 'si è verificato un errore di validazione sconosciuto';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/ja_JP.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Japanese (Japan) - ISO 639-1 language code 'ja' with ISO 3166-1 alpha-2 country code 'JP' for Japan. */
+export declare function ja_JP(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/ja_JP.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Japanese (Japan) - ISO 639-1 language code 'ja' with ISO 3166-1 alpha-2 country code 'JP' for Japan. */
+export function ja_JP(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return '追加のプロパティを持つことはできません';
+        case 'anyOf': return 'anyOf のスキーマと一致する必要があります';
+        case 'boolean': return 'スキーマが false です';
+        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 のいずれか1つのスキーマと正確に一致する必要があります';
+        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/node_modules/typebox/build/system/locale/ko_KR.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Korean (South Korea) - ISO 639-1 language code 'ko' with ISO 3166-1 alpha-2 country code 'KR' for South Korea. */
+export declare function ko_KR(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/ko_KR.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Korean (South Korea) - ISO 639-1 language code 'ko' with ISO 3166-1 alpha-2 country code 'KR' for South Korea. */
+export function ko_KR(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/node_modules/typebox/build/system/locale/ms_MY.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Malay (Malaysia) - ISO 639-1 language code 'ms' with ISO 3166-1 alpha-2 country code 'MY' for Malaysia. */
+export declare function ms_MY(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/ms_MY.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Malay (Malaysia) - ISO 639-1 language code 'ms' with ISO 3166-1 alpha-2 country code 'MY' for Malaysia. */
+export function ms_MY(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'tidak boleh mempunyai sifat tambahan';
+        case 'anyOf': return 'mesti sepadan dengan skema dalam anyOf';
+        case 'boolean': return 'skema adalah palsu';
+        case 'const': return 'mesti sama dengan pemalar';
+        case 'contains': return 'mesti mengandungi sekurang-kurangnya 1 item yang sah';
+        case 'dependencies': return `mesti mempunyai sifat ${error.params.dependencies.join(', ')} apabila sifat ${error.params.property} hadir`;
+        case 'dependentRequired': return `mesti mempunyai sifat ${error.params.dependencies.join(', ')} apabila sifat ${error.params.property} hadir`;
+        case 'enum': return 'mesti sama dengan salah satu nilai yang dibenarkan';
+        case 'exclusiveMaximum': return `mesti ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `mesti ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `mesti sepadan dengan format "${error.params.format}"`;
+        case 'if': return `mesti sepadan dengan skema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `tidak boleh mempunyai lebih daripada ${error.params.limit} item`;
+        case 'maxLength': return `tidak boleh mempunyai lebih daripada ${error.params.limit} aksara`;
+        case 'maxProperties': return `tidak boleh mempunyai lebih daripada ${error.params.limit} sifat`;
+        case 'maximum': return `mesti ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `tidak boleh mempunyai kurang daripada ${error.params.limit} item`;
+        case 'minLength': return `tidak boleh mempunyai kurang daripada ${error.params.limit} aksara`;
+        case 'minProperties': return `tidak boleh mempunyai kurang daripada ${error.params.limit} sifat`;
+        case 'minimum': return `mesti ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `mesti gandaan ${error.params.multipleOf}`;
+        case 'not': return 'tidak boleh sah';
+        case 'oneOf': return 'mesti sepadan dengan tepat satu skema dalam oneOf';
+        case 'pattern': return `mesti sepadan dengan corak "${error.params.pattern}"`;
+        case 'propertyNames': return `nama sifat ${error.params.propertyNames.join(', ')} tidak sah`;
+        case 'required': return `mesti mempunyai sifat yang diperlukan ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `mesti ${error.params.type}` : `mesti sama ada ${error.params.type.join(' atau ')}`;
+        case 'unevaluatedItems': return 'tidak boleh mempunyai item yang tidak dinilai';
+        case 'unevaluatedProperties': return 'tidak boleh mempunyai sifat yang tidak dinilai';
+        case 'uniqueItems': return `tidak boleh mempunyai item pendua`;
+        case '~guard': return `mestilah sepadan dengan fungsi semak`;
+        case '~refine': return error.params.message;
+        default: return 'ralat pengesahan yang tidak diketahui berlaku';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/nl_NL.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Dutch (Netherlands) - ISO 639-1 language code 'nl' with ISO 3166-1 alpha-2 country code 'NL' for Netherlands. */
+export declare function nl_NL(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/nl_NL.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Dutch (Netherlands) - ISO 639-1 language code 'nl' with ISO 3166-1 alpha-2 country code 'NL' for Netherlands. */
+export function nl_NL(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'mag geen aanvullende eigenschappen hebben';
+        case 'anyOf': return 'moet overeenkomen met een schema in anyOf';
+        case 'boolean': return 'schema is onwaar';
+        case 'const': return 'moet gelijk zijn aan constante';
+        case 'contains': return 'moet ten minste 1 geldig item bevatten';
+        case 'dependencies': return `moet eigenschappen ${error.params.dependencies.join(', ')} hebben wanneer eigenschap ${error.params.property} aanwezig is`;
+        case 'dependentRequired': return `moet eigenschappen ${error.params.dependencies.join(', ')} hebben wanneer eigenschap ${error.params.property} aanwezig is`;
+        case 'enum': return 'moet gelijk zijn aan een van de toegestane waarden';
+        case 'exclusiveMaximum': return `moet ${error.params.comparison} ${error.params.limit} zijn`;
+        case 'exclusiveMinimum': return `moet ${error.params.comparison} ${error.params.limit} zijn`;
+        case 'format': return `moet overeenkomen met formaat "${error.params.format}"`;
+        case 'if': return `moet overeenkomen met "${error.params.failingKeyword}" schema`;
+        case 'maxItems': return `mag niet meer dan ${error.params.limit} items hebben`;
+        case 'maxLength': return `mag niet meer dan ${error.params.limit} tekens hebben`;
+        case 'maxProperties': return `mag niet meer dan ${error.params.limit} eigenschappen hebben`;
+        case 'maximum': return `moet ${error.params.comparison} ${error.params.limit} zijn`;
+        case 'minItems': return `mag niet minder dan ${error.params.limit} items hebben`;
+        case 'minLength': return `mag niet minder dan ${error.params.limit} tekens hebben`;
+        case 'minProperties': return `mag niet minder dan ${error.params.limit} eigenschappen hebben`;
+        case 'minimum': return `moet ${error.params.comparison} ${error.params.limit} zijn`;
+        case 'multipleOf': return `moet een veelvoud zijn van ${error.params.multipleOf}`;
+        case 'not': return 'mag niet geldig zijn';
+        case 'oneOf': return 'moet precies één schema in oneOf overeenkomen';
+        case 'pattern': return `moet overeenkomen met patroon "${error.params.pattern}"`;
+        case 'propertyNames': return `eigenschapsnamen ${error.params.propertyNames.join(', ')} zijn ongeldig`;
+        case 'required': return `moet de vereiste eigenschappen ${error.params.requiredProperties.join(', ')} hebben`;
+        case 'type': return typeof error.params.type === 'string' ? `moet ${error.params.type} zijn` : `moet ${error.params.type.join(' of ')} zijn`;
+        case 'unevaluatedItems': return 'mag geen onbeoordeelde items hebben';
+        case 'unevaluatedProperties': return 'mag geen onbeoordeelde eigenschappen hebben';
+        case 'uniqueItems': return `mag geen dubbele items hebben`;
+        case '~guard': return `moet overeenkomen met de controlefunctie`;
+        case '~refine': return error.params.message;
+        default: return 'er is een onbekende validatiefout opgetreden';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/pl_PL.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Polish (Poland) - ISO 639-1 language code 'pl' with ISO 3166-1 alpha-2 country code 'PL' for Poland. */
+export declare function pl_PL(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/pl_PL.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Polish (Poland) - ISO 639-1 language code 'pl' with ISO 3166-1 alpha-2 country code 'PL' for Poland. */
+export function pl_PL(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'nie może mieć dodatkowych właściwości';
+        case 'anyOf': return 'musi pasować do schematu w anyOf';
+        case 'boolean': return 'schemat jest fałszywy';
+        case 'const': return 'musi być równy stałej';
+        case 'contains': return 'musi zawierać co najmniej 1 prawidłowy element';
+        case 'dependencies': return `musi mieć właściwości ${error.params.dependencies.join(', ')}, gdy właściwość ${error.params.property} jest obecna`;
+        case 'dependentRequired': return `musi mieć właściwości ${error.params.dependencies.join(', ')}, gdy właściwość ${error.params.property} jest obecna`;
+        case 'enum': return 'musi być równy jednej z dozwolonych wartości';
+        case 'exclusiveMaximum': return `musi być ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `musi być ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `musi pasować do formatu "${error.params.format}"`;
+        case 'if': return `musi pasować do schematu "${error.params.failingKeyword}"`;
+        case 'maxItems': return `nie może mieć więcej niż ${error.params.limit} elementów`;
+        case 'maxLength': return `nie może mieć więcej niż ${error.params.limit} znaków`;
+        case 'maxProperties': return `nie może mieć więcej niż ${error.params.limit} właściwości`;
+        case 'maximum': return `musi być ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `nie może mieć mniej niż ${error.params.limit} elementów`;
+        case 'minLength': return `nie może mieć mniej niż ${error.params.limit} znaków`;
+        case 'minProperties': return `nie może mieć mniej niż ${error.params.limit} właściwości`;
+        case 'minimum': return `musi być ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `musi być wielokrotnością ${error.params.multipleOf}`;
+        case 'not': return 'nie może być ważne';
+        case 'oneOf': return 'musi pasować dokładnie do jednego schematu w oneOf';
+        case 'pattern': return `musi pasować do wzorca "${error.params.pattern}"`;
+        case 'propertyNames': return `nazwy właściwości ${error.params.propertyNames.join(', ')} są nieprawidłowe`;
+        case 'required': return `musi mieć wymagane właściwości ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `musi być typu ${error.params.type}` : `musi być typu ${error.params.type.join(' lub ')}`;
+        case 'unevaluatedItems': return 'nie może mieć nieewaluowanych elementów';
+        case 'unevaluatedProperties': return 'nie może mieć nieewaluowanych właściwości';
+        case 'uniqueItems': return `nie może zawierać zduplikowanych elementów`;
+        case '~guard': return `musi pasować do funkcji sprawdzającej`;
+        case '~refine': return error.params.message;
+        default: return 'wystąpił nieznany błąd walidacji';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/pt_BR.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Portuguese (Brazil) - ISO 639-1 language code 'pt' with ISO 3166-1 alpha-2 country code 'BR' for Brazil. */
+export declare function pt_BR(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/pt_BR.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Portuguese (Brazil) - ISO 639-1 language code 'pt' with ISO 3166-1 alpha-2 country code 'BR' for Brazil. */
+export function pt_BR(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'não deve ter propriedades adicionais';
+        case 'anyOf': return 'deve corresponder a um esquema em anyOf';
+        case 'boolean': return 'o esquema é falso';
+        case 'const': return 'deve ser igual à constante';
+        case 'contains': return 'deve conter pelo menos 1 item válido';
+        case 'dependencies': return `deve ter as propriedades ${error.params.dependencies.join(', ')} quando a propriedade ${error.params.property} estiver presente`;
+        case 'dependentRequired': return `deve ter as propriedades ${error.params.dependencies.join(', ')} quando a propriedade ${error.params.property} estiver presente`;
+        case 'enum': return 'deve ser igual a um dos valores permitidos';
+        case 'exclusiveMaximum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `deve corresponder ao formato "${error.params.format}"`;
+        case 'if': return `deve corresponder ao esquema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `não deve ter mais de ${error.params.limit} itens`;
+        case 'maxLength': return `não deve ter mais de ${error.params.limit} caracteres`;
+        case 'maxProperties': return `não deve ter mais de ${error.params.limit} propriedades`;
+        case 'maximum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `não deve ter menos de ${error.params.limit} itens`;
+        case 'minLength': return `não deve ter menos de ${error.params.limit} caracteres`;
+        case 'minProperties': return `não deve ter menos de ${error.params.limit} propriedades`;
+        case 'minimum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `deve ser múltiplo de ${error.params.multipleOf}`;
+        case 'not': return 'não deve ser válido';
+        case 'oneOf': return 'deve corresponder exatamente a um esquema em oneOf';
+        case 'pattern': return `deve corresponder ao padrão "${error.params.pattern}"`;
+        case 'propertyNames': return `os nomes das propriedades ${error.params.propertyNames.join(', ')} são inválidos`;
+        case 'required': return `deve ter as propriedades obrigatórias ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `deve ser ${error.params.type}` : `deve ser ${error.params.type.join(' ou ')}`;
+        case 'unevaluatedItems': return 'não deve ter itens não avaliados';
+        case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
+        case 'uniqueItems': return `não deve ter itens duplicados`;
+        case '~guard': return `deve corresponder à função de verificação`;
+        case '~refine': return error.params.message;
+        default: return 'ocorreu um erro de validação desconhecido';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/pt_PT.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Portuguese (Portugal) - ISO 639-1 language code 'pt' with ISO 3166-1 alpha-2 country code 'PT' for Portugal. */
+export declare function pt_PT(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/pt_PT.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Portuguese (Portugal) - ISO 639-1 language code 'pt' with ISO 3166-1 alpha-2 country code 'PT' for Portugal. */
+export function pt_PT(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'não deve ter propriedades adicionais';
+        case 'anyOf': return 'deve corresponder a um esquema em anyOf';
+        case 'boolean': return 'o esquema é falso';
+        case 'const': return 'deve ser igual à constante';
+        case 'contains': return 'deve conter pelo menos 1 item válido';
+        case 'dependencies': return `deve ter as propriedades ${error.params.dependencies.join(', ')} quando a propriedade ${error.params.property} estiver presente`;
+        case 'dependentRequired': return `deve ter as propriedades ${error.params.dependencies.join(', ')} quando a propriedade ${error.params.property} estiver presente`;
+        case 'enum': return 'deve ser igual a um dos valores permitidos';
+        case 'exclusiveMaximum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `deve corresponder ao formato "${error.params.format}"`;
+        case 'if': return `deve corresponder ao esquema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `não deve ter mais de ${error.params.limit} itens`;
+        case 'maxLength': return `não deve ter mais de ${error.params.limit} carateres`;
+        case 'maxProperties': return `não deve ter mais de ${error.params.limit} propriedades`;
+        case 'maximum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `não deve ter menos de ${error.params.limit} itens`;
+        case 'minLength': return `não deve ter menos de ${error.params.limit} carateres`;
+        case 'minProperties': return `não deve ter menos de ${error.params.limit} propriedades`;
+        case 'minimum': return `deve ser ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `deve ser múltiplo de ${error.params.multipleOf}`;
+        case 'not': return 'não deve ser válido';
+        case 'oneOf': return 'deve corresponder exatamente a um esquema em oneOf';
+        case 'pattern': return `deve corresponder ao padrão "${error.params.pattern}"`;
+        case 'propertyNames': return `os nomes das propriedades ${error.params.propertyNames.join(', ')} são inválidos`;
+        case 'required': return `deve ter as propriedades obrigatórias ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `deve ser ${error.params.type}` : `deve ser ${error.params.type.join(' ou ')}`;
+        case 'unevaluatedItems': return 'não deve ter itens não avaliados';
+        case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
+        case 'uniqueItems': return `não deve ter itens duplicados`;
+        case '~guard': return `deve corresponder à função de verificação`;
+        case '~refine': return error.params.message;
+        default: return 'ocorreu um erro de validação desconhecido';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/ro_RO.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Romanian (Romania) - ISO 639-1 language code 'ro' with ISO 3166-1 alpha-2 country code 'RO' for Romania. */
+export declare function ro_RO(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/ro_RO.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Romanian (Romania) - ISO 639-1 language code 'ro' with ISO 3166-1 alpha-2 country code 'RO' for Romania. */
+export function ro_RO(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'nu trebuie să aibă proprietăți suplimentare';
+        case 'anyOf': return 'trebuie să se potrivească cu o schemă din anyOf';
+        case 'boolean': return 'schema este falsă';
+        case 'const': return 'trebuie să fie egal cu constanta';
+        case 'contains': return 'trebuie să conțină cel puțin 1 element valid';
+        case 'dependencies': return `trebuie să aibă proprietățile ${error.params.dependencies.join(', ')} când proprietatea ${error.params.property} este prezentă`;
+        case 'dependentRequired': return `trebuie să aibă proprietățile ${error.params.dependencies.join(', ')} când proprietatea ${error.params.property} este prezentă`;
+        case 'enum': return 'trebuie să fie egal cu una dintre valorile permise';
+        case 'exclusiveMaximum': return `trebuie să fie ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `trebuie să fie ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `trebuie să se potrivească formatului "${error.params.format}"`;
+        case 'if': return `trebuie să se potrivească cu schema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `nu trebuie să aibă mai mult de ${error.params.limit} elemente`;
+        case 'maxLength': return `nu trebuie să aibă mai mult de ${error.params.limit} caractere`;
+        case 'maxProperties': return `nu trebuie să aibă mai mult de ${error.params.limit} proprietăți`;
+        case 'maximum': return `trebuie să fie ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `nu trebuie să aibă mai puțin de ${error.params.limit} elemente`;
+        case 'minLength': return `nu trebuie să aibă mai puțin de ${error.params.limit} caractere`;
+        case 'minProperties': return `nu trebuie să aibă mai puțin de ${error.params.limit} proprietăți`;
+        case 'minimum': return `trebuie să fie ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `trebuie să fie multiplu de ${error.params.multipleOf}`;
+        case 'not': return 'nu trebuie să fie valid';
+        case 'oneOf': return 'trebuie să se potrivească exact unei scheme din oneOf';
+        case 'pattern': return `trebuie să se potrivească cu modelul "${error.params.pattern}"`;
+        case 'propertyNames': return `numele proprietăților ${error.params.propertyNames.join(', ')} sunt invalide`;
+        case 'required': return `trebuie să aibă proprietățile obligatorii ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `trebuie să fie ${error.params.type}` : `trebuie să fie ${error.params.type.join(' sau ')}`;
+        case 'unevaluatedItems': return 'nu trebuie să aibă elemente neevaluate';
+        case 'unevaluatedProperties': return 'nu trebuie să aibă proprietăți neevaluate';
+        case 'uniqueItems': return `nu trebuie să aibă elemente duplicate`;
+        case '~guard': return `trebuie să corespundă funcției de verificare`;
+        case '~refine': return error.params.message;
+        default: return 'a apărut o eroare de validare necunoscută';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/ru_RU.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Russian (Russia) - ISO 639-1 language code 'ru' with ISO 3166-1 alpha-2 country code 'RU' for Russia. */
+export declare function ru_RU(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/ru_RU.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Russian (Russia) - ISO 639-1 language code 'ru' with ISO 3166-1 alpha-2 country code 'RU' for Russia. */
+export function ru_RU(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.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 'должен соответствовать ровно одной схеме в 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/node_modules/typebox/build/system/locale/sv_SE.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Swedish (Sweden) - ISO 639-1 language code 'sv' with ISO 3166-1 alpha-2 country code 'SE' for Sweden. */
+export declare function sv_SE(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/sv_SE.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Swedish (Sweden) - ISO 639-1 language code 'sv' with ISO 3166-1 alpha-2 country code 'SE' for Sweden. */
+export function sv_SE(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'får inte ha ytterligare egenskaper';
+        case 'anyOf': return 'måste matcha ett schema i anyOf';
+        case 'boolean': return 'schemat är falskt';
+        case 'const': return 'måste vara lika med konstanten';
+        case 'contains': return 'måste innehålla minst 1 giltigt objekt';
+        case 'dependencies': return `måste ha egenskaperna ${error.params.dependencies.join(', ')} när egenskapen ${error.params.property} finns`;
+        case 'dependentRequired': return `måste ha egenskaperna ${error.params.dependencies.join(', ')} när egenskapen ${error.params.property} finns`;
+        case 'enum': return 'måste vara lika med ett av de tillåtna värdena';
+        case 'exclusiveMaximum': return `måste vara ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `måste vara ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `måste matcha formatet "${error.params.format}"`;
+        case 'if': return `måste matcha "${error.params.failingKeyword}" schema`;
+        case 'maxItems': return `får inte ha fler än ${error.params.limit} objekt`;
+        case 'maxLength': return `får inte ha fler än ${error.params.limit} tecken`;
+        case 'maxProperties': return `får inte ha fler än ${error.params.limit} egenskaper`;
+        case 'maximum': return `måste vara ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `får inte ha färre än ${error.params.limit} objekt`;
+        case 'minLength': return `får inte ha färre än ${error.params.limit} tecken`;
+        case 'minProperties': return `får inte ha färre än ${error.params.limit} egenskaper`;
+        case 'minimum': return `måste vara ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `måste vara en multipel av ${error.params.multipleOf}`;
+        case 'not': return 'får inte vara giltigt';
+        case 'oneOf': return 'måste matcha exakt ett schema i oneOf';
+        case 'pattern': return `måste matcha mönstret "${error.params.pattern}"`;
+        case 'propertyNames': return `egenskapernas namn ${error.params.propertyNames.join(', ')} är ogiltiga`;
+        case 'required': return `måste ha obligatoriska egenskaper ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `måste vara ${error.params.type}` : `måste vara antingen ${error.params.type.join(' eller ')}`;
+        case 'unevaluatedItems': return 'får inte ha oidentifierade objekt';
+        case 'unevaluatedProperties': return 'får inte ha oidentifierade egenskaper';
+        case 'uniqueItems': return `får inte ha dubbletter`;
+        case '~guard': return `måste matcha kontrollfunktionen`;
+        case '~refine': return error.params.message;
+        default: return 'ett okänt valideringsfel uppstod';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/sw_TZ.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Swahili (Tanzania) - ISO 639-1 language code 'sw' with ISO 3166-1 alpha-2 country code 'TZ' for Tanzania (as a common representative). */
+export declare function sw_TZ(error: TValidationError): string;