@sinclair/typebox 0.24.50 → 0.25.0

package/typebox.d.ts

@@ -32,7 +32,7 @@ export interface TSchema extends SchemaOptions {
     params: unknown[];
     static: unknown;
 }
-export declare type TAnySchema = TSchema | TAny | TArray | TBoolean | TConstructor | TEnum | TFunction | TInteger | TLiteral | TNull | TNumber | TObject | TPromise | TRecord | TSelf | TRef | TString | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export declare type TAnySchema = TSchema | TAny | TArray | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TLiteral | TNull | TNumber | TObject | TPromise | TRecord | TSelf | TRef | TString | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
 export interface NumericOptions extends SchemaOptions {
     exclusiveMaximum?: number;
     exclusiveMinimum?: number;
@@ -69,10 +69,23 @@ export declare type StaticContructorParameters<T extends readonly TSchema[], P e
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
     static: new (...param: StaticContructorParameters<T, this['params']>) => Static<U, this['params']>;
-    type: 'constructor';
+    type: 'object';
+    instanceOf: 'Constructor';
     parameters: T;
     returns: U;
 }
+export interface DateOptions extends SchemaOptions {
+    exclusiveMaximumTimestamp?: number;
+    exclusiveMinimumTimestamp?: number;
+    maximumTimestamp?: number;
+    minimumTimestamp?: number;
+}
+export interface TDate extends TSchema, DateOptions {
+    [Kind]: 'Date';
+    static: Date;
+    type: 'object';
+    instanceOf: 'Date';
+}
 export interface TEnumOption<T> {
     type: 'number' | 'string';
     const: T;
@@ -90,7 +103,8 @@ export declare type StaticFunctionParameters<T extends readonly TSchema[], P ext
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
     static: (...param: StaticFunctionParameters<T, this['params']>) => Static<U, this['params']>;
-    type: 'function';
+    type: 'object';
+    instanceOf: 'Function';
     parameters: T;
     returns: U;
 }
@@ -207,10 +221,11 @@ export declare type TPick<T extends TObject, Properties extends ObjectPropertyKe
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
     static: Promise<Static<T, this['params']>>;
-    type: 'promise';
+    type: 'object';
+    instanceOf: 'Promise';
     item: TSchema;
 }
-export declare type TRecordKey = TString | TNumber | TUnion<TLiteral<any>[]>;
+export declare type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
 export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: Record<Static<K>, Static<T, this['params']>>;
