typebox 1.0.27 → 1.0.29

package/build/error/errors.d.mts

@@ -1,4 +1,4 @@
-export type TValidationError = TAdditionalPropertiesError | TAnyOfError | 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 | TStandardSchemaV1Error | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+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 declare function IsValidationError(value: unknown): value is TValidationError;
 export type TLocalizedValidationError = TValidationError & {
     message: string;
@@ -21,6 +21,12 @@ 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: {};
@@ -182,16 +188,6 @@ export interface TRequiredError extends TValidationErrorBase {
         requiredProperties: string[];
     };
 }
-export interface TStandardSchemaV1Error extends TValidationErrorBase {
-    keyword: '~standard';
-    params: {
-        vendor: string;
-        issues: {
-            message: string;
-            path?: string[];
-        }[];
-    };
-}
 export interface TTypeError extends TValidationErrorBase {
     keyword: 'type';
     params: {

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

@@ -0,0 +1,5 @@
+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/engine/_base.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+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]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckBase(context, schema, value) {
+    return schema['~base'].check(value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorBase(context, schemaPath, instancePath, schema, value) {
+    return schema['~base'].check(value) || context.AddError({
+        keyword: '~base',
+        schemaPath,
+        instancePath,
+        params: { errors: schema['~base'].errors(value) },
+    });
+}

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

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

package/build/schema/engine/index.mjs

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

package/build/schema/engine/schema.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import * as S from '../types/index.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildStandardSchemaV1, CheckStandardSchemaV1, ErrorStandardSchemaV1 } from './_standard.mjs';
 import { BuildRefine, CheckRefine, ErrorRefine } from './_refine.mjs';
+import { BuildBase, CheckBase, ErrorBase } from './_base.mjs';
 import { BuildAdditionalItems, CheckAdditionalItems, ErrorAdditionalItems } from './additionalItems.mjs';
 import { BuildAdditionalProperties, CheckAdditionalProperties, ErrorAdditionalProperties } from './additionalProperties.mjs';
 import { BuildAllOf, CheckAllOf, ErrorAllOf } from './allOf.mjs';
@@ -204,12 +204,12 @@ 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.IsConst(schema))
         conditions.push(BuildConst(context, schema, value));
     if (S.IsEnum(schema))
         conditions.push(BuildEnum(context, schema, value));
-    if (S.IsStandardSchemaV1(schema))
-        conditions.push(BuildStandardSchemaV1(context, schema, value));
     if (S.IsIf(schema))
         conditions.push(BuildIf(context, schema, value));
     if (S.IsNot(schema))
@@ -262,9 +262,9 @@ 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.IsConst(schema) || CheckConst(context, schema, value)) &&
         (!S.IsEnum(schema) || CheckEnum(context, schema, value)) &&
-        (!S.IsStandardSchemaV1(schema) || CheckStandardSchemaV1(context, schema, value)) &&
         (!S.IsIf(schema) || CheckIf(context, schema, value)) &&
         (!S.IsNot(schema) || CheckNot(context, schema, value)) &&
         (!S.IsAllOf(schema) || CheckAllOf(context, schema, value)) &&
@@ -308,9 +308,9 @@ 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.IsConst(schema) || ErrorConst(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsEnum(schema) || ErrorEnum(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsStandardSchemaV1(schema) || ErrorStandardSchemaV1(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsIf(schema) || ErrorIf(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsNot(schema) || ErrorNot(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsAllOf(schema) || ErrorAllOf(context, schemaPath, instancePath, schema, value)) &

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

@@ -0,0 +1,10 @@
+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;

package/build/schema/types/_base.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsBaseValidator(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']);
+}

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

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

package/build/schema/types/index.mjs

@@ -2,7 +2,7 @@
 // Extensions
 // ------------------------------------------------------------------
 export * from './_refine.mjs';
-export * from './_standard.mjs';
+export * from './_base.mjs';
 // ------------------------------------------------------------------
 // Standard
 // ------------------------------------------------------------------

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

@@ -1,5 +1,5 @@
-import type { XSchemaLike } from '../types/schema.mjs';
-import type { XStandardSchemaV1, XStandardValidatorV1 } from './_standard.mjs';
+import type { XBase } from './_base.mjs';
+import type { XSchemaLike } from './schema.mjs';
 import type { XAdditionalProperties } from './additionalProperties.mjs';
 import type { XAnyOf } from './anyOf.mjs';
 import type { XAllOf } from './allOf.mjs';
@@ -11,11 +11,7 @@ import type { XPatternProperties } from './patternProperties.mjs';
 import type { XPrefixItems } from './prefixItems.mjs';
 import type { XProperties } from './properties.mjs';
 import type { XRequired } from './required.mjs';
-export type XStaticStandardSchemaV1<Validator extends XStandardValidatorV1, ValidateResult extends unknown = ReturnType<Validator['validate']>, RemoveAsync extends unknown = Exclude<ValidateResult, Promise<any>>, RemoveIssue extends unknown = Exclude<RemoveAsync, {
-    issues: any;
-}>, Result extends unknown = RemoveIssue extends {
-    value: infer Value;
-} ? Value : unknown> = Result;
+export type XStaticBase<Value extends unknown> = Value;
 type XStaticAdditionalProperties<Schema extends XSchemaLike, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
     [key: string]: unknown;
 } : Schema extends false ? {} : {
@@ -104,14 +100,14 @@ type XStaticEvaluate<Schema extends unknown, Result extends unknown = Schema ext
     [Key in keyof Schema]: Schema[Key];
 } : 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 Standard Schema */
-export type XStaticType<Schema extends XSchemaLike, Result extends unknown = (Schema extends XStandardSchemaV1<infer Validator extends XStandardValidatorV1> ? XStaticStandardSchemaV1<Validator> : XStaticJsonSchema<Schema>)> = 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;
 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 XStandardSchemaV1 ? 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 or Standard Schema */
+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);
+/** 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

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

package/build/system/locale/bn_BD.mjs

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

package/build/system/locale/cs_CZ.mjs

@@ -34,7 +34,7 @@ export function cs_CZ(error) {
         case 'unevaluatedProperties': return 'nesmí mít nevyhodnocené vlastnosti';
         case 'uniqueItems': return `nesmí mít duplicitní položky`;
         case '~refine': return error.params.message;
-        case '~standard': return `musí odpovídat schématu ${error.params.vendor}`;
+        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

@@ -34,7 +34,7 @@ export function de_DE(error) {
         case 'unevaluatedProperties': return 'darf keine unbewerteten Eigenschaften haben';
         case 'uniqueItems': return `darf keine doppelten Elemente haben`;
         case '~refine': return error.params.message;
-        case '~standard': return `muss mit dem ${error.params.vendor}-Schema übereinstimmen`;
+        case '~base': return `muss mit dem ${'Base'}-Schema übereinstimmen`;
         default: return 'ein unbekannter Validierungsfehler ist aufgetreten';
     }
 }

package/build/system/locale/el_GR.mjs

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

package/build/system/locale/en_US.mjs

@@ -33,7 +33,7 @@ export function en_US(error) {
         case 'unevaluatedProperties': return 'must not have unevaluated properties';
         case 'uniqueItems': return `must not have duplicate items`;
         case '~refine': return error.params.message;
-        case '~standard': return `must match against ${error.params.vendor} schema`;
+        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

@@ -34,7 +34,7 @@ export function es_419(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        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

@@ -34,7 +34,7 @@ export function es_AR(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        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

@@ -34,7 +34,7 @@ export function es_ES(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        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

@@ -34,7 +34,7 @@ export function es_MX(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        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

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

package/build/system/locale/fil_PH.mjs

@@ -34,7 +34,7 @@ export function fil_PH(error) {
         case 'unevaluatedProperties': return 'hindi dapat magkaroon ng mga hindi pa nasusuring katangian';
         case 'uniqueItems': return `hindi dapat magkaroon ng mga duplicate na item`;
         case '~refine': return error.params.message;
-        case '~standard': return `dapat tumugma laban sa ${error.params.vendor} schema`;
+        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

@@ -34,7 +34,7 @@ export function fr_CA(error) {
         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 '~refine': return error.params.message;
-        case '~standard': return `doit correspondre au schéma ${error.params.vendor}`;
+        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

@@ -34,7 +34,7 @@ export function fr_FR(error) {
         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 '~refine': return error.params.message;
-        case '~standard': return `doit correspondre au schéma ${error.params.vendor}`;
+        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

@@ -34,7 +34,7 @@ export function ha_NG(error) {
         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 '~refine': return error.params.message;
-        case '~standard': return `dole ne ya dace da tsarin ${error.params.vendor}`;
+        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

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

package/build/system/locale/hu_HU.mjs

@@ -34,7 +34,7 @@ export function hu_HU(error) {
         case 'unevaluatedProperties': return 'nem lehetnek nem értékelt tulajdonságai';
         case 'uniqueItems': return `nem lehetnek ismétlődő elemei`;
         case '~refine': return error.params.message;
-        case '~standard': return `meg kell egyeznie a(z) ${error.params.vendor} sémával`;
+        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

@@ -34,7 +34,7 @@ export function id_ID(error) {
         case 'unevaluatedProperties': return 'tidak boleh memiliki properti yang belum dievaluasi';
         case 'uniqueItems': return `tidak boleh memiliki item duplikat`;
         case '~refine': return error.params.message;
-        case '~standard': return `harus cocok dengan skema ${error.params.vendor}`;
+        case '~base': return `harus cocok dengan skema ${'Base'}`;
         default: return 'terjadi kesalahan validasi yang tidak diketahui';
     }
 }

package/build/system/locale/it_IT.mjs

@@ -34,7 +34,7 @@ export function it_IT(error) {
         case 'unevaluatedProperties': return 'non deve avere proprietà non valutate';
         case 'uniqueItems': return `non deve avere elementi duplicati`;
         case '~refine': return error.params.message;
-        case '~standard': return `deve corrispondere allo schema ${error.params.vendor}`;
+        case '~base': return `deve corrispondere allo schema ${'Base'}`;
         default: return 'si è verificato un errore di validazione sconosciuto';
     }
 }

package/build/system/locale/ja_JP.mjs

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

package/build/system/locale/ko_KR.mjs

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

package/build/system/locale/ms_MY.mjs

@@ -34,7 +34,7 @@ export function ms_MY(error) {
         case 'unevaluatedProperties': return 'tidak boleh mempunyai sifat yang tidak dinilai';
         case 'uniqueItems': return `tidak boleh mempunyai item pendua`;
         case '~refine': return error.params.message;
-        case '~standard': return `mesti sepadan dengan skema ${error.params.vendor}`;
+        case '~base': return `mesti sepadan dengan skema ${'Base'}`;
         default: return 'ralat pengesahan yang tidak diketahui berlaku';
     }
 }

package/build/system/locale/nl_NL.mjs

@@ -34,7 +34,7 @@ export function nl_NL(error) {
         case 'unevaluatedProperties': return 'mag geen onbeoordeelde eigenschappen hebben';
         case 'uniqueItems': return `mag geen dubbele items hebben`;
         case '~refine': return error.params.message;
-        case '~standard': return `moet overeenkomen met ${error.params.vendor} schema`;
+        case '~base': return `moet overeenkomen met ${'Base'} schema`;
         default: return 'er is een onbekende validatiefout opgetreden';
     }
 }

package/build/system/locale/pl_PL.mjs

@@ -34,7 +34,7 @@ export function pl_PL(error) {
         case 'unevaluatedProperties': return 'nie może mieć nieewaluowanych właściwości';
         case 'uniqueItems': return `nie może zawierać zduplikowanych elementów`;
         case '~refine': return error.params.message;
-        case '~standard': return `musi pasować do schematu ${error.params.vendor}`;
+        case '~base': return `musi pasować do schematu ${'Base'}`;
         default: return 'wystąpił nieznany błąd walidacji';
     }
 }

package/build/system/locale/pt_BR.mjs

@@ -34,7 +34,7 @@ export function pt_BR(error) {
         case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
         case 'uniqueItems': return `não deve ter itens duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `deve corresponder ao esquema ${error.params.vendor}`;
+        case '~base': return `deve corresponder ao esquema ${'Base'}`;
         default: return 'ocorreu um erro de validação desconhecido';
     }
 }

package/build/system/locale/pt_PT.mjs

@@ -34,7 +34,7 @@ export function pt_PT(error) {
         case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
         case 'uniqueItems': return `não deve ter itens duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `deve corresponder ao esquema ${error.params.vendor}`;
+        case '~base': return `deve corresponder ao esquema ${'Base'}`;
         default: return 'ocorreu um erro de validação desconhecido';
     }
 }

package/build/system/locale/ro_RO.mjs

@@ -34,7 +34,7 @@ export function ro_RO(error) {
         case 'unevaluatedProperties': return 'nu trebuie să aibă proprietăți neevaluate';
         case 'uniqueItems': return `nu trebuie să aibă elemente duplicate`;
         case '~refine': return error.params.message;
-        case '~standard': return `trebuie să se potrivească cu schema ${error.params.vendor}`;
+        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

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

package/build/system/locale/sv_SE.mjs

@@ -34,7 +34,7 @@ export function sv_SE(error) {
         case 'unevaluatedProperties': return 'får inte ha oidentifierade egenskaper';
         case 'uniqueItems': return `får inte ha dubbletter`;
         case '~refine': return error.params.message;
-        case '~standard': return `måste matcha mot ${error.params.vendor} schema`;
+        case '~base': return `måste matcha mot ${'Base'} schema`;
         default: return 'ett okänt valideringsfel uppstod';
     }
 }

package/build/system/locale/sw_TZ.mjs

@@ -34,7 +34,7 @@ export function sw_TZ(error) {
         case 'unevaluatedProperties': return 'haipaswi kuwa na sifa zisizotathminiwa';
         case 'uniqueItems': return `haipaswi kuwa na vitu vilivyofanana`;
         case '~refine': return error.params.message;
-        case '~standard': return `lazima ilingane na schema ya ${error.params.vendor}`;
+        case '~base': return `lazima ilingane na schema ya ${'Base'}`;
         default: return 'hitilafu isiyojulikana ya uthibitishaji imetokea';
     }
 }

package/build/system/locale/th_TH.mjs

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

package/build/system/locale/tr_TR.mjs

@@ -34,7 +34,7 @@ export function tr_TR(error) {
         case 'unevaluatedProperties': return 'değerlendirilmemiş özelliklere sahip olmamalıdır';
         case 'uniqueItems': return `yinelenen öğelere sahip olmamalıdır`;
         case '~refine': return error.params.message;
-        case '~standard': return `${error.params.vendor} şemasına göre eşleşmelidir`;
+        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

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

package/build/system/locale/ur_PK.mjs

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

package/build/system/locale/vi_VN.mjs

@@ -34,7 +34,7 @@ export function vi_VN(error) {
         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 '~refine': return error.params.message;
-        case '~standard': return `phải khớp với schema ${error.params.vendor}`;
+        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

@@ -34,7 +34,7 @@ export function yo_NG(error) {
         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 '~refine': return error.params.message;
-        case '~standard': return `gbọdọ baramu àlàyé ${error.params.vendor}`;
+        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

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

package/build/system/locale/zh_Hant.mjs

@@ -34,7 +34,7 @@ export function zh_Hant(error) {
         case 'unevaluatedProperties': return '不得有未評估的屬性';
         case 'uniqueItems': return `不得有重複項目`;
         case '~refine': return error.params.message;
-        case '~standard': return `必須匹配 ${error.params.vendor} 模式`;
+        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';
 // ------------------------------------------------------------------
-// StandardSchema
+// Base
 // ------------------------------------------------------------------
-function IsStandardSchema(value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~standard');
+function IsBase(value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~base');
 }
-function FromStandardSchema(value) {
+function FromBase(value) {
     return value; // non-clonable
 }
 // ------------------------------------------------------------------
@@ -47,7 +47,7 @@ function FromUnknown(value) {
 // ------------------------------------------------------------------
 function FromValue(value) {
     return (value instanceof RegExp ? FromRegExp(value) :
-        IsStandardSchema(value) ? FromStandardSchema(value) :
+        IsBase(value) ? FromBase(value) :
             Guard.IsArray(value) ? FromArray(value) :
                 Guard.IsObject(value) ? FromObject(value) :
                     FromUnknown(value));

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

@@ -1,4 +1,5 @@
 import { type TSchema } from './schema.mjs';
+import { type XBase, type XBaseValidator } from '../../schema/types/index.mjs';
 export declare class BaseNotImplemented extends Error {
     readonly cause: {
         type: Base;
@@ -7,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 {
+export declare class Base<Value extends unknown = unknown> implements TSchema, XBase<Value> {
     readonly '~kind': 'Base';
-    readonly '~standard': StandardSchemaV1.Props<Value>;
+    readonly '~base': BaseValidator<Value>;
     constructor();
     /** Checks a value or returns false if invalid */
     Check(value: unknown): value is Value;
@@ -26,37 +27,9 @@ export declare class Base<Value extends unknown = unknown> implements TSchema {
 }
 /** Returns true if the given value is a Base type. */
 export declare function IsBase(value: unknown): value is Base;
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-    export interface Props<Input = unknown, Output = Input> {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    export type Result<Output> = SuccessResult<Output> | FailureResult;
-    export interface SuccessResult<Output> {
-        readonly value: Output;
-        readonly issues?: undefined;
-    }
-    export interface FailureResult {
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    export interface Issue {
-        readonly message: string;
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    export interface PathSegment {
-        readonly key: PropertyKey;
-    }
-    export interface Types<Input = unknown, Output = Input> {
-        readonly input: Input;
-        readonly output: Output;
-    }
-    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
-    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
-    export {};
+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

@@ -20,16 +20,14 @@ export class BaseNotImplemented extends Error {
 /** Base class for creating extension types. */
 export class Base {
     constructor() {
-        const validator = new BaseValidator(
-        // @ts-ignore TS 5.0.4 - unable to derive guard type
-        (value) => this.Check(value), (value) => this.Errors(value));
+        const validator = new BaseValidator((value) => this.Check(value), (value) => this.Errors(value));
         const configuration = {
             writable: false,
             configurable: false,
             enumerable: false
         };
         Object.defineProperty(this, '~kind', { ...configuration, value: 'Base' });
-        Object.defineProperty(this, '~standard', { ...configuration, value: validator });
+        Object.defineProperty(this, '~base', { ...configuration, value: validator });
     }
     /** Checks a value or returns false if invalid */
     Check(value) {
@@ -70,18 +68,5 @@ class BaseValidator {
     constructor(check, errors) {
         this.check = check;
         this.errors = errors;
-        this.vendor = 'typebox';
-        this.version = 1;
-        this.validate = (value) => {
-            return this.check(value)
-                ? this.Success(value)
-                : this.Failure(this.errors(value));
-        };
-    }
-    Success(value) {
-        return { value };
-    }
-    Failure(issues) {
-        return { issues };
     }
 }

package/package.json

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

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

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

package/build/schema/engine/_standard.mjs

@@ -1,27 +0,0 @@
-// deno-fmt-ignore-file
-import * as V from './_externals.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildStandardSchemaV1(context, schema, value) {
-    return E.Not(E.HasPropertyKey(E.Call(E.Member(E.Member(V.CreateExternalVariable(schema), '~standard'), 'validate'), [value]), E.Constant('issues')));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckStandardSchemaV1(context, schema, value) {
-    return !G.HasPropertyKey(schema['~standard'].validate(value), 'issues');
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorStandardSchemaV1(context, schemaPath, instancePath, schema, value) {
-    const result = schema['~standard'].validate(value);
-    return !G.HasPropertyKey(result, 'issues') || context.AddError({
-        keyword: '~standard',
-        schemaPath,
-        instancePath,
-        params: { vendor: schema[`~standard`].vendor, issues: result.issues },
-    });
-}

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

@@ -1,14 +0,0 @@
-import type { XSchema } from './schema.mjs';
-export interface XStandardValidatorV1 {
-    version: 1;
-    vendor: string;
-    validate: (...args: unknown[]) => object;
-}
-export interface XStandardSchemaV1<Validator extends XStandardValidatorV1 = XStandardValidatorV1> {
-    '~standard': Validator;
-}
-/**
- * Returns true if the schema contains an '~standard` keyword
- * @specification 'StandardSchema'
- */
-export declare function IsStandardSchemaV1(value: XSchema): value is XStandardSchemaV1;

package/build/schema/types/_standard.mjs

@@ -1,19 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains an '~standard` keyword
- * @specification 'StandardSchema'
- */
-export function IsStandardSchemaV1(value) {
-    return Guard.HasPropertyKey(value, '~standard')
-        && Guard.IsObject(value["~standard"])
-        && Guard.HasPropertyKey(value['~standard'], 'version')
-        && Guard.HasPropertyKey(value['~standard'], 'vendor')
-        && Guard.HasPropertyKey(value['~standard'], 'validate')
-        && Guard.IsEqual(value['~standard'].version, 1)
-        && Guard.IsString(value['~standard'].vendor)
-        && Guard.IsFunction(value['~standard'].validate);
-}