typebox 1.0.29 → 1.0.31

package/build/error/errors.d.mts

@@ -1,4 +1,4 @@
-export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBaseError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TGuardError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
 export declare function IsValidationError(value: unknown): value is TValidationError;
 export type TLocalizedValidationError = TValidationError & {
     message: string;
@@ -21,12 +21,6 @@ export interface TAnyOfError extends TValidationErrorBase {
     keyword: 'anyOf';
     params: {};
 }
-export interface TBaseError extends TValidationErrorBase {
-    keyword: '~base';
-    params: {
-        errors: object[];
-    };
-}
 export interface TBooleanError extends TValidationErrorBase {
     keyword: 'boolean';
     params: {};
@@ -84,6 +78,12 @@ export interface TFormatError extends TValidationErrorBase {
         format: string;
     };
 }
+export interface TGuardError extends TValidationErrorBase {
+    keyword: '~guard';
+    params: {
+        errors: object[];
+    };
+}
 export interface TIfError extends TValidationErrorBase {
     keyword: 'if';
     params: {

package/build/schema/engine/_guard.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildGuard(context: BuildContext, schema: S.XGuard, value: string): string;
+export declare function CheckGuard(context: CheckContext, schema: S.XGuard, value: unknown): boolean;
+export declare function ErrorGuard(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XGuard, value: unknown): boolean;

package/build/schema/engine/{_base.mjs → _guard.mjs}

@@ -4,23 +4,23 @@ import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildBase(context, schema, value) {
-    return E.Call(E.Member(E.Member(V.CreateExternalVariable(schema), '~base'), 'check'), [value]);
+export function BuildGuard(context, schema, value) {
+    return E.Call(E.Member(E.Member(V.CreateExternalVariable(schema), '~guard'), 'check'), [value]);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckBase(context, schema, value) {
-    return schema['~base'].check(value);
+export function CheckGuard(context, schema, value) {
+    return schema['~guard'].check(value);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorBase(context, schemaPath, instancePath, schema, value) {
-    return schema['~base'].check(value) || context.AddError({
-        keyword: '~base',
+export function ErrorGuard(context, schemaPath, instancePath, schema, value) {
+    return schema['~guard'].check(value) || context.AddError({
+        keyword: '~guard',
         schemaPath,
         instancePath,
-        params: { errors: schema['~base'].errors(value) },
+        params: { errors: schema['~guard'].errors(value) },
     });
 }

package/build/schema/engine/_refine.mjs

@@ -6,20 +6,20 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 export function BuildRefine(context, schema, value) {
     const refinements = V.CreateExternalVariable(schema['~refine'].map((refinement) => refinement));
-    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'callback'), [value]));
+    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'refine'), [value]));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRefine(context, schema, value) {
-    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.callback(value));
+    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.refine(value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorRefine(context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.callback(value) || context.AddError({
+        return refinement.refine(value) || context.AddError({
             keyword: '~refine',
             schemaPath,
             instancePath,

package/build/schema/engine/index.d.mts

@@ -2,7 +2,7 @@ export * from './_context.mjs';
 export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_externals.mjs';
-export * from './_base.mjs';
+export * from './_guard.mjs';
 export * from './_refine.mjs';
 export * from './additionalProperties.mjs';
 export * from './additionalItems.mjs';

package/build/schema/engine/index.mjs

@@ -8,7 +8,7 @@ export * from './_externals.mjs';
 // ------------------------------------------------------------------
 // Schematics
 // ------------------------------------------------------------------
-export * from './_base.mjs';
+export * from './_guard.mjs';
 export * from './_refine.mjs';
 export * from './additionalProperties.mjs';
 export * from './additionalItems.mjs';

package/build/schema/engine/schema.mjs

@@ -2,7 +2,7 @@
 import * as S from '../types/index.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildRefine, CheckRefine, ErrorRefine } from './_refine.mjs';
-import { BuildBase, CheckBase, ErrorBase } from './_base.mjs';
+import { BuildGuard, CheckGuard, ErrorGuard } from './_guard.mjs';
 import { BuildAdditionalItems, CheckAdditionalItems, ErrorAdditionalItems } from './additionalItems.mjs';
 import { BuildAdditionalProperties, CheckAdditionalProperties, ErrorAdditionalProperties } from './additionalProperties.mjs';
 import { BuildAllOf, CheckAllOf, ErrorAllOf } from './allOf.mjs';
@@ -204,8 +204,8 @@ export function BuildSchema(context, schema, value) {
     }
     if (S.IsRef(schema))
         conditions.push(BuildRef(context, schema, value));
-    if (S.IsBase(schema))
-        conditions.push(BuildBase(context, schema, value));
+    if (S.IsGuard(schema))
+        conditions.push(BuildGuard(context, schema, value));
     if (S.IsConst(schema))
         conditions.push(BuildConst(context, schema, value));
     if (S.IsEnum(schema))
@@ -262,7 +262,7 @@ export function CheckSchema(context, schema, value) {
             (!S.IsMinimum(schema) || CheckMinimum(context, schema, value)) &&
             (!S.IsMultipleOf(schema) || CheckMultipleOf(context, schema, value)))) &&
         (!S.IsRef(schema) || CheckRef(context, schema, value)) &&
-        (!S.IsBase(schema) || CheckBase(context, schema, value)) &&
+        (!S.IsGuard(schema) || CheckGuard(context, schema, value)) &&
         (!S.IsConst(schema) || CheckConst(context, schema, value)) &&
         (!S.IsEnum(schema) || CheckEnum(context, schema, value)) &&
         (!S.IsIf(schema) || CheckIf(context, schema, value)) &&
@@ -308,7 +308,7 @@ export function ErrorSchema(context, schemaPath, instancePath, schema, value) {
             +(!S.IsMinimum(schema) || ErrorMinimum(context, schemaPath, instancePath, schema, value)) &
             +(!S.IsMultipleOf(schema) || ErrorMultipleOf(context, schemaPath, instancePath, schema, value)))) &
         +(!S.IsRef(schema) || ErrorRef(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsBase(schema) || ErrorBase(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsGuard(schema) || ErrorGuard(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsConst(schema) || ErrorConst(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsEnum(schema) || ErrorEnum(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsIf(schema) || ErrorIf(context, schemaPath, instancePath, schema, value)) &

package/build/schema/types/_guard.d.mts

@@ -0,0 +1,10 @@
+import type { XSchema } from './schema.mjs';
+export interface XGuardInterface<Value extends unknown = unknown> {
+    check(value: unknown): value is Value;
+    errors(value: unknown): object[];
+}
+export interface XGuard<Value extends unknown = unknown> {
+    '~guard': XGuardInterface<Value>;
+}
+export declare function IsGuardInterface(value: unknown): value is XGuardInterface;
+export declare function IsGuard(value: XSchema): value is XGuard;

package/build/schema/types/{_base.mjs → _guard.mjs}

@@ -3,14 +3,14 @@ import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
-export function IsBaseValidator(value) {
+export function IsGuardInterface(value) {
     return Guard.IsObject(value)
         && Guard.HasPropertyKey(value, 'check')
         && Guard.HasPropertyKey(value, 'errors')
         && Guard.IsFunction(value.check)
         && Guard.IsFunction(value.errors);
 }
-export function IsBase(value) {
-    return Guard.HasPropertyKey(value, '~base')
-        && IsBaseValidator(value['~base']);
+export function IsGuard(value) {
+    return Guard.HasPropertyKey(value, '~guard')
+        && IsGuardInterface(value['~guard']);
 }

package/build/schema/types/_refine.d.mts

@@ -1,6 +1,6 @@
 import type { XSchema } from './schema.mjs';
 export interface XRefinement {
-    callback: (value: unknown) => boolean;
+    refine: (value: unknown) => boolean;
     message: string;
 }
 export interface XRefine<Refinements extends XRefinement[] = XRefinement[]> {

package/build/schema/types/_refine.mjs

@@ -11,8 +11,8 @@ export function IsRefine(value) {
     return Guard.HasPropertyKey(value, '~refine')
         && Guard.IsArray(value["~refine"])
         && Guard.Every(value['~refine'], 0, value => Guard.IsObject(value)
-            && Guard.HasPropertyKey(value, 'callback')
+            && Guard.HasPropertyKey(value, 'refine')
             && Guard.HasPropertyKey(value, 'message')
-            && Guard.IsFunction(value.callback)
+            && Guard.IsFunction(value.refine)
             && Guard.IsString(value.message));
 }

package/build/schema/types/index.d.mts

@@ -1,5 +1,5 @@
+export * from './_guard.mjs';
 export * from './_refine.mjs';
-export * from './_base.mjs';
 export * from './additionalProperties.mjs';
 export * from './additionalItems.mjs';
 export * from './allOf.mjs';

package/build/schema/types/index.mjs

@@ -1,8 +1,8 @@
 // ------------------------------------------------------------------
 // Extensions
 // ------------------------------------------------------------------
+export * from './_guard.mjs';
 export * from './_refine.mjs';
-export * from './_base.mjs';
 // ------------------------------------------------------------------
 // Standard
 // ------------------------------------------------------------------

package/build/schema/types/static.d.mts

@@ -1,4 +1,4 @@
-import type { XBase } from './_base.mjs';
+import type { XGuard } from './_guard.mjs';
 import type { XSchemaLike } from './schema.mjs';
 import type { XAdditionalProperties } from './additionalProperties.mjs';
 import type { XAnyOf } from './anyOf.mjs';
@@ -101,13 +101,13 @@ type XStaticEvaluate<Schema extends unknown, Result extends unknown = Schema ext
 } : Schema> = Result;
 type XStaticJsonSchema<Schema extends unknown, Keywords extends unknown[] = XStaticKeywords<Schema>, Intersect extends unknown = XStaticKeywordIntersect<Keywords>, Result extends unknown = XStaticEvaluate<Intersect>> = Result;
 /** Statically infers a JSON Schema or Validator */
-export type XStaticType<Schema extends XSchemaLike, Result extends unknown = (Schema extends XBase<infer Value> ? Value : XStaticJsonSchema<Schema>)> = Result;
+export type XStaticType<Schema extends XSchemaLike, Result extends unknown = (Schema extends XGuard<infer Value> ? Value : XStaticJsonSchema<Schema>)> = Result;
 type XStaticMutableTuple<Schemas extends readonly unknown[]> = (Schemas extends [infer Left, ...infer Right extends unknown[]] ? [XStaticMutable<Left>, ...XStaticMutableTuple<Right>] : []);
 type XStaticMutableArray<Schema extends unknown, Result extends unknown[] = XStaticMutable<Schema>[]> = Result;
 type XStaticMutableObject<Schema extends object, Result extends Record<PropertyKey, unknown> = {
     -readonly [K in keyof Schema]: XStaticMutable<Schema[K]>;
 }> = Result;
-type XStaticMutable<Schema> = (Schema extends XBase ? Schema : Schema extends readonly [...infer Schemas extends unknown[]] ? XStaticMutableTuple<Schemas> : Schema extends readonly (infer Schema)[] ? XStaticMutableArray<Schema> : Schema extends object ? XStaticMutableObject<Schema> : Schema);
+type XStaticMutable<Schema> = (Schema extends XGuard ? Schema : Schema extends readonly [...infer Schemas extends unknown[]] ? XStaticMutableTuple<Schemas> : Schema extends readonly (infer Schema)[] ? XStaticMutableArray<Schema> : Schema extends object ? XStaticMutableObject<Schema> : Schema);
 /** Statically infers a JSON Schema */
 export type XStatic<Schema extends XSchemaLike, Mutable extends XSchemaLike = XStaticMutable<Schema>, Result extends unknown = XStaticType<Mutable>> = Result;
 export {};

package/build/system/locale/ar_001.mjs

@@ -33,8 +33,8 @@ export function ar_001(error) {
         case 'unevaluatedItems': return 'يجب ألا يحتوي على عناصر غير مقيمة';
         case 'unevaluatedProperties': return 'يجب ألا يحتوي على خصائص غير مقيمة';
         case 'uniqueItems': return `يجب ألا يحتوي على عناصر مكررة`;
+        case '~guard': return `يجب أن يتطابق مع دالة الفحص`;
         case '~refine': return error.params.message;
-        case '~base': return `يجب أن يتطابق مع مخطط ${'Base'}`;
         default: return 'حدث خطأ غير معروف في التحقق من الصحة';
     }
 }

package/build/system/locale/bn_BD.mjs

@@ -33,8 +33,8 @@ export function bn_BD(error) {
         case 'unevaluatedItems': return 'অবমূল্যায়িত আইটেম থাকতে পারবে না';
         case 'unevaluatedProperties': return 'অবমূল্যায়িত বৈশিষ্ট্য থাকতে পারবে না';
         case 'uniqueItems': return `অনুলিপি আইটেম থাকতে পারবে না`;
+        case '~guard': return `চেক ফাংশনের সাথে মেলাতে হবে`;
         case '~refine': return error.params.message;
-        case '~base': return `${'Base'} স্কিমার সাথে মিলতে হবে`;
         default: return 'একটি অজানা বৈধকরণ ত্রুটি ঘটেছে';
     }
 }

package/build/system/locale/cs_CZ.mjs

@@ -33,8 +33,8 @@ export function cs_CZ(error) {
         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;
-        case '~base': return `musí odpovídat schématu ${'Base'}`;
         default: return 'došlo k neznámé chybě ověření';
     }
 }

package/build/system/locale/de_DE.mjs

@@ -33,8 +33,8 @@ export function de_DE(error) {
         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;
-        case '~base': return `muss mit dem ${'Base'}-Schema übereinstimmen`;
         default: return 'ein unbekannter Validierungsfehler ist aufgetreten';
     }
 }

package/build/system/locale/el_GR.mjs

@@ -33,8 +33,8 @@ export function el_GR(error) {
         case 'unevaluatedItems': return 'δεν πρέπει να έχει μη αξιολογημένα στοιχεία';
         case 'unevaluatedProperties': return 'δεν πρέπει να έχει μη αξιολογημένες ιδιότητες';
         case 'uniqueItems': return `δεν πρέπει να έχει διπλά στοιχεία`;
+        case '~guard': return `πρέπει να αντιστοιχεί στη συνάρτηση ελέγχου`;
         case '~refine': return error.params.message;
-        case '~base': return `πρέπει να ταιριάζει με το σχήμα ${'Base'}`;
         default: return 'προέκυψε ένα άγνωστο σφάλμα επικύρωσης';
     }
 }

package/build/system/locale/en_US.mjs

@@ -32,8 +32,8 @@ export function en_US(error) {
         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;
-        case '~base': return `must match against ${'Base'} schema`;
         // deno-coverage-ignore - unreachable
         default: return 'an unknown validation error occurred';
     }

package/build/system/locale/es_419.mjs

@@ -33,8 +33,8 @@ export function es_419(error) {
         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;
-        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ocurrió un error de validación desconocido';
     }
 }

package/build/system/locale/es_AR.mjs

@@ -33,8 +33,8 @@ export function es_AR(error) {
         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;
-        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ocurrió un error de validación desconocido';
     }
 }

package/build/system/locale/es_ES.mjs

@@ -33,8 +33,8 @@ export function es_ES(error) {
         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;
-        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ha ocurrido un error de validación desconocido';
     }
 }

package/build/system/locale/es_MX.mjs

@@ -33,8 +33,8 @@ export function es_MX(error) {
         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;
-        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ocurrió un error de validación desconocido';
     }
 }

package/build/system/locale/fa_IR.mjs

@@ -33,8 +33,8 @@ export function fa_IR(error) {
         case 'unevaluatedItems': return 'نباید آیتم‌های ارزیابی نشده داشته باشد';
         case 'unevaluatedProperties': return 'نباید ویژگی‌های ارزیابی نشده داشته باشد';
         case 'uniqueItems': return `نباید آیتم‌های تکراری داشته باشد`;
+        case '~guard': return `باید با تابع بررسی مطابقت داشته باشد`;
         case '~refine': return error.params.message;
-        case '~base': return `باید با طرح‌واره ${'Base'} مطابقت داشته باشد`;
         default: return 'یک خطای اعتبارسنجی ناشناخته رخ داده است';
     }
 }

package/build/system/locale/fil_PH.mjs

@@ -33,8 +33,8 @@ export function fil_PH(error) {
         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;
-        case '~base': return `dapat tumugma laban sa ${'Base'} schema`;
         default: return 'nagkaroon ng hindi kilalang error sa pagpapatunay';
     }
 }

package/build/system/locale/fr_CA.mjs

@@ -33,8 +33,8 @@ export function fr_CA(error) {
         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;
-        case '~base': return `doit correspondre au schéma ${'Base'}`;
         default: return 'une erreur de validation inconnue est survenue';
     }
 }

package/build/system/locale/fr_FR.mjs

@@ -33,8 +33,8 @@ export function fr_FR(error) {
         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;
-        case '~base': return `doit correspondre au schéma ${'Base'}`;
         default: return 'une erreur de validation inconnue est survenue';
     }
 }

package/build/system/locale/ha_NG.mjs

@@ -33,8 +33,8 @@ export function ha_NG(error) {
         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;
-        case '~base': return `dole ne ya dace da tsarin ${'Base'}`;
         default: return 'an sami kuskuren tabbatarwa da ba a sani ba';
     }
 }

package/build/system/locale/hi_IN.mjs

@@ -33,8 +33,8 @@ export function hi_IN(error) {
         case 'unevaluatedItems': return 'में अप्रयुक्त आइटम नहीं होने चाहिए';
         case 'unevaluatedProperties': return 'में अप्रयुक्त गुण नहीं होने चाहिए';
         case 'uniqueItems': return `में डुप्लिकेट आइटम नहीं होने चाहिए`;
+        case '~guard': return `चेक फ़ंक्शन से मेल खाना चाहिए`;
         case '~refine': return error.params.message;
-        case '~base': return `${'Base'} स्कीमा के विरुद्ध मेल खाना चाहिए`;
         default: return 'एक अज्ञात सत्यापन त्रुटि हुई';
     }
 }

package/build/system/locale/hu_HU.mjs

@@ -33,8 +33,8 @@ export function hu_HU(error) {
         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;
-        case '~base': return `meg kell egyeznie a(z) ${'Base'} sémával`;
         default: return 'ismeretlen validációs hiba történt';
     }
 }