@@ -268,9 +283,9 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
 }
 export interface TUndefined extends TSchema {
     [Kind]: 'Undefined';
-    specialized: 'Undefined';
     static: undefined;
-    type: 'object';
+    type: 'null';
+    typeOf: 'Undefined';
 }
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Union';
@@ -286,7 +301,7 @@ export interface Uint8ArrayOptions extends SchemaOptions {
 export interface TUint8Array extends TSchema, Uint8ArrayOptions {
     [Kind]: 'Uint8Array';
     static: Uint8Array;
-    specialized: 'Uint8Array';
+    instanceOf: 'Uint8Array';
     type: 'object';
 }
 export interface TUnknown extends TSchema {
@@ -304,6 +319,7 @@ export interface TVoid extends TSchema {
     [Kind]: 'Void';
     static: void;
     type: 'null';
+    typeOf: 'Void';
 }
 /** Creates a static type from a TypeBox type */
 export declare type Static<T extends TSchema, P extends unknown[] = []> = (T & {
@@ -316,88 +332,91 @@ export declare class TypeBuilder {
     Readonly<T extends TSchema>(item: T): TReadonly<T>;
     /** Creates a optional property */
     Optional<T extends TSchema>(item: T): TOptional<T>;
-    /** Creates a any type */
+    /** `Standard` Creates a any type */
     Any(options?: SchemaOptions): TAny;
-    /** Creates a array type */
+    /** `Standard` Creates a array type */
     Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
-    /** Creates a boolean type */
+    /** `Standard` Creates a boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
-    /** Creates a tuple type from this constructors parameters */
+    /** `Extended` Creates a tuple type from this constructors parameters */
     ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
-    /** Creates a constructor type */
+    /** `Extended` Creates a constructor type */
     Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TupleToArray<T>, U>;
-    /** Creates a constructor type */
+    /** `Extended` Creates a constructor type */
     Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
-    /** Creates a enum type */
+    /** `Extended` Creates a Date type */
+    Date(options?: DateOptions): TDate;
+    /** `Standard` Creates a enum type */
     Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
-    /** Creates a function type */
+    /** `Extended` Creates a function type */
     Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TupleToArray<T>, U>;
-    /** Creates a function type */
+    /** `Extended` Creates a function type */
     Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
-    /** Creates a type from this constructors instance type */
+    /** `Extended` Creates a type from this constructors instance type */
     InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
-    /** Creates a integer type */
+    /** `Standard` Creates a integer type */
     Integer(options?: NumericOptions): TInteger;
-    /** Creates a intersect type. */
+    /** `Standard` Creates a intersect type. */
     Intersect<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TIntersect<T>;
-    /** Creates a keyof type */
+    /** `Standard` Creates a keyof type */
     KeyOf<T extends TObject>(object: T, options?: SchemaOptions): TKeyOf<T>;
-    /** Creates a literal type. */
+    /** `Standard` Creates a literal type. */
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
-    /** Creates a never type */
+    /** `Standard` Creates a never type */
     Never(options?: SchemaOptions): TNever;
-    /** Creates a null type */
+    /** `Standard` Creates a null type */
     Null(options?: SchemaOptions): TNull;
-    /** Creates a number type */
+    /** `Standard` Creates a number type */
     Number(options?: NumericOptions): TNumber;
-    /** Creates an object type with the given properties */
+    /** `Standard` Creates an object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** Creates a new object whose properties are omitted from the given object */
+    /** `Standard` Creates a new object type whose keys are omitted from the given source type */
     Omit<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TOmit<T, UnionStringLiteralToTuple<K>>;
-    /** Creates a new object whose properties are omitted from the given object */
+    /** `Standard` Creates a new object type whose keys are omitted from the given source type */
     Omit<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TOmit<T, K>;
-    /** Creates a tuple type from this functions parameters */
+    /** `Extended` Creates a tuple type from this functions parameters */
     Parameters<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TParameters<T>;
-    /** Creates an object type whose properties are all optional */
+    /** `Standard` Creates an object type whose properties are all optional */
     Partial<T extends TObject>(schema: T, options?: ObjectOptions): TPartial<T>;
-    /** Creates a object whose properties are picked from the given object */
+    /** `Standard` Creates a new object type whose keys are picked from the given source type */
     Pick<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TPick<T, UnionStringLiteralToTuple<K>>;
-    /** Creates a object whose properties are picked from the given object */
+    /** `Standard` Creates a new object type whose keys are picked from the given source type */
     Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TPick<T, K>;
-    /** Creates a promise type. This type cannot be represented in schema. */
+    /** `Extended` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
-    /** Creates an object whose properties are derived from the given string literal union. */
+    /** `Standard` Creates an object whose properties are derived from the given string literal union. */
     Record<K extends TUnion<TLiteral[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordProperties<K, T>>;
-    /** Creates a record type */
-    Record<K extends TString | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>;
-    /** Creates a recursive object type */
+    /** `Standard` Creates a record type */
+    Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>;
+    /** `Standard` Creates recursive type */
     Recursive<T extends TSchema>(callback: (self: TSelf) => T, options?: SchemaOptions): TRecursive<T>;
-    /** Creates a reference schema */
+    /** `Standard` Creates a reference type. The referenced type must contain a $id. */
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
-    /** Creates a string type from a regular expression */
+    /** `Standard` Creates a string type from a regular expression */
     RegEx(regex: RegExp, options?: SchemaOptions): TString;
-    /** Creates an object type whose properties are all required */
+    /** `Standard` Creates an object type whose properties are all required */
     Required<T extends TObject>(schema: T, options?: SchemaOptions): TRequired<T>;
-    /** Creates a type from this functions return type */
+    /** `Extended` Creates a type from this functions return type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
     /** Removes Kind and Modifier symbol property keys from this schema */
     Strict<T extends TSchema>(schema: T): T;
-    /** Creates a string type */
+    /** `Standard` Creates a string type */
     String<Format extends string>(options?: StringOptions<StringFormatOption | Format>): TString<Format>;
-    /** Creates a tuple type */
+    /** `Standard` Creates a tuple type */
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
-    /** Creates a undefined type */
+    /** `Extended` Creates a undefined type */
     Undefined(options?: SchemaOptions): TUndefined;
-    /** Creates a union type */
+    /** `Standard` Creates a union type */
     Union(items: [], options?: SchemaOptions): TNever;
+    /** `Standard` Creates a union type */
     Union<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TUnion<T>;
-    /** Creates a Uint8Array type */
+    /** `Extended` Creates a Uint8Array type */
     Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
-    /** Creates an unknown type */
+    /** `Standard` Creates an unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
-    /** Creates a user defined schema that infers as type T  */
+    /** `Standard` Creates a user defined schema that infers as type T  */
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
-    /** Creates a void type */
+    /** `Extended` Creates a void type */
     Void(options?: SchemaOptions): TVoid;
     /** Use this function to return TSchema with static and params omitted */
     protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;

package/typebox.js

@@ -57,36 +57,40 @@ class TypeBuilder {
     // ----------------------------------------------------------------------
     // Types
     // ----------------------------------------------------------------------
-    /** Creates a any type */
+    /** `Standard` Creates a any type */
     Any(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Any' });
     }
-    /** Creates a array type */
+    /** `Standard` Creates a array type */
     Array(items, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items });
     }
-    /** Creates a boolean type */
+    /** `Standard` Creates a boolean type */
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** Creates a tuple type from this constructors parameters */
+    /** `Extended` Creates a tuple type from this constructors parameters */
     ConstructorParameters(schema, options = {}) {
         return this.Tuple([...schema.parameters], { ...options });
     }
-    /** Creates a constructor type */
+    /** `Extended` Creates a constructor type */
     Constructor(parameters, returns, options = {}) {
         if (parameters[exports.Kind] === 'Tuple') {
             const inner = parameters.items === undefined ? [] : parameters.items;
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters: inner, returns });
+            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: inner, returns });
         }
         else if (globalThis.Array.isArray(parameters)) {
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters, returns });
+            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters, returns });
         }
         else {
             throw new Error('TypeBuilder.Constructor: Invalid parameters');
         }
     }
