@openclaw/tavily-plugin 0.0.0 → 2026.6.11-beta.2

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

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+/** en_US: English (United States) - ISO 639-1 language code 'en' with ISO 3166-1 alpha-2 country code 'US' for United States. */
+export function en_US(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'must not have additional properties';
+        case 'anyOf': return 'must match a schema in anyOf';
+        case 'boolean': return 'schema is false';
+        case 'const': return 'must be equal to constant';
+        case 'contains': return 'must contain at least 1 valid item';
+        case 'dependencies': return `must have properties ${error.params.dependencies.join(', ')} when property ${error.params.property} is present`;
+        case 'dependentRequired': return `must have properties ${error.params.dependencies.join(', ')} when property ${error.params.property} is present`;
+        case 'enum': return 'must be equal to one of the allowed values';
+        case 'exclusiveMaximum': return `must be ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `must be ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `must match format "${error.params.format}"`;
+        case 'if': return `must match "${error.params.failingKeyword}" schema`;
+        case 'maxItems': return `must not have more than ${error.params.limit} items`;
+        case 'maxLength': return `must not have more than ${error.params.limit} characters`;
+        case 'maxProperties': return `must not have more than ${error.params.limit} properties`;
+        case 'maximum': return `must be ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `must not have fewer than ${error.params.limit} items`;
+        case 'minLength': return `must not have fewer than ${error.params.limit} characters`;
+        case 'minProperties': return `must not have fewer than ${error.params.limit} properties`;
+        case 'minimum': return `must be ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `must be multiple of ${error.params.multipleOf}`;
+        case 'not': return 'must not be valid';
+        case 'oneOf': return 'must match exactly one schema in oneOf';
+        case 'pattern': return `must match pattern "${error.params.pattern}"`;
+        case 'propertyNames': return `property names ${error.params.propertyNames.join(', ')} are invalid`;
+        case 'required': return `must have required properties ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `must be ${error.params.type}` : `must be either ${error.params.type.join(' or ')}`;
+        case 'unevaluatedItems': return 'must not have unevaluated items';
+        case 'unevaluatedProperties': return 'must not have unevaluated properties';
+        case 'uniqueItems': return `must not have duplicate items`;
+        case '~guard': return `must match check function`;
+        case '~refine': return error.params.message;
+        // deno-coverage-ignore - unreachable
+        default: return 'an unknown validation error occurred';
+    }
+}

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Spanish (Latin America) - ISO 639-1 language code 'es' with UN M.49 region code '419' for Latin America and the Caribbean. */
+export declare function es_419(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Spanish (Latin America) - ISO 639-1 language code 'es' with UN M.49 region code '419' for Latin America and the Caribbean. */
+export function es_419(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'no debe tener propiedades adicionales';
+        case 'anyOf': return 'debe coincidir con un esquema en cualquiera de';
+        case 'boolean': return 'el esquema es falso';
+        case 'const': return 'debe ser igual a la constante';
+        case 'contains': return 'debe contener al menos 1 elemento válido';
+        case 'dependencies': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'dependentRequired': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'enum': return 'debe ser igual a uno de los valores permitidos';
+        case 'exclusiveMaximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `debe coincidir con el formato "${error.params.format}"`;
+        case 'if': return `debe coincidir con el esquema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `no debe tener más de ${error.params.limit} elementos`;
+        case 'maxLength': return `no debe tener más de ${error.params.limit} caracteres`;
+        case 'maxProperties': return `no debe tener más de ${error.params.limit} propiedades`;
+        case 'maximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `no debe tener menos de ${error.params.limit} elementos`;
+        case 'minLength': return `no debe tener menos de ${error.params.limit} caracteres`;
+        case 'minProperties': return `no debe tener menos de ${error.params.limit} propiedades`;
+        case 'minimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `debe ser múltiplo de ${error.params.multipleOf}`;
+        case 'not': return 'no debe ser válido';
+        case 'oneOf': return 'debe coincidir exactamente con un esquema en uno de';
+        case 'pattern': return `debe coincidir con el patrón "${error.params.pattern}"`;
+        case 'propertyNames': return `los nombres de las propiedades ${error.params.propertyNames.join(', ')} no son válidos`;
+        case 'required': return `debe tener las propiedades requeridas ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `debe ser ${error.params.type}` : `debe ser ${error.params.type.join(' o ')}`;
+        case 'unevaluatedItems': return 'no debe tener elementos no evaluados';
+        case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
+        case 'uniqueItems': return `no debe tener elementos duplicados`;
+        case '~guard': return `debe coincidir con la función de verificación`;
+        case '~refine': return error.params.message;
+        default: return 'ocurrió un error de validación desconocido';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Spanish (Argentina) - ISO 639-1 language code 'es' with ISO 3166-1 alpha-2 country code 'AR' for Argentina. */
+export declare function es_AR(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Spanish (Argentina) - ISO 639-1 language code 'es' with ISO 3166-1 alpha-2 country code 'AR' for Argentina. */
+export function es_AR(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'no debe tener propiedades adicionales';
+        case 'anyOf': return 'debe coincidir con un esquema en cualquiera de';
+        case 'boolean': return 'el esquema es falso';
+        case 'const': return 'debe ser igual a la constante';
+        case 'contains': return 'debe contener al menos 1 elemento válido';
+        case 'dependencies': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'dependentRequired': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'enum': return 'debe ser igual a uno de los valores permitidos';
+        case 'exclusiveMaximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `debe coincidir con el formato "${error.params.format}"`;
+        case 'if': return `debe coincidir con el esquema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `no debe tener más de ${error.params.limit} elementos`;
+        case 'maxLength': return `no debe tener más de ${error.params.limit} caracteres`;
+        case 'maxProperties': return `no debe tener más de ${error.params.limit} propiedades`;
+        case 'maximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `no debe tener menos de ${error.params.limit} elementos`;
+        case 'minLength': return `no debe tener menos de ${error.params.limit} caracteres`;
+        case 'minProperties': return `no debe tener menos de ${error.params.limit} propiedades`;
+        case 'minimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `debe ser múltiplo de ${error.params.multipleOf}`;
+        case 'not': return 'no debe ser válido';
+        case 'oneOf': return 'debe coincidir exactamente con un esquema en uno de';
+        case 'pattern': return `debe coincidir con el patrón "${error.params.pattern}"`;
+        case 'propertyNames': return `los nombres de las propiedades ${error.params.propertyNames.join(', ')} son inválidos`;
+        case 'required': return `debe tener las propiedades requeridas ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `debe ser ${error.params.type}` : `debe ser ${error.params.type.join(' o ')}`;
+        case 'unevaluatedItems': return 'no debe tener elementos no evaluados';
+        case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
+        case 'uniqueItems': return `no debe tener elementos duplicados`;
+        case '~guard': return `debe coincidir con la función de verificación`;
+        case '~refine': return error.params.message;
+        default: return 'ocurrió un error de validación desconocido';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Spanish (Spain) - ISO 639-1 language code 'es' with ISO 3166-1 alpha-2 country code 'ES' for Spain. */
+export declare function es_ES(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Spanish (Spain) - ISO 639-1 language code 'es' with ISO 3166-1 alpha-2 country code 'ES' for Spain. */
+export function es_ES(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'no debe tener propiedades adicionales';
+        case 'anyOf': return 'debe coincidir con un esquema en cualquiera de';
+        case 'boolean': return 'el esquema es falso';
+        case 'const': return 'debe ser igual a la constante';
+        case 'contains': return 'debe contener al menos 1 elemento válido';
+        case 'dependencies': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'dependentRequired': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'enum': return 'debe ser igual a uno de los valores permitidos';
+        case 'exclusiveMaximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `debe coincidir con el formato "${error.params.format}"`;
+        case 'if': return `debe coincidir con el esquema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `no debe tener más de ${error.params.limit} elementos`;
+        case 'maxLength': return `no debe tener más de ${error.params.limit} caracteres`;
+        case 'maxProperties': return `no debe tener más de ${error.params.limit} propiedades`;
+        case 'maximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `no debe tener menos de ${error.params.limit} elementos`;
+        case 'minLength': return `no debe tener menos de ${error.params.limit} caracteres`;
+        case 'minProperties': return `no debe tener menos de ${error.params.limit} propiedades`;
+        case 'minimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `debe ser múltiplo de ${error.params.multipleOf}`;
+        case 'not': return 'no debe ser válido';
+        case 'oneOf': return 'debe coincidir exactamente con un esquema en uno de';
+        case 'pattern': return `debe coincidir con el patrón "${error.params.pattern}"`;
+        case 'propertyNames': return `los nombres de las propiedades ${error.params.propertyNames.join(', ')} no son válidos`;
+        case 'required': return `debe tener las propiedades requeridas ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `debe ser ${error.params.type}` : `debe ser ${error.params.type.join(' o ')}`;
+        case 'unevaluatedItems': return 'no debe tener elementos no evaluados';
+        case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
+        case 'uniqueItems': return `no debe tener elementos duplicados`;
+        case '~guard': return `debe coincidir con la función de verificación`;
+        case '~refine': return error.params.message;
+        default: return 'ha ocurrido un error de validación desconocido';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/**  Spanish (Mexico) - ISO 639-1 language code 'es' with ISO 3166-1 alpha-2 country code 'MX' for Mexico. */
+export declare function es_MX(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/**  Spanish (Mexico) - ISO 639-1 language code 'es' with ISO 3166-1 alpha-2 country code 'MX' for Mexico. */
+export function es_MX(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'no debe tener propiedades adicionales';
+        case 'anyOf': return 'debe coincidir con un esquema en cualquiera de';
+        case 'boolean': return 'el esquema es falso';
+        case 'const': return 'debe ser igual a la constante';
+        case 'contains': return 'debe contener al menos 1 elemento válido';
+        case 'dependencies': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'dependentRequired': return `debe tener las propiedades ${error.params.dependencies.join(', ')} cuando la propiedad ${error.params.property} está presente`;
+        case 'enum': return 'debe ser igual a uno de los valores permitidos';
+        case 'exclusiveMaximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `debe coincidir con el formato "${error.params.format}"`;
+        case 'if': return `debe coincidir con el esquema "${error.params.failingKeyword}"`;
+        case 'maxItems': return `no debe tener más de ${error.params.limit} elementos`;
+        case 'maxLength': return `no debe tener más de ${error.params.limit} caracteres`;
+        case 'maxProperties': return `no debe tener más de ${error.params.limit} propiedades`;
+        case 'maximum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `no debe tener menos de ${error.params.limit} elementos`;
+        case 'minLength': return `no debe tener menos de ${error.params.limit} caracteres`;
+        case 'minProperties': return `no debe tener menos de ${error.params.limit} propiedades`;
+        case 'minimum': return `debe ser ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `debe ser múltiplo de ${error.params.multipleOf}`;
+        case 'not': return 'no debe ser válido';
+        case 'oneOf': return 'debe coincidir exactamente con un esquema en uno de';
+        case 'pattern': return `debe coincidir con el patrón "${error.params.pattern}"`;
+        case 'propertyNames': return `los nombres de las propiedades ${error.params.propertyNames.join(', ')} no son válidos`;
+        case 'required': return `debe tener las propiedades requeridas ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `debe ser ${error.params.type}` : `debe ser ${error.params.type.join(' o ')}`;
+        case 'unevaluatedItems': return 'no debe tener elementos no evaluados';
+        case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
+        case 'uniqueItems': return `no debe tener elementos duplicados`;
+        case '~guard': return `debe coincidir con la función de verificación`;
+        case '~refine': return error.params.message;
+        default: return 'ocurrió un error de validación desconocido';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Persian (Iran) - ISO 639-1 language code 'fa' with ISO 3166-1 alpha-2 country code 'IR' for Iran. */
+export declare function fa_IR(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Persian (Iran) - ISO 639-1 language code 'fa' with ISO 3166-1 alpha-2 country code 'IR' for Iran. */
+export function fa_IR(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/fil_PH.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Filipino (Philippines) - ISO 639-1 language code 'fil' with ISO 3166-1  */
+export declare function fil_PH(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Filipino (Philippines) - ISO 639-1 language code 'fil' with ISO 3166-1  */
+export function fil_PH(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'hindi dapat magkaroon ng karagdagang mga katangian';
+        case 'anyOf': return 'dapat tumugma sa isang schema sa anyOf';
+        case 'boolean': return 'mali ang schema';
+        case 'const': return 'dapat katumbas ng konstante';
+        case 'contains': return 'dapat maglaman ng hindi bababa sa 1 wastong item';
+        case 'dependencies': return `dapat magkaroon ng mga katangian ${error.params.dependencies.join(', ')} kapag naroroon ang katangian ${error.params.property}`;
+        case 'dependentRequired': return `dapat magkaroon ng mga katangian ${error.params.dependencies.join(', ')} kapag naroroon ang katangian ${error.params.property}`;
+        case 'enum': return 'dapat katumbas ng isa sa mga pinapayagang halaga';
+        case 'exclusiveMaximum': return `dapat ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `dapat ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `dapat tumugma sa format na "${error.params.format}"`;
+        case 'if': return `dapat tumugma sa "${error.params.failingKeyword}" schema`;
+        case 'maxItems': return `hindi dapat magkaroon ng higit sa ${error.params.limit} item`;
+        case 'maxLength': return `hindi dapat magkaroon ng higit sa ${error.params.limit} karakter`;
+        case 'maxProperties': return `hindi dapat magkaroon ng higit sa ${error.params.limit} katangian`;
+        case 'maximum': return `dapat ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `hindi dapat magkaroon ng mas kaunti sa ${error.params.limit} item`;
+        case 'minLength': return `hindi dapat magkaroon ng mas kaunti sa ${error.params.limit} karakter`;
+        case 'minProperties': return `hindi dapat magkaroon ng mas kaunti sa ${error.params.limit} katangian`;
+        case 'minimum': return `dapat ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `dapat maramihan ng ${error.params.multipleOf}`;
+        case 'not': return 'hindi dapat wasto';
+        case 'oneOf': return 'dapat tumugma nang eksakto sa isang schema sa oneOf';
+        case 'pattern': return `dapat tumugma sa pattern na "${error.params.pattern}"`;
+        case 'propertyNames': return `ang mga pangalan ng katangian na ${error.params.propertyNames.join(', ')} ay hindi wasto`;
+        case 'required': return `dapat magkaroon ng mga kinakailangang katangian ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `dapat ${error.params.type}` : `dapat ay ${error.params.type.join(' o ')}`;
+        case 'unevaluatedItems': return 'hindi dapat magkaroon ng mga hindi pa nasusuring item';
+        case 'unevaluatedProperties': return 'hindi dapat magkaroon ng mga hindi pa nasusuring katangian';
+        case 'uniqueItems': return `hindi dapat magkaroon ng mga duplicate na item`;
+        case '~guard': return `dapat tumugma sa function ng pagsusuri`;
+        case '~refine': return error.params.message;
+        default: return 'nagkaroon ng hindi kilalang error sa pagpapatunay';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** French (Canada) - ISO 639-1 language code 'fr' with ISO 3166-1 alpha-2 country code 'CA' for Canada. */
+export declare function fr_CA(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** French (Canada) - ISO 639-1 language code 'fr' with ISO 3166-1 alpha-2 country code 'CA' for Canada. */
+export function fr_CA(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'ne doit pas avoir de propriétés additionnelles';
+        case 'anyOf': return 'doit correspondre à un schéma dans anyOf';
+        case 'boolean': return 'le schéma est faux';
+        case 'const': return 'doit être égal à la constante';
+        case 'contains': return 'doit contenir au moins 1 élément valide';
+        case 'dependencies': return `doit avoir les propriétés ${error.params.dependencies.join(', ')} lorsque la propriété ${error.params.property} est présente`;
+        case 'dependentRequired': return `doit avoir les propriétés ${error.params.dependencies.join(', ')} lorsque la propriété ${error.params.property} est présente`;
+        case 'enum': return 'doit être égal à l\'une des valeurs autorisées';
+        case 'exclusiveMaximum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `doit correspondre au format "${error.params.format}"`;
+        case 'if': return `doit correspondre au schéma "${error.params.failingKeyword}"`;
+        case 'maxItems': return `ne doit pas avoir plus de ${error.params.limit} éléments`;
+        case 'maxLength': return `ne doit pas avoir plus de ${error.params.limit} caractères`;
+        case 'maxProperties': return `ne doit pas avoir plus de ${error.params.limit} propriétés`;
+        case 'maximum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `ne doit pas avoir moins de ${error.params.limit} éléments`;
+        case 'minLength': return `ne doit pas avoir moins de ${error.params.limit} caractères`;
+        case 'minProperties': return `ne doit pas avoir moins de ${error.params.limit} propriétés`;
+        case 'minimum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `doit être un multiple de ${error.params.multipleOf}`;
+        case 'not': return 'ne doit pas être valide';
+        case 'oneOf': return 'doit correspondre exactement à un schéma dans oneOf';
+        case 'pattern': return `doit correspondre au motif "${error.params.pattern}"`;
+        case 'propertyNames': return `les noms de propriété ${error.params.propertyNames.join(', ')} sont invalides`;
+        case 'required': return `doit avoir les propriétés requises ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `doit être ${error.params.type}` : `doit être l'un des types suivants : ${error.params.type.join(' ou ')}`;
+        case 'unevaluatedItems': return 'ne doit pas avoir d\'éléments non évalués';
+        case 'unevaluatedProperties': return 'ne doit pas avoir de propriétés non évaluées';
+        case 'uniqueItems': return `ne doit pas avoir d'éléments en double`;
+        case '~guard': return `doit correspondre à la fonction de vérification`;
+        case '~refine': return error.params.message;
+        default: return 'une erreur de validation inconnue est survenue';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** French (France) - ISO 639-1 language code 'fr' with ISO 3166-1 alpha-2 country code 'FR' for France. */
+export declare function fr_FR(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** French (France) - ISO 639-1 language code 'fr' with ISO 3166-1 alpha-2 country code 'FR' for France. */
+export function fr_FR(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'ne doit pas avoir de propriétés additionnelles';
+        case 'anyOf': return 'doit correspondre à un schéma dans anyOf';
+        case 'boolean': return 'le schéma est faux';
+        case 'const': return 'doit être égal à la constante';
+        case 'contains': return 'doit contenir au moins 1 élément valide';
+        case 'dependencies': return `doit avoir les propriétés ${error.params.dependencies.join(', ')} lorsque la propriété ${error.params.property} est présente`;
+        case 'dependentRequired': return `doit avoir les propriétés ${error.params.dependencies.join(', ')} lorsque la propriété ${error.params.property} est présente`;
+        case 'enum': return 'doit être égal à l\'une des valeurs autorisées';
+        case 'exclusiveMaximum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `doit correspondre au format "${error.params.format}"`;
+        case 'if': return `doit correspondre au schéma "${error.params.failingKeyword}"`;
+        case 'maxItems': return `ne doit pas avoir plus de ${error.params.limit} éléments`;
+        case 'maxLength': return `ne doit pas avoir plus de ${error.params.limit} caractères`;
+        case 'maxProperties': return `ne doit pas avoir plus de ${error.params.limit} propriétés`;
+        case 'maximum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `ne doit pas avoir moins de ${error.params.limit} éléments`;
+        case 'minLength': return `ne doit pas avoir moins de ${error.params.limit} caractères`;
+        case 'minProperties': return `ne doit pas avoir moins de ${error.params.limit} propriétés`;
+        case 'minimum': return `doit être ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `doit être un multiple de ${error.params.multipleOf}`;
+        case 'not': return 'ne doit pas être valide';
+        case 'oneOf': return 'doit correspondre exactement à un schéma dans oneOf';
+        case 'pattern': return `doit correspondre au motif "${error.params.pattern}"`;
+        case 'propertyNames': return `les noms de propriété ${error.params.propertyNames.join(', ')} sont invalides`;
+        case 'required': return `doit avoir les propriétés requises ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `doit être ${error.params.type}` : `doit être l'un des types suivants : ${error.params.type.join(' ou ')}`;
+        case 'unevaluatedItems': return 'ne doit pas avoir d\'éléments non évalués';
+        case 'unevaluatedProperties': return 'ne doit pas avoir de propriétés non évaluées';
+        case 'uniqueItems': return `ne doit pas avoir d'éléments en double`;
+        case '~guard': return `doit correspondre à la fonction de vérification`;
+        case '~refine': return error.params.message;
+        default: return 'une erreur de validation inconnue est survenue';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Hausa (Nigeria) - ISO 639-1 language code 'ha' with ISO 3166-1 alpha-2 country code 'NG' for Nigeria. */
+export declare function ha_NG(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Hausa (Nigeria) - ISO 639-1 language code 'ha' with ISO 3166-1 alpha-2 country code 'NG' for Nigeria. */
+export function ha_NG(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'kada ya kasance yana da ƙarin kaddarori';
+        case 'anyOf': return 'dole ne ya dace da wani tsari a cikin anyOf';
+        case 'boolean': return 'tsarin yana da karya';
+        case 'const': return 'dole ne ya zama daidai da madaidaicin';
+        case 'contains': return 'dole ne ya ƙunshi aƙalla abu 1 mai inganci';
+        case 'dependencies': return `dole ne ya kasance yana da kaddarori ${error.params.dependencies.join(', ')} idan kadara ${error.params.property} tana nan`;
+        case 'dependentRequired': return `dole ne ya kasance yana da kaddarori ${error.params.dependencies.join(', ')} idan kadara ${error.params.property} tana nan`;
+        case 'enum': return 'dole ne ya zama daidai da ɗayan ƙimar da aka yarda';
+        case 'exclusiveMaximum': return `dole ne ya zama ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `dole ne ya zama ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `dole ne ya dace da tsarin "${error.params.format}"`;
+        case 'if': return `dole ne ya dace da tsarin "${error.params.failingKeyword}"`;
+        case 'maxItems': return `kada ya kasance yana da fiye da abubuwa ${error.params.limit}`;
+        case 'maxLength': return `kada ya kasance yana da fiye da haruffa ${error.params.limit}`;
+        case 'maxProperties': return `kada ya kasance yana da fiye da kaddarori ${error.params.limit}`;
+        case 'maximum': return `dole ne ya zama ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `kada ya kasance yana da ƙasa da abubuwa ${error.params.limit}`;
+        case 'minLength': return `kada ya kasance yana da ƙasa da haruffa ${error.params.limit}`;
+        case 'minProperties': return `kada ya kasance yana da ƙasa da kaddarori ${error.params.limit}`;
+        case 'minimum': return `dole ne ya zama ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `dole ne ya zama ninki na ${error.params.multipleOf}`;
+        case 'not': return 'kada ya zama mai inganci';
+        case 'oneOf': return 'dole ne ya dace da tsari ɗaya kawai a cikin oneOf';
+        case 'pattern': return `dole ne ya dace da tsari "${error.params.pattern}"`;
+        case 'propertyNames': return `sunayen kaddarori ${error.params.propertyNames.join(', ')} ba su da inganci`;
+        case 'required': return `dole ne ya kasance yana da kaddarori masu mahimmanci ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `dole ne ya zama ${error.params.type}` : `dole ne ya zama ɗaya daga cikin ${error.params.type.join(' ko ')}`;
+        case 'unevaluatedItems': return 'kada ya kasance yana da abubuwan da ba a kimanta su ba';
+        case 'unevaluatedProperties': return 'kada ya kasance yana da kaddarorin da ba a kimanta su ba';
+        case 'uniqueItems': return `kada ya kasance yana da abubuwan da suka yi kama`;
+        case '~guard': return `dole ne ya dace da aikin duba`;
+        case '~refine': return error.params.message;
+        default: return 'an sami kuskuren tabbatarwa da ba a sani ba';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Hindi (India) - ISO 639-1 language code 'hi' with ISO 3166-1 alpha-2 country code 'IN' for India. */
+export declare function hi_IN(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Hindi (India) - ISO 639-1 language code 'hi' with ISO 3166-1 alpha-2 country code 'IN' for India. */
+export function hi_IN(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/hu_HU.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Hungarian (Hungary) - ISO 639-1 language code 'hu' with ISO 3166-1 alpha-2 country code 'HU' for Hungary. */
+export declare function hu_HU(error: TValidationError): string;

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

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Hungarian (Hungary) - ISO 639-1 language code 'hu' with ISO 3166-1 alpha-2 country code 'HU' for Hungary. */
+export function hu_HU(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'nem lehetnek további tulajdonságai';
+        case 'anyOf': return 'meg kell egyeznie az anyOf-ban található sémák egyikével';
+        case 'boolean': return 'a séma hamis';
+        case 'const': return 'egyenlőnek kell lennie az állandóval';
+        case 'contains': return 'legalább 1 érvényes elemet kell tartalmaznia';
+        case 'dependencies': return `rendelkeznie kell a(z) ${error.params.dependencies.join(', ')} tulajdonságokkal, ha a(z) ${error.params.property} tulajdonság jelen van`;
+        case 'dependentRequired': return `rendelkeznie kell a(z) ${error.params.dependencies.join(', ')} tulajdonságokkal, ha a(z) ${error.params.property} tulajdonság jelen van`;
+        case 'enum': return 'egyenlőnek kell lennie az engedélyezett értékek egyikével';
+        case 'exclusiveMaximum': return `${error.params.comparison} ${error.params.limit} kell lennie`;
+        case 'exclusiveMinimum': return `${error.params.comparison} ${error.params.limit} kell lennie`;
+        case 'format': return `meg kell egyeznie a(z) "${error.params.format}" formátummal`;
+        case 'if': return `meg kell egyeznie a(z) "${error.params.failingKeyword}" sémával`;
+        case 'maxItems': return `nem lehet több, mint ${error.params.limit} eleme`;
+        case 'maxLength': return `nem lehet több, mint ${error.params.limit} karaktere`;
+        case 'maxProperties': return `nem lehet több, mint ${error.params.limit} tulajdonsága`;
+        case 'maximum': return `${error.params.comparison} ${error.params.limit} kell lennie`;
+        case 'minItems': return `nem lehet kevesebb, mint ${error.params.limit} eleme`;
+        case 'minLength': return `nem lehet kevesebb, mint ${error.params.limit} karaktere`;
+        case 'minProperties': return `nem lehet kevesebb, mint ${error.params.limit} tulajdonsága`;
+        case 'minimum': return `${error.params.comparison} ${error.params.limit} kell lennie`;
+        case 'multipleOf': return `a(z) ${error.params.multipleOf} többszörösének kell lennie`;
+        case 'not': return 'nem lehet érvényes';
+        case 'oneOf': return 'pontosan egy sémának kell megfelelnie a oneOf-ban';
+        case 'pattern': return `meg kell egyeznie a(z) "${error.params.pattern}" mintával`;
+        case 'propertyNames': return `a tulajdonságnevek (${error.params.propertyNames.join(', ')}) érvénytelenek`;
+        case 'required': return `rendelkeznie kell a(z) ${error.params.requiredProperties.join(', ')} kötelező tulajdonságokkal`;
+        case 'type': return typeof error.params.type === 'string' ? `típusának ${error.params.type} kell lennie` : `típusának ${error.params.type.join(' vagy ')} kell lennie`;
+        case 'unevaluatedItems': return 'nem lehetnek nem értékelt elemei';
+        case 'unevaluatedProperties': return 'nem lehetnek nem értékelt tulajdonságai';
+        case 'uniqueItems': return `nem lehetnek ismétlődő elemei`;
+        case '~guard': return `meg kell felelnie az ellenőrző függvénynek`;
+        case '~refine': return error.params.message;
+        default: return 'ismeretlen validációs hiba történt';
+    }
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Indonesian (Indonesia) - ISO 639-1 language code 'id' with ISO 3166-1 alpha-2 country code 'ID' for Indonesia. */
+export declare function id_ID(error: TValidationError): string;