package/build/system/locale/id_ID.mjs

@@ -33,8 +33,8 @@ export function id_ID(error) {
         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;
-        case '~base': return `harus cocok dengan skema ${'Base'}`;
         default: return 'terjadi kesalahan validasi yang tidak diketahui';
     }
 }

package/build/system/locale/it_IT.mjs

@@ -33,8 +33,8 @@ export function it_IT(error) {
         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;
-        case '~base': return `deve corrispondere allo schema ${'Base'}`;
         default: return 'si è verificato un errore di validazione sconosciuto';
     }
 }

package/build/system/locale/ja_JP.mjs

@@ -33,8 +33,8 @@ export function ja_JP(error) {
         case 'unevaluatedItems': return '未評価のアイテムを持つことはできません';
         case 'unevaluatedProperties': return '未評価のプロパティを持つことはできません';
         case 'uniqueItems': return `重複するアイテムを持つことはできません`;
+        case '~guard': return `チェック関数と一致する必要があります`;
         case '~refine': return error.params.message;
-        case '~base': return `${'Base'} スキーマと一致する必要があります`;
         default: return '不明なバリデーションエラーが発生しました';
     }
 }

package/build/system/locale/ko_KR.mjs

@@ -33,8 +33,8 @@ export function ko_KR(error) {
         case 'unevaluatedItems': return '평가되지 않은 항목을 가질 수 없습니다';
         case 'unevaluatedProperties': return '평가되지 않은 속성을 가질 수 없습니다';
         case 'uniqueItems': return `중복 항목을 가질 수 없습니다`;
+        case '~guard': return `체크 함수와 일치해야 합니다`;
         case '~refine': return error.params.message;
-        case '~base': return `${'Base'} 스키마와 일치해야 합니다`;
         default: return '알 수 없는 유효성 검사 오류가 발생했습니다';
     }
 }