-    /** Creates a enum type */
+    /** `Extended` Creates a Date type */
+    Date(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Date', type: 'object', instanceOf: 'Date' });
+    }
+    /** `Standard` Creates a enum type */
     Enum(item, options = {}) {
         const values = Object.keys(item)
             .filter((key) => isNaN(key))
@@ -94,28 +98,28 @@ class TypeBuilder {
         const anyOf = values.map((value) => (typeof value === 'string' ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
         return this.Create({ ...options, [exports.Kind]: 'Union', [exports.Hint]: 'Enum', anyOf });
     }
-    /** Creates a function type */
+    /** `Extended` Creates a function type */
     Function(parameters, returns, options = {}) {
         if (parameters[exports.Kind] === 'Tuple') {
             const inner = parameters.items === undefined ? [] : parameters.items;
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters: inner, returns });
+            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: inner, returns });
         }
         else if (globalThis.Array.isArray(parameters)) {
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters, returns });
+            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters, returns });
         }
         else {
             throw new Error('TypeBuilder.Function: Invalid parameters');
         }
     }
-    /** Creates a type from this constructors instance type */
+    /** `Extended` Creates a type from this constructors instance type */
     InstanceType(schema, options = {}) {
         return { ...options, ...this.Clone(schema.returns) };
     }
-    /** Creates a integer type */
+    /** `Standard` Creates a integer type */
     Integer(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
     }
