@sinclair/typebox 0.24.51 → 0.25.1

package/compiler/compiler.d.ts

@@ -11,7 +11,7 @@ export declare class TypeCheck<T extends Types.TSchema> {
     Code(): string;
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): IterableIterator<ValueError>;
-    /** Returns true if the value matches the given type. */
+    /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Types.Static<T>;
 }
 export declare namespace Property {

package/compiler/compiler.js

@@ -50,7 +50,7 @@ class TypeCheck {
     Errors(value) {
         return index_1.ValueErrors.Errors(this.schema, this.references, value);
     }
-    /** Returns true if the value matches the given type. */
+    /** Returns true if the value matches the compiled type. */
     Check(value) {
         return this.checkFunc(value);
     }
@@ -127,6 +127,17 @@ var TypeCompiler;
     function* Constructor(schema, value) {
         yield* Visit(schema.returns, `${value}.prototype`);
     }
+    function* Date(schema, value) {
+        yield `(${value} instanceof Date)`;
+        if (schema.exclusiveMinimumTimestamp !== undefined)
+            yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`;
+        if (schema.exclusiveMaximumTimestamp !== undefined)
+            yield `(${value}.getTime() < ${schema.exclusiveMaximumTimestamp})`;
+        if (schema.minimumTimestamp !== undefined)
+            yield `(${value}.getTime() >= ${schema.minimumTimestamp})`;
+        if (schema.maximumTimestamp !== undefined)
+            yield `(${value}.getTime() <= ${schema.maximumTimestamp})`;
+    }
     function* Function(schema, value) {
         yield `(typeof ${value} === 'function')`;
     }
@@ -211,7 +222,7 @@ var TypeCompiler;
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
     function* Record(schema, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
+        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`new RegExp(/${keyPattern}/)`);
         yield `(Object.keys(${value}).every(key => ${local}.test(key)))`;
@@ -301,6 +312,8 @@ var TypeCompiler;
                 return yield* Boolean(anySchema, value);
             case 'Constructor':
                 return yield* Constructor(anySchema, value);
+            case 'Date':
+                return yield* Date(anySchema, value);
             case 'Function':
                 return yield* Function(anySchema, value);
             case 'Integer':

package/conditional/structural.js

@@ -204,6 +204,26 @@ var Structural;
             return StructuralResult.True;
         }
     }
+    function Date(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TRecord(right)) {
+            return StructuralResult.False;
+        }
+        else if (guard_1.TypeGuard.TDate(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
     function Function(left, right) {
         if (AnyOrUnknownRule(right)) {
             return StructuralResult.True;
@@ -592,6 +612,9 @@ var Structural;
         else if (guard_1.TypeGuard.TConstructor(left)) {
             return Constructor(left, resolvedRight);
         }
+        else if (guard_1.TypeGuard.TDate(left)) {
+            return Date(left, resolvedRight);
+        }
         else if (guard_1.TypeGuard.TFunction(left)) {
             return Function(left, resolvedRight);
         }

package/errors/errors.d.ts

@@ -5,44 +5,49 @@ export declare enum ValueErrorType {
     ArrayMaxItems = 2,
     ArrayUniqueItems = 3,
     Boolean = 4,
-    Function = 5,
-    Integer = 6,
-    IntegerMultipleOf = 7,
-    IntegerExclusiveMinimum = 8,
-    IntegerExclusiveMaximum = 9,
-    IntegerMinimum = 10,
-    IntegerMaximum = 11,
-    Literal = 12,
-    Never = 13,
-    Null = 14,
-    Number = 15,
-    NumberMultipleOf = 16,
-    NumberExclusiveMinimum = 17,
-    NumberExclusiveMaximum = 18,
-    NumberMinumum = 19,
-    NumberMaximum = 20,
-    Object = 21,
-    ObjectMinProperties = 22,
-    ObjectMaxProperties = 23,
-    ObjectAdditionalProperties = 24,
-    ObjectRequiredProperties = 25,
-    Promise = 26,
-    RecordKeyNumeric = 27,
-    RecordKeyString = 28,
-    String = 29,
-    StringMinLength = 30,
-    StringMaxLength = 31,
-    StringPattern = 32,
-    StringFormatUnknown = 33,
-    StringFormat = 34,
-    TupleZeroLength = 35,
-    TupleLength = 36,
-    Undefined = 37,
-    Union = 38,
-    Uint8Array = 39,
-    Uint8ArrayMinByteLength = 40,
-    Uint8ArrayMaxByteLength = 41,
-    Void = 42
+    Date = 5,
+    DateExclusiveMinimumTimestamp = 6,
+    DateExclusiveMaximumTimestamp = 7,
+    DateMinimumTimestamp = 8,
+    DateMaximumTimestamp = 9,
+    Function = 10,
+    Integer = 11,
+    IntegerMultipleOf = 12,
+    IntegerExclusiveMinimum = 13,
+    IntegerExclusiveMaximum = 14,
+    IntegerMinimum = 15,
+    IntegerMaximum = 16,
+    Literal = 17,
+    Never = 18,
+    Null = 19,
+    Number = 20,
+    NumberMultipleOf = 21,
+    NumberExclusiveMinimum = 22,
+    NumberExclusiveMaximum = 23,
+    NumberMinumum = 24,
+    NumberMaximum = 25,
+    Object = 26,
+    ObjectMinProperties = 27,
+    ObjectMaxProperties = 28,
+    ObjectAdditionalProperties = 29,
+    ObjectRequiredProperties = 30,
+    Promise = 31,
+    RecordKeyNumeric = 32,
+    RecordKeyString = 33,
+    String = 34,
+    StringMinLength = 35,
+    StringMaxLength = 36,
+    StringPattern = 37,
+    StringFormatUnknown = 38,
+    StringFormat = 39,
+    TupleZeroLength = 40,
+    TupleLength = 41,
+    Undefined = 42,
+    Union = 43,
+    Uint8Array = 44,
+    Uint8ArrayMinByteLength = 45,
+    Uint8ArrayMaxByteLength = 46,
+    Void = 47
 }
 export interface ValueError {
     type: ValueErrorType;

package/errors/errors.js

@@ -40,44 +40,49 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["ArrayMaxItems"] = 2] = "ArrayMaxItems";
     ValueErrorType[ValueErrorType["ArrayUniqueItems"] = 3] = "ArrayUniqueItems";
     ValueErrorType[ValueErrorType["Boolean"] = 4] = "Boolean";
-    ValueErrorType[ValueErrorType["Function"] = 5] = "Function";
-    ValueErrorType[ValueErrorType["Integer"] = 6] = "Integer";
-    ValueErrorType[ValueErrorType["IntegerMultipleOf"] = 7] = "IntegerMultipleOf";
-    ValueErrorType[ValueErrorType["IntegerExclusiveMinimum"] = 8] = "IntegerExclusiveMinimum";
-    ValueErrorType[ValueErrorType["IntegerExclusiveMaximum"] = 9] = "IntegerExclusiveMaximum";
-    ValueErrorType[ValueErrorType["IntegerMinimum"] = 10] = "IntegerMinimum";
-    ValueErrorType[ValueErrorType["IntegerMaximum"] = 11] = "IntegerMaximum";
-    ValueErrorType[ValueErrorType["Literal"] = 12] = "Literal";
-    ValueErrorType[ValueErrorType["Never"] = 13] = "Never";
-    ValueErrorType[ValueErrorType["Null"] = 14] = "Null";
-    ValueErrorType[ValueErrorType["Number"] = 15] = "Number";
-    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 16] = "NumberMultipleOf";
-    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 17] = "NumberExclusiveMinimum";
-    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 18] = "NumberExclusiveMaximum";
-    ValueErrorType[ValueErrorType["NumberMinumum"] = 19] = "NumberMinumum";
-    ValueErrorType[ValueErrorType["NumberMaximum"] = 20] = "NumberMaximum";
-    ValueErrorType[ValueErrorType["Object"] = 21] = "Object";
-    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 22] = "ObjectMinProperties";
-    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 23] = "ObjectMaxProperties";
-    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 24] = "ObjectAdditionalProperties";
-    ValueErrorType[ValueErrorType["ObjectRequiredProperties"] = 25] = "ObjectRequiredProperties";
-    ValueErrorType[ValueErrorType["Promise"] = 26] = "Promise";
-    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 27] = "RecordKeyNumeric";
-    ValueErrorType[ValueErrorType["RecordKeyString"] = 28] = "RecordKeyString";
-    ValueErrorType[ValueErrorType["String"] = 29] = "String";
-    ValueErrorType[ValueErrorType["StringMinLength"] = 30] = "StringMinLength";
-    ValueErrorType[ValueErrorType["StringMaxLength"] = 31] = "StringMaxLength";
-    ValueErrorType[ValueErrorType["StringPattern"] = 32] = "StringPattern";
-    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 33] = "StringFormatUnknown";
-    ValueErrorType[ValueErrorType["StringFormat"] = 34] = "StringFormat";
-    ValueErrorType[ValueErrorType["TupleZeroLength"] = 35] = "TupleZeroLength";
-    ValueErrorType[ValueErrorType["TupleLength"] = 36] = "TupleLength";
-    ValueErrorType[ValueErrorType["Undefined"] = 37] = "Undefined";
-    ValueErrorType[ValueErrorType["Union"] = 38] = "Union";
-    ValueErrorType[ValueErrorType["Uint8Array"] = 39] = "Uint8Array";
-    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 40] = "Uint8ArrayMinByteLength";
-    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 41] = "Uint8ArrayMaxByteLength";
-    ValueErrorType[ValueErrorType["Void"] = 42] = "Void";
+    ValueErrorType[ValueErrorType["Date"] = 5] = "Date";
+    ValueErrorType[ValueErrorType["DateExclusiveMinimumTimestamp"] = 6] = "DateExclusiveMinimumTimestamp";
+    ValueErrorType[ValueErrorType["DateExclusiveMaximumTimestamp"] = 7] = "DateExclusiveMaximumTimestamp";
+    ValueErrorType[ValueErrorType["DateMinimumTimestamp"] = 8] = "DateMinimumTimestamp";
+    ValueErrorType[ValueErrorType["DateMaximumTimestamp"] = 9] = "DateMaximumTimestamp";
+    ValueErrorType[ValueErrorType["Function"] = 10] = "Function";
+    ValueErrorType[ValueErrorType["Integer"] = 11] = "Integer";
+    ValueErrorType[ValueErrorType["IntegerMultipleOf"] = 12] = "IntegerMultipleOf";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMinimum"] = 13] = "IntegerExclusiveMinimum";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMaximum"] = 14] = "IntegerExclusiveMaximum";
+    ValueErrorType[ValueErrorType["IntegerMinimum"] = 15] = "IntegerMinimum";
+    ValueErrorType[ValueErrorType["IntegerMaximum"] = 16] = "IntegerMaximum";
+    ValueErrorType[ValueErrorType["Literal"] = 17] = "Literal";
+    ValueErrorType[ValueErrorType["Never"] = 18] = "Never";
+    ValueErrorType[ValueErrorType["Null"] = 19] = "Null";
+    ValueErrorType[ValueErrorType["Number"] = 20] = "Number";
+    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 21] = "NumberMultipleOf";
+    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 22] = "NumberExclusiveMinimum";
+    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 23] = "NumberExclusiveMaximum";
+    ValueErrorType[ValueErrorType["NumberMinumum"] = 24] = "NumberMinumum";
+    ValueErrorType[ValueErrorType["NumberMaximum"] = 25] = "NumberMaximum";
+    ValueErrorType[ValueErrorType["Object"] = 26] = "Object";
+    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 27] = "ObjectMinProperties";
+    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 28] = "ObjectMaxProperties";
+    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 29] = "ObjectAdditionalProperties";
+    ValueErrorType[ValueErrorType["ObjectRequiredProperties"] = 30] = "ObjectRequiredProperties";
+    ValueErrorType[ValueErrorType["Promise"] = 31] = "Promise";
+    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 32] = "RecordKeyNumeric";
+    ValueErrorType[ValueErrorType["RecordKeyString"] = 33] = "RecordKeyString";
+    ValueErrorType[ValueErrorType["String"] = 34] = "String";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 35] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 36] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 37] = "StringPattern";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 38] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 39] = "StringFormat";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 40] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 41] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 42] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 43] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 44] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 45] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 46] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 47] = "Void";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrors
@@ -117,6 +122,23 @@ var ValueErrors;
     function* Constructor(schema, references, path, value) {
         yield* Visit(schema.returns, references, path, value.prototype);
     }
+    function* Date(schema, references, path, value) {
+        if (!(value instanceof globalThis.Date)) {
+            return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` };
+        }
+        if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+            yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` };
+        }
+        if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+            yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` };
+        }
+        if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
+            yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` };
+        }
+        if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
+            yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` };
+        }
+    }
     function* Function(schema, references, path, value) {
         if (!(typeof value === 'function')) {
             return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` };
@@ -351,6 +373,8 @@ var ValueErrors;
                 return yield* Boolean(anySchema, anyReferences, path, value);
             case 'Constructor':
                 return yield* Constructor(anySchema, anyReferences, path, value);
+            case 'Date':
+                return yield* Date(anySchema, anyReferences, path, value);
             case 'Function':
                 return yield* Function(anySchema, anyReferences, path, value);
             case 'Integer':

package/guard/guard.d.ts

@@ -13,6 +13,8 @@ export declare namespace TypeGuard {
     function TBoolean(schema: unknown): schema is Types.TBoolean;
     /** Returns true if the given schema is TConstructor */
     function TConstructor(schema: unknown): schema is Types.TConstructor;
+    /** Returns true if the given schema is TDate */
+    function TDate(schema: unknown): schema is Types.TDate;
     /** Returns true if the given schema is TFunction */
     function TFunction(schema: unknown): schema is Types.TFunction;
     /** Returns true if the given schema is TInteger */

package/guard/guard.js

@@ -111,12 +111,23 @@ var TypeGuard;
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TBoolean */
     function TBoolean(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean' && IsOptionalString(schema.$id);
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Boolean' &&
+            schema.type === 'boolean' &&
+            IsOptionalString(schema.$id));
     }
     TypeGuard.TBoolean = TBoolean;
     /** Returns true if the given schema is TConstructor */
     function TConstructor(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+        // prettier-ignore
+        if (!(IsObject(schema) &&
+            schema[Types.Kind] === 'Constructor' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Constructor' &&
+            IsOptionalString(schema.$id) &&
+            IsArray(schema.parameters) &&
+            TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -126,9 +137,29 @@ var TypeGuard;
         return true;
     }
     TypeGuard.TConstructor = TConstructor;
+    /** Returns true if the given schema is TDate */
+    function TDate(schema) {
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Date' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Date' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.minimumTimestamp) &&
+            IsOptionalNumber(schema.maximumTimestamp) &&
+            IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
+            IsOptionalNumber(schema.exclusiveMaximumTimestamp));
+    }
+    TypeGuard.TDate = TDate;
     /** Returns true if the given schema is TFunction */
     function TFunction(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+        // prettier-ignore
+        if (!(IsObject(schema) &&
+            schema[Types.Kind] === 'Function' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Function' &&
+            IsOptionalString(schema.$id) &&
+            IsArray(schema.parameters) &&
+            TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -153,7 +184,13 @@ var TypeGuard;
     TypeGuard.TInteger = TInteger;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Literal' &&
+            IsOptionalString(schema.$id) &&
+            (IsString(schema.const) ||
+                IsNumber(schema.const) ||
+                IsBoolean(schema.const)));
     }
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNever */
@@ -213,12 +250,24 @@ var TypeGuard;
     TypeGuard.TObject = TObject;
     /** Returns true if the given schema is TPromise */
     function TPromise(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && IsOptionalString(schema.$id) && TSchema(schema.item);
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Promise' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Promise' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.item));
     }
     TypeGuard.TPromise = TPromise;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
+        // prettier-ignore
+        if (!(IsObject(schema) &&
+            schema[Types.Kind] === 'Record' &&
+            schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
+            schema.additionalProperties === false &&
+            IsObject(schema.patternProperties))) {
             return false;
         }
         const keys = Object.keys(schema.patternProperties);
@@ -236,12 +285,20 @@ var TypeGuard;
     TypeGuard.TRecord = TRecord;
     /** Returns true if the given schema is TSelf */
     function TSelf(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsOptionalString(schema.$id) && IsString(schema.$ref);
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Self' &&
+            IsOptionalString(schema.$id) &&
+            IsString(schema.$ref));
     }
     TypeGuard.TSelf = TSelf;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsOptionalString(schema.$id) && IsString(schema.$ref);
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Ref' &&
+            IsOptionalString(schema.$id) &&
+            IsString(schema.$ref));
     }
     TypeGuard.TRef = TRef;
     /** Returns true if the given schema is TString */
@@ -258,7 +315,14 @@ var TypeGuard;
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
+        // prettier-ignore
+        if (!(IsObject(schema) &&
+            schema[Types.Kind] === 'Tuple' &&
+            schema.type === 'array' &&
+            IsOptionalString(schema.$id) &&
+            IsNumber(schema.minItems) &&
+            IsNumber(schema.maxItems) &&
+            schema.minItems === schema.maxItems)) {
             return false;
         }
         if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
@@ -276,12 +340,21 @@ var TypeGuard;
     TypeGuard.TTuple = TTuple;
     /** Returns true if the given schema is TUndefined */
     function TUndefined(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.specialized === 'Undefined';
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Undefined' &&
+            schema.type === 'null' &&
+            schema.typeOf === 'Undefined' &&
+            IsOptionalString(schema.$id));
     }
     TypeGuard.TUndefined = TUndefined;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
+        // prettier-ignore
+        if (!(IsObject(schema) &&
+            schema[Types.Kind] === 'Union' &&
+            IsArray(schema.anyOf) &&
+            IsOptionalString(schema.$id))) {
             return false;
         }
         for (const inner of schema.anyOf) {
@@ -297,19 +370,27 @@ var TypeGuard;
             schema[Types.Kind] === 'Uint8Array' &&
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
-            schema.specialized === 'Uint8Array' &&
+            schema.instanceOf === 'Uint8Array' &&
             IsOptionalNumber(schema.minByteLength) &&
             IsOptionalNumber(schema.maxByteLength));
     }
     TypeGuard.TUint8Array = TUint8Array;
     /** Returns true if the given schema is TUnknown */
     function TUnknown(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Unknown' && IsOptionalString(schema.$id);
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Unknown' &&
+            IsOptionalString(schema.$id));
     }
     TypeGuard.TUnknown = TUnknown;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null' && IsOptionalString(schema.$id);
+        // prettier-ignore
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Void' &&
+            schema.type === 'null' &&
+            schema.typeOf === 'Void' &&
+            IsOptionalString(schema.$id));
     }
     TypeGuard.TVoid = TVoid;
     /** Returns true if the given schema is TSchema */
@@ -318,6 +399,7 @@ var TypeGuard;
             TArray(schema) ||
             TBoolean(schema) ||
             TConstructor(schema) ||
+            TDate(schema) ||
             TFunction(schema) ||
             TInteger(schema) ||
             TLiteral(schema) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.51",
+  "version": "0.25.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",