package/build/system/locale/ms_MY.mjs

@@ -33,8 +33,8 @@ export function ms_MY(error) {
         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;
-        case '~base': return `mesti sepadan dengan skema ${'Base'}`;
         default: return 'ralat pengesahan yang tidak diketahui berlaku';
     }
 }

package/build/system/locale/nl_NL.mjs

@@ -33,8 +33,8 @@ export function nl_NL(error) {
         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;
-        case '~base': return `moet overeenkomen met ${'Base'} schema`;
         default: return 'er is een onbekende validatiefout opgetreden';
     }
 }

package/build/system/locale/pl_PL.mjs

@@ -33,8 +33,8 @@ export function pl_PL(error) {
         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;
-        case '~base': return `musi pasować do schematu ${'Base'}`;
         default: return 'wystąpił nieznany błąd walidacji';
     }
 }

package/build/system/locale/pt_BR.mjs

@@ -33,8 +33,8 @@ export function pt_BR(error) {
         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;
-        case '~base': return `deve corresponder ao esquema ${'Base'}`;
         default: return 'ocorreu um erro de validação desconhecido';
     }
 }

package/build/system/locale/pt_PT.mjs

@@ -33,8 +33,8 @@ export function pt_PT(error) {
         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;
-        case '~base': return `deve corresponder ao esquema ${'Base'}`;
         default: return 'ocorreu um erro de validação desconhecido';
     }
 }