-    /** Creates a intersect type. */
+    /** `Standard` Creates a intersect type. */
     Intersect(objects, options = {}) {
         const isOptional = (schema) => (schema[exports.Modifier] && schema[exports.Modifier] === 'Optional') || schema[exports.Modifier] === 'ReadonlyOptional';
         const [required, optional] = [new Set(), new Set()];
@@ -144,16 +148,16 @@ class TypeBuilder {
             return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties });
         }
     }
-    /** Creates a keyof type */
+    /** `Standard` Creates a keyof type */
     KeyOf(object, options = {}) {
         const items = Object.keys(object.properties).map((key) => this.Create({ ...options, [exports.Kind]: 'Literal', type: 'string', const: key }));
         return this.Create({ ...options, [exports.Kind]: 'Union', [exports.Hint]: 'KeyOf', anyOf: items });
     }
-    /** Creates a literal type. */
+    /** `Standard` Creates a literal type. */
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
-    /** Creates a never type */
+    /** `Standard` Creates a never type */
     Never(options = {}) {
         return this.Create({
             ...options,
@@ -164,15 +168,15 @@ class TypeBuilder {
             ],
         });
     }
-    /** Creates a null type */
+    /** `Standard` Creates a null type */
     Null(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Null', type: 'null' });
     }
-    /** Creates a number type */
+    /** `Standard` Creates a number type */
     Number(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Number', type: 'number' });
     }
-    /** Creates an object type with the given properties */
+    /** `Standard` Creates an object type */
     Object(properties, options = {}) {
         const property_names = Object.keys(properties);
         const optional = property_names.filter((name) => {
@@ -188,7 +192,7 @@ class TypeBuilder {
             return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties });
         }
     }
-    /** Creates a new object whose properties are omitted from the given object */
+    /** `Standard` Creates a new object type whose keys are omitted from the given source type */
     Omit(schema, keys, options = {}) {
         const select = keys[exports.Kind] === 'Union' ? keys.anyOf.map((schema) => schema.const) : keys;
         const next = { ...this.Clone(schema), ...options, [exports.Hint]: 'Omit' };
@@ -203,11 +207,11 @@ class TypeBuilder {
         }
         return this.Create(next);
     }
-    /** Creates a tuple type from this functions parameters */
+    /** `Extended` Creates a tuple type from this functions parameters */
     Parameters(schema, options = {}) {
         return exports.Type.Tuple(schema.parameters, { ...options });
     }
-    /** Creates an object type whose properties are all optional */
+    /** `Standard` Creates an object type whose properties are all optional */
     Partial(schema, options = {}) {
         const next = { ...this.Clone(schema), ...options, [exports.Hint]: 'Partial' };
         delete next.required;
@@ -231,7 +235,7 @@ class TypeBuilder {
         }
         return this.Create(next);
     }
-    /** Creates a object whose properties are picked from the given object */
+    /** `Standard` Creates a new object type whose keys are picked from the given source type */
     Pick(schema, keys, options = {}) {
         const select = keys[exports.Kind] === 'Union' ? keys.anyOf.map((schema) => schema.const) : keys;
         const next = { ...this.Clone(schema), ...options, [exports.Hint]: 'Pick' };
@@ -246,11 +250,11 @@ class TypeBuilder {
         }
         return this.Create(next);
     }
-    /** Creates a promise type. This type cannot be represented in schema. */
+    /** `Extended` Creates a Promise type */
     Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'promise', item });
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item });
     }
-    /** Creates a record type */
+    /** `Standard` Creates a record type */
     Record(key, value, options = {}) {
         // If string literal union return TObject with properties extracted from union.
         if (key[exports.Kind] === 'Union') {
@@ -259,7 +263,7 @@ class TypeBuilder {
             }, {}), { ...options, [exports.Hint]: 'Record' });
         }
         // otherwise return TRecord with patternProperties