package/build/system/locale/ro_RO.mjs

@@ -33,8 +33,8 @@ export function ro_RO(error) {
         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;
-        case '~base': return `trebuie să se potrivească cu schema ${'Base'}`;
         default: return 'a apărut o eroare de validare necunoscută';
     }
 }

package/build/system/locale/ru_RU.mjs

@@ -33,8 +33,8 @@ export function ru_RU(error) {
         case 'unevaluatedItems': return 'не должно быть нерассмотренных элементов';
         case 'unevaluatedProperties': return 'не должно быть нерассмотренных свойств';
         case 'uniqueItems': return `не должно быть повторяющихся элементов`;
+        case '~guard': return `должно соответствовать проверочной функции`;
         case '~refine': return error.params.message;
-        case '~base': return `должен соответствовать схеме ${'Base'}`;
         default: return 'произошла неизвестная ошибка валидации';
     }
 }

package/build/system/locale/sv_SE.mjs

@@ -33,8 +33,8 @@ export function sv_SE(error) {
         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;
-        case '~base': return `måste matcha mot ${'Base'} schema`;
         default: return 'ett okänt valideringsfel uppstod';
     }
 }

package/build/system/locale/sw_TZ.mjs

@@ -33,8 +33,8 @@ export function sw_TZ(error) {
         case 'unevaluatedItems': return 'haipaswi kuwa na vitu visivyotathminiwa';
         case 'unevaluatedProperties': return 'haipaswi kuwa na sifa zisizotathminiwa';
         case 'uniqueItems': return `haipaswi kuwa na vitu vilivyofanana`;
+        case '~guard': return `inapaswa kulingana na kipengele cha ukaguzi`;
         case '~refine': return error.params.message;
-        case '~base': return `lazima ilingane na schema ya ${'Base'}`;
         default: return 'hitilafu isiyojulikana ya uthibitishaji imetokea';
     }
 }

package/build/system/locale/th_TH.mjs

@@ -33,8 +33,8 @@ export function th_TH(error) {
         case 'unevaluatedItems': return 'ต้องไม่มีรายการที่ยังไม่ได้ประเมิน';
         case 'unevaluatedProperties': return 'ต้องไม่มีคุณสมบัติที่ยังไม่ได้ประเมิน';
         case 'uniqueItems': return `ต้องไม่มีรายการที่ซ้ำกัน`;
+        case '~guard': return `ต้องตรงกับฟังก์ชันตรวจสอบ`;
         case '~refine': return error.params.message;
-        case '~base': return `ต้องตรงกับ Schema ของ ${'Base'}`;
         default: return 'เกิดข้อผิดพลาดในการตรวจสอบที่ไม่รู้จัก';
     }
 }

package/build/system/locale/tr_TR.mjs

@@ -33,8 +33,8 @@ export function tr_TR(error) {
         case 'unevaluatedItems': return 'değerlendirilmemiş öğelere sahip olmamalıdır';
         case 'unevaluatedProperties': return 'değerlendirilmemiş özelliklere sahip olmamalıdır';
         case 'uniqueItems': return `yinelenen öğelere sahip olmamalıdır`;
+        case '~guard': return `kontrol fonksiyonuyla eşleşmelidir`;
         case '~refine': return error.params.message;
-        case '~base': return `${'Base'} şemasına göre eşleşmelidir`;
         default: return 'bilinmeyen bir doğrulama hatası oluştu';
     }
 }