-        const pattern = key[exports.Kind] === 'Number' ? '^(0|[1-9][0-9]*)$' : key[exports.Kind] === 'String' && key.pattern ? key.pattern : '^.*$';
+        const pattern = ['Integer', 'Number'].includes(key[exports.Kind]) ? '^(0|[1-9][0-9]*)$' : key[exports.Kind] === 'String' && key.pattern ? key.pattern : '^.*$';
         return this.Create({
             ...options,
             [exports.Kind]: 'Record',
@@ -268,7 +272,7 @@ class TypeBuilder {
             additionalProperties: false,
         });
     }
-    /** Creates a recursive object type */
+    /** `Standard` Creates recursive type */
     Recursive(callback, options = {}) {
         if (options.$id === undefined)
             options.$id = `T${TypeOrdinal++}`;
@@ -276,17 +280,17 @@ class TypeBuilder {
         self.$id = options.$id;
         return this.Create({ ...options, ...self });
     }
-    /** Creates a reference schema */
+    /** `Standard` Creates a reference type. The referenced type must contain a $id. */
     Ref(schema, options = {}) {
         if (schema.$id === undefined)
             throw Error('TypeBuilder.Ref: Referenced schema must specify an $id');
         return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
     }
-    /** Creates a string type from a regular expression */
+    /** `Standard` Creates a string type from a regular expression */
     RegEx(regex, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'String', type: 'string', pattern: regex.source });
     }
-    /** Creates an object type whose properties are all required */
+    /** `Standard` Creates an object type whose properties are all required */
     Required(schema, options = {}) {
         const next = { ...this.Clone(schema), ...options, [exports.Hint]: 'Required' };
         next.required = Object.keys(next.properties);
@@ -310,7 +314,7 @@ class TypeBuilder {
         }
         return this.Create(next);
     }
-    /** Creates a type from this functions return type */
+    /** `Extended` Creates a type from this functions return type */
     ReturnType(schema, options = {}) {
         return { ...options, ...this.Clone(schema.returns) };
     }
@@ -318,11 +322,11 @@ class TypeBuilder {
     Strict(schema) {
         return JSON.parse(JSON.stringify(schema));
     }
-    /** Creates a string type */
+    /** `Standard` Creates a string type */
     String(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
     }
-    /** Creates a tuple type */
+    /** `Standard` Creates a tuple type */
     Tuple(items, options = {}) {
         const additionalItems = false;
         const minItems = items.length;
@@ -330,28 +334,29 @@ class TypeBuilder {
         const schema = (items.length > 0 ? { ...options, [exports.Kind]: 'Tuple', type: 'array', items, additionalItems, minItems, maxItems } : { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
-    /** Creates a undefined type */
+    /** `Extended` Creates a undefined type */
     Undefined(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'object', specialized: 'Undefined' });
+        return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' });
     }
+    /** `Standard` Creates a union type */
     Union(items, options = {}) {
         return items.length === 0 ? exports.Type.Never({ ...options }) : this.Create({ ...options, [exports.Kind]: 'Union', anyOf: items });
     }
-    /** Creates a Uint8Array type */
+    /** `Extended` Creates a Uint8Array type */
     Uint8Array(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'object', specialized: 'Uint8Array' });
+        return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' });
     }
-    /** Creates an unknown type */
+    /** `Standard` Creates an unknown type */
     Unknown(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Unknown' });
     }
-    /** Creates a user defined schema that infers as type T  */
+    /** `Standard` Creates a user defined schema that infers as type T  */
     Unsafe(options = {}) {
         return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
     }
-    /** Creates a void type */
+    /** `Extended` Creates a void type */
     Void(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Void', type: 'null' });
+        return this.Create({ ...options, [exports.Kind]: 'Void', type: 'null', typeOf: 'Void' });
     }
     /** Use this function to return TSchema with static and params omitted */
     Create(schema) {

package/value/cast.js

@@ -195,6 +195,9 @@ var ValueCast;
         }
         return result;
     }
+    function Date(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
     function Enum(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
@@ -247,7 +250,7 @@ var ValueCast;
     function Record(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
             return clone_1.ValueClone.Clone(value);
-        if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value))
+        if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date)
             return create_1.ValueCreate.Create(schema, references);
         const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0];
         const subschema = schema.patternProperties[subschemaKey];