package/build/system/locale/uk_UA.mjs

@@ -33,8 +33,8 @@ export function uk_UA(error) {
         case 'unevaluatedItems': return 'не повинно мати неперевірених елементів';
         case 'unevaluatedProperties': return 'не повинно мати неперевірених властивостей';
         case 'uniqueItems': return `не повинно мати повторюваних елементів`;
+        case '~guard': return `повинно відповідати функції перевірки`;
         case '~refine': return error.params.message;
-        case '~base': return `має відповідати схемі ${'Base'}`;
         default: return 'виникла невідома помилка валідації';
     }
 }

package/build/system/locale/ur_PK.mjs

@@ -33,8 +33,8 @@ export function ur_PK(error) {
         case 'unevaluatedItems': return 'غیر تشخیص شدہ آئٹمز نہیں ہونے چاہئیں';
         case 'unevaluatedProperties': return 'غیر تشخیص شدہ خصوصیات نہیں ہونی چاہئیں';
         case 'uniqueItems': return `ڈپلیکیٹ آئٹمز نہیں ہونے چاہئیں`;
+        case '~guard': return `چیک فنکشن سے مطابقت ہونی چاہیے`;
         case '~refine': return error.params.message;
-        case '~base': return `${'Base'} اسکیما سے مماثل ہونا چاہیے`;
         default: return 'تصدیق میں ایک نامعلوم خرابی پیش آئی';
     }
 }

package/build/system/locale/vi_VN.mjs

@@ -33,8 +33,8 @@ export function vi_VN(error) {
         case 'unevaluatedItems': return 'không được có các mục chưa được đánh giá';
         case 'unevaluatedProperties': return 'không được có các thuộc tính chưa được đánh giá';
         case 'uniqueItems': return `không được có các mục trùng lặp`;
+        case '~guard': return `phải khớp với hàm kiểm tra`;
         case '~refine': return error.params.message;
-        case '~base': return `phải khớp với schema ${'Base'}`;
         default: return 'đã xảy ra lỗi xác thực không xác định';
     }
 }

package/build/system/locale/yo_NG.mjs

@@ -33,8 +33,8 @@ export function yo_NG(error) {
         case 'unevaluatedItems': return 'ko gbọdọ ni awọn ohun ti ko ṣe iṣiro';
         case 'unevaluatedProperties': return 'ko gbọdọ ni awọn ohun-ini ti ko ṣe iṣiro';
         case 'uniqueItems': return `ko gbọdọ ni awọn ohun elo ẹda`;
+        case '~guard': return `gbogbo yẹ ki o ba iṣẹ́ ṣàyẹ̀wò mu`;
         case '~refine': return error.params.message;
-        case '~base': return `gbọdọ baramu àlàyé ${'Base'}`;
         default: return 'aṣiṣe ijẹrisi aimọ waye';
     }
 }

package/build/system/locale/zh_Hans.mjs

@@ -33,8 +33,8 @@ export function zh_Hans(error) {
         case 'unevaluatedItems': return '不得有未评估的项';
         case 'unevaluatedProperties': return '不得有未评估的属性';
         case 'uniqueItems': return `不得有重复项`;
+        case '~guard': return `必须与检查函数匹配`;
         case '~refine': return error.params.message;
-        case '~base': return `必须匹配 ${'Base'} 模式`;
         default: return '发生未知验证错误';
     }
 }

package/build/system/locale/zh_Hant.mjs

@@ -33,8 +33,8 @@ export function zh_Hant(error) {
         case 'unevaluatedItems': return '不得有未評估的項目';
         case 'unevaluatedProperties': return '不得有未評估的屬性';
         case 'uniqueItems': return `不得有重複項目`;
+        case '~guard': return `必須與檢查函數匹配`;
         case '~refine': return error.params.message;
-        case '~base': return `必須匹配 ${'Base'} 模式`;
         default: return '發生未知驗證錯誤';
     }
 }

package/build/system/memory/clone.mjs

@@ -2,12 +2,12 @@
 import { Guard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
 // ------------------------------------------------------------------
-// Base
+// Guard
 // ------------------------------------------------------------------
-function IsBase(value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~base');
+function IsGuard(value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~guard');
 }
-function FromBase(value) {
+function FromGuard(value) {
     return value; // non-clonable
 }
 // ------------------------------------------------------------------
@@ -47,7 +47,7 @@ function FromUnknown(value) {
 // ------------------------------------------------------------------
 function FromValue(value) {
     return (value instanceof RegExp ? FromRegExp(value) :
-        IsBase(value) ? FromBase(value) :
+        IsGuard(value) ? FromGuard(value) :
             Guard.IsArray(value) ? FromArray(value) :
                 Guard.IsObject(value) ? FromObject(value) :
                     FromUnknown(value));

package/build/type/types/_refine.d.mts

@@ -10,10 +10,10 @@ export type TRefine<Type extends TSchema = TSchema> = (Type & {
 });
 export type TRefineCallback<Type extends TSchema> = (value: Static<Type>) => boolean;
 export interface TRefinement<Type extends TSchema = TSchema> {
-    callback: TRefineCallback<Type>;
+    refine: TRefineCallback<Type>;
     message: string;
 }
 /** Applies a Refine check to the given type. */
-export declare function Refine<Type extends TSchema>(type: Type, callback: TRefineCallback<Type>, message?: string): TRefineAdd<Type>;
+export declare function Refine<Type extends TSchema>(type: Type, refine: TRefineCallback<Type>, message?: string): TRefineAdd<Type>;
 /** Returns true if the given value is a TRefine. */
 export declare function IsRefine(value: unknown): value is TRefine<TSchema>;

package/build/type/types/_refine.mjs

@@ -8,8 +8,8 @@ export function RefineAdd(type, refinement) {
     return Memory.Update(type, {}, { '~refine': refinements });
 }
 /** Applies a Refine check to the given type. */
-export function Refine(type, callback, message = 'error') {
-    return RefineAdd(type, { callback, message });
+export function Refine(type, refine, message = 'error') {
+    return RefineAdd(type, { refine, message });
 }
 // ------------------------------------------------------------------
 // Guard

package/build/type/types/base.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from './schema.mjs';
-import { type XBase, type XBaseValidator } from '../../schema/types/index.mjs';
-export declare class BaseNotImplemented extends Error {
+import { type XGuard, type XGuardInterface } from '../../schema/types/index.mjs';
+export declare class NotImplemented extends Error {
     readonly cause: {
         type: Base;
         method: string;
@@ -8,9 +8,9 @@ export declare class BaseNotImplemented extends Error {
     constructor(type: Base, method: string);
 }
 /** Base class for creating extension types. */
-export declare class Base<Value extends unknown = unknown> implements TSchema, XBase<Value> {
+export declare class Base<Value extends unknown = unknown> implements TSchema, XGuard<Value> {
     readonly '~kind': 'Base';
-    readonly '~base': BaseValidator<Value>;
+    readonly '~guard': XGuardInterface<Value>;
     constructor();
     /** Checks a value or returns false if invalid */
     Check(value: unknown): value is Value;
@@ -27,9 +27,3 @@ export declare class Base<Value extends unknown = unknown> implements TSchema, X
 }
 /** Returns true if the given value is a Base type. */
 export declare function IsBase(value: unknown): value is Base;
-declare class BaseValidator<Value extends unknown = unknown> implements XBaseValidator<Value> {
-    readonly check: (value: unknown) => value is Value;
-    readonly errors: (value: unknown) => object[];
-    constructor(check: (value: unknown) => value is Value, errors: (value: unknown) => object[]);
-}
-export {};

package/build/type/types/base.mjs

@@ -1,9 +1,10 @@
 // deno-fmt-ignore-file
+import { Settings } from '../../system/settings/index.mjs';
 import { IsKind } from './schema.mjs';
 // ------------------------------------------------------------------
-// BaseNotImplemented
+// NotImplemented
 // ------------------------------------------------------------------
-export class BaseNotImplemented extends Error {
+export class NotImplemented extends Error {
     constructor(type, method) {
         super(`Base type does not implement the '${method}' function`);
         Object.defineProperty(this, 'cause', {
@@ -20,14 +21,16 @@ export class BaseNotImplemented extends Error {
 /** Base class for creating extension types. */
 export class Base {
     constructor() {
-        const validator = new BaseValidator((value) => this.Check(value), (value) => this.Errors(value));
-        const configuration = {
+        Object.defineProperty(this, '~kind', {
+            enumerable: Settings.Get().enumerableKind,
             writable: false,
             configurable: false,
-            enumerable: false
+            value: 'Base'
+        });
+        this['~guard'] = {
+            check: (value) => this.Check(value),
+            errors: (value) => this.Errors(value)
         };
-        Object.defineProperty(this, '~kind', { ...configuration, value: 'Base' });
-        Object.defineProperty(this, '~base', { ...configuration, value: validator });
     }
     /** Checks a value or returns false if invalid */
     Check(value) {
@@ -51,7 +54,7 @@ export class Base {
     }
     /** Creates a new instance of this type */
     Create() {
-        throw new BaseNotImplemented(this, 'Create');
+        throw new NotImplemented(this, 'Create');
     }
 }
 // ------------------------------------------------------------------
@@ -61,12 +64,3 @@ export class Base {
 export function IsBase(value) {
     return IsKind(value, 'Base');
 }
-// ------------------------------------------------------------------
-// BaseValidator
-// ------------------------------------------------------------------
-class BaseValidator {
-    constructor(check, errors) {
-        this.check = check;
-        this.errors = errors;
-    }
-}

package/build/type/types/schema.d.mts

@@ -152,7 +152,7 @@ export interface TNumberOptions extends TSchemaOptions {
      */
     multipleOf?: number | bigint;
 }
-export type TFormat = 'base64' | 'date-time' | 'date' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri-reference' | 'iri' | 'json-pointer-uri-fragment' | 'json-pointer' | 'json-string' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | ({} & string);
+export type TFormat = 'date-time' | 'date' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri-reference' | 'iri' | 'json-pointer-uri-fragment' | 'json-pointer' | 'json-string' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | ({} & string);
 export interface TStringOptions extends TSchemaOptions {
     /**
      * Specifies the expected string format.

package/build/value/repair/from-base.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, Base } from '../../type/index.mjs';
+export declare function FromBase(context: TProperties, type: Base, value: unknown): unknown;

package/build/value/repair/from-base.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromUnknown } from './from-unknown.mjs';
+// ------------------------------------------------------------------
+// FromBase
+// ------------------------------------------------------------------
+export function FromBase(context, type, value) {
+    return FromUnknown(context, type, value);
+}

package/build/value/repair/from-type.mjs

@@ -2,6 +2,7 @@
 import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 import * as T from '../../type/index.mjs';
 import { FromArray } from './from-array.mjs';
+import { FromBase } from './from-base.mjs';
 import { FromEnum } from './from-enum.mjs';
 import { FromIntersect } from './from-intersect.mjs';
 import { FromObject } from './from-object.mjs';
@@ -44,6 +45,10 @@ function AssertRepairableType(context, type, value) {
 // FromType
 // ------------------------------------------------------------------
 export function FromType(context, type, value) {
+    // Intercept Base
+    if (T.IsBase(type))
+        return FromBase(context, type, value);
+    // Standard Repair
     AssertRepairableValue(context, type, value);
     AssertRepairableType(context, type, value);
     return (T.IsArray(type) ? FromArray(context, type, value) :

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "keywords": [
     "typescript",
     "jsonschema"

package/build/schema/engine/_base.d.mts

@@ -1,5 +0,0 @@
-import * as S from '../types/index.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildBase(context: BuildContext, schema: S.XBase, value: string): string;
-export declare function CheckBase(context: CheckContext, schema: S.XBase, value: unknown): boolean;
-export declare function ErrorBase(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XBase, value: unknown): boolean;

package/build/schema/types/_base.d.mts

@@ -1,10 +0,0 @@
-import type { XSchema } from './schema.mjs';
-export interface XBaseValidator<Value extends unknown = unknown> {
-    check(value: unknown): value is Value;
-    errors(value: unknown): object[];
-}
-export interface XBase<Value extends unknown = unknown> {
-    '~base': XBaseValidator<Value>;
-}
-export declare function IsBaseValidator(value: unknown): value is XBaseValidator;
-export declare function IsBase(value: XSchema): value is XBase;