@@ -312,6 +315,8 @@ var ValueCast;
                 return Boolean(anySchema, anyReferences, value);
             case 'Constructor':
                 return Constructor(anySchema, anyReferences, value);
+            case 'Date':
+                return Date(anySchema, anyReferences, value);
             case 'Enum':
                 return Enum(anySchema, anyReferences, value);
             case 'Function':

package/value/check.js

@@ -63,6 +63,24 @@ var ValueCheck;
     function Constructor(schema, references, value) {
         return Visit(schema.returns, references, value.prototype);
     }
+    function Date(schema, references, value) {
+        if (!(value instanceof globalThis.Date)) {
+            return false;
+        }
+        if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+            return false;
+        }
+        if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+            return false;
+        }
+        if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
+            return false;
+        }
+        if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
+            return false;
+        }
+        return true;
+    }
     function Function(schema, references, value) {
         return typeof value === 'function';
     }
@@ -175,7 +193,7 @@ var ValueCheck;
         return typeof value === 'object' && typeof value.then === 'function';
     }
     function Record(schema, references, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
             return false;
         }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
@@ -281,6 +299,8 @@ var ValueCheck;
                 return Boolean(anySchema, anyReferences, value);
             case 'Constructor':
                 return Constructor(anySchema, anyReferences, value);
+            case 'Date':
+                return Date(anySchema, anyReferences, value);
             case 'Function':
                 return Function(anySchema, anyReferences, value);
             case 'Integer':

package/value/clone.js

@@ -31,13 +31,16 @@ exports.ValueClone = void 0;
 const is_1 = require("./is");
 var ValueClone;
 (function (ValueClone) {
+    function Array(value) {
+        return value.map((element) => Clone(element));
+    }
+    function Date(value) {
+        return new globalThis.Date(value.toISOString());
+    }
     function Object(value) {
         const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)];
         return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
     }
-    function Array(value) {
-        return value.map((element) => Clone(element));
-    }
     function TypedArray(value) {
         return value.slice();
     }
@@ -45,7 +48,10 @@ var ValueClone;
         return value;
     }
     function Clone(value) {
-        if (is_1.Is.Object(value)) {
+        if (is_1.Is.Date(value)) {
+            return Date(value);
+        }
+        else if (is_1.Is.Object(value)) {
             return Object(value);
         }
         else if (is_1.Is.Array(value)) {

package/value/create.js

@@ -99,6 +99,17 @@ var ValueCreate;
             }
         }
     }
+    function Date(schema, references) {
+        if (schema.default !== undefined) {
+            return schema.default;
+        }
+        else if (schema.minimumTimestamp !== undefined) {
+            return new globalThis.Date(schema.minimumTimestamp);
+        }
+        else {
+            return new globalThis.Date(0);
+        }
+    }
     function Enum(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
@@ -305,6 +316,8 @@ var ValueCreate;
                 return Boolean(anySchema, anyReferences);
             case 'Constructor':
                 return Constructor(anySchema, anyReferences);
+            case 'Date':
+                return Date(anySchema, anyReferences);
             case 'Enum':
                 return Enum(anySchema, anyReferences);
             case 'Function':

package/value/delta.js

@@ -79,6 +79,11 @@ var ValueDelta;
                 yield Delete(`${path}/${String(key)}`);
         }
     }
+    function* Date(path, current, next) {
+        if (is_1.Is.Date(next) && current.getTime() === next.getTime())
+            return;
+        yield Update(path, next);
+    }
     function* Array(path, current, next) {
         if (!is_1.Is.Array(next))
             return yield Update(path, next);
@@ -112,6 +117,9 @@ var ValueDelta;
         if (is_1.Is.Object(current)) {
             return yield* Object(path, current, next);
         }
+        else if (is_1.Is.Date(current)) {
+            return yield* Date(path, current, next);
+        }
         else if (is_1.Is.Array(current)) {
             return yield* Array(path, current, next);
         }