@sinclair/typebox 0.26.1 → 0.26.3

package/compiler/compiler.js

@@ -165,10 +165,10 @@ var TypeCompiler;
         return typeof value === 'string';
     }
     // -------------------------------------------------------------------
-    // Overrides
+    // Polices
     // -------------------------------------------------------------------
-    function IsNumberCheck(value) {
-        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    function IsExactOptionalProperty(value, key, expression) {
+        return index_2.TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${value}.${key} !== undefined ? ${expression} : true)`;
     }
     function IsObjectCheck(value) {
         return !index_2.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
@@ -178,6 +178,9 @@ var TypeCompiler;
             ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
             : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
     }
+    function IsNumberCheck(value) {
+        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    }
     function IsVoidCheck(value) {
         return index_2.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
     }
@@ -302,32 +305,32 @@ var TypeCompiler;
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
         if (IsNumber(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
-        const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
-        for (const schemaKey of schemaKeys) {
-            const memberExpression = MemberExpression.Encode(value, schemaKey);
-            const property = schema.properties[schemaKey];
-            if (schema.required && schema.required.includes(schemaKey)) {
+        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        for (const knownKey of knownKeys) {
+            const memberExpression = MemberExpression.Encode(value, knownKey);
+            const property = schema.properties[knownKey];
+            if (schema.required && schema.required.includes(knownKey)) {
                 yield* Visit(property, references, memberExpression);
                 if (Types.ExtendsUndefined.Check(property))
-                    yield `('${schemaKey}' in ${value})`;
+                    yield `('${knownKey}' in ${value})`;
             }
             else {
                 const expression = CreateExpression(property, references, memberExpression);
-                yield `('${schemaKey}' in ${value} ? ${expression} : true)`;
+                yield IsExactOptionalProperty(value, knownKey, expression);
             }
         }
         if (schema.additionalProperties === false) {
-            if (schema.required && schema.required.length === schemaKeys.length) {
-                yield `Object.getOwnPropertyNames(${value}).length === ${schemaKeys.length}`;
+            if (schema.required && schema.required.length === knownKeys.length) {
+                yield `Object.getOwnPropertyNames(${value}).length === ${knownKeys.length}`;
             }
             else {
-                const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`;
+                const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
                 yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
             }
         }
         if (typeof schema.additionalProperties === 'object') {
             const expression = CreateExpression(schema.additionalProperties, references, 'value[key]');
-            const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`;
+            const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
     }

package/errors/errors.js

@@ -136,6 +136,24 @@ var ValueErrors;
     // ----------------------------------------------------------------------
     // Guards
     // ----------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsInteger(value) {
+        return globalThis.Number.isInteger(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    // ----------------------------------------------------------------------
+    // Policies
+    // ----------------------------------------------------------------------
+    function IsExactOptionalProperty(value, key) {
+        return index_1.TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
     function IsObject(value) {
         const result = typeof value === 'object' && value !== null;
         return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
@@ -143,26 +161,14 @@ var ValueErrors;
     function IsRecordObject(value) {
         return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
     }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
     function IsNumber(value) {
         const result = typeof value === 'number';
         return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
     }
-    function IsInteger(value) {
-        return globalThis.Number.isInteger(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
     function IsVoid(value) {
         const result = value === undefined;
         return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
     }
-    function IsDefined(value) {
-        return value !== undefined;
-    }
     // ----------------------------------------------------------------------
     // Types
     // ----------------------------------------------------------------------
@@ -361,7 +367,7 @@ var ValueErrors;
                 }
             }
             else {
-                if (knownKey in value) {
+                if (IsExactOptionalProperty(value, knownKey)) {
                     yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
                 }
             }

package/package.json

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

package/readme.md

@@ -229,13 +229,13 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Null()          │ type T = null               │ const T = {                    │
-│                                │                             │    type: 'null'                │
+│                                │                             │   type: 'null'                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
-│                                │                             │    const: 42,                  │
-│                                │                             │    type: 'number'              │
+│                                │                             │   const: 42,                   │
+│                                │                             │   type: 'number'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -325,20 +325,17 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number | string        │   type: 'object',              │
-│     x: Type.Number()           │   y: number                 │   properties: {                │
-│   }),                          │ }                           │     x: {                       │
-│   Type.Object({                │                             │       anyOf: [                 │
-│     x: Type.String()           │                             │         { type: 'number' },    │
-│     y: Type.Number()           │                             │         { type: 'string' }     │
-│   })                           │                             │       ]                        │
-│ ])                             │                             │     },                         │
-│                                │                             │     y: {                       │
-│                                │                             │       type: 'number'           │
+│ const T = Type.Composite([     │ type I = {                  │ const T = {                    │
+│   Type.Object({                │   x: number                 │   type: 'object',              │
+│     x: Type.Number()           │ } & {                       │   required: ['x', 'y'],        │
+│   }),                          │   y: number                 │   properties: {                │
+│   Type.Object({                │ }                           │     x: {                       │
+│     y: Type.Number()           │                             │       type: 'number'           │
+│   })                           │ type T = {                  │     },                         │
+│ ])                             │   [K in keyof I]: I[K]      │     y: {                       │
+│                                │ }                           │       type: 'number'           │
 │                                │                             │     }                          │
-│                                │                             │   },                           │
-│                                │                             │   required: ['x', 'y']         │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤

package/system/system.d.ts

@@ -7,6 +7,8 @@ export declare class TypeSystemDuplicateFormat extends Error {
 }
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export declare namespace TypeSystem {
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    let ExactOptionalPropertyTypes: boolean;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     let AllowArrayObjects: boolean;
     /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */

package/system/system.js

@@ -44,12 +44,20 @@ exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 var TypeSystem;
 (function (TypeSystem) {
+    // ------------------------------------------------------------------------
+    // Assertion Policies
+    // ------------------------------------------------------------------------
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    TypeSystem.ExactOptionalPropertyTypes = false;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     TypeSystem.AllowArrayObjects = false;
     /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
     TypeSystem.AllowNaN = false;
     /** Sets whether `null` should validate for void types. The default is `false` */
     TypeSystem.AllowVoidNull = false;
+    // ------------------------------------------------------------------------
+    // String Formats and Types
+    // ------------------------------------------------------------------------
     /** Creates a new type */
     function Type(kind, check) {
         if (Types.TypeRegistry.Has(kind))

package/typebox.d.ts

@@ -83,16 +83,18 @@ export interface TBoolean extends TSchema {
 }
 export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
-export type TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>;
-export type TCompositeUnionLeft<T extends TObject, Acc extends TProperties> = {
-    [K in keyof T['properties']]: K extends keyof Acc ? TCompositeUnion<T['properties'][K], Acc[K]> : T['properties'][K];
+export type TCompositeEvaluateArray<T extends readonly TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 };
-export type TCompositeUnionRight<T extends TObject, Acc extends TProperties> = {
-    [K in keyof Acc]: K extends keyof T['properties'] ? TCompositeUnion<T['properties'][K], Acc[K]> : Acc[K];
+export type TCompositeArray<T extends readonly TObject[]> = {
+    [K in keyof T]: T[K] extends TObject<infer P> ? P : {};
 };
-export type TCompositeUnionObject<T extends TObject, Acc extends TProperties> = Evaluate<TCompositeUnionLeft<T, Acc> & TCompositeUnionRight<T, Acc>>;
-export type TCompositeProperties<T extends TObject[], Acc extends TProperties> = T extends [...infer L, infer R] ? TCompositeProperties<Assert<L, TObject[]>, TCompositeUnionObject<Assert<R, TObject>, Acc>> : T extends [] ? Acc : never;
-export type TComposite<T extends TObject[] = TObject[]> = Ensure<TObject<TCompositeProperties<T, {}>>>;
+export type TCompositeProperties<I extends unknown, T extends readonly any[]> = Evaluate<T extends [infer A, ...infer B] ? TCompositeProperties<I & A, B> : I extends object ? I : {}>;
+export interface TComposite<T extends TObject[] = TObject[]> extends TObject {
+    [Hint]: 'Composite';
+    static: Evaluate<TCompositeProperties<unknown, TCompositeEvaluateArray<T, this['params']>>>;
+    properties: TCompositeProperties<unknown, TCompositeArray<T>>;
+}
 export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
 }];
@@ -169,7 +171,7 @@ export type TKeyOfTuple<T extends TSchema> = {
 } extends infer U ? UnionToTuple<Exclude<{
     [K in keyof U]: U[K];
 }[keyof U], undefined>> : never;
-export type TKeyOf<T extends TSchema = TSchema> = (T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : [
+export type TKeyOf<T extends TSchema = TSchema> = (T extends TComposite ? TKeyOfTuple<T> : T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : [
 ]) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
 export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
@@ -180,13 +182,7 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
 export interface TNever extends TSchema {
     [Kind]: 'Never';
     static: never;
-    allOf: [{
-        type: 'boolean';
-        const: false;
-    }, {
-        type: 'boolean';
-        const: true;
-    }];
+    not: {};
 }
 export type TNotStatic<_ extends TSchema = TSchema, T extends TSchema = TSchema> = Static<T>;
 export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
@@ -241,22 +237,25 @@ export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
     [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
 }, TSchema[]>;
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
-export type TOmit<T extends TSchema, K extends keyof any> = T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
+export type TOmit<T extends TSchema, K extends keyof any> = T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
 export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
+export type TPartialObjectArray<T extends TObject[]> = Assert<{
+    [K in keyof T]: TPartial<Assert<T[K], TObject>>;
+}, TObject[]>;
 export type TPartialArray<T extends TSchema[]> = Assert<{
     [K in keyof T]: TPartial<Assert<T[K], TSchema>>;
 }, TSchema[]>;
 export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
 }, TProperties>>;
-export type TPartial<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
+export type TPartial<T extends TSchema> = T extends TComposite<infer S> ? TComposite<TPartialArray<S>> : T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
 export type TPickArray<T extends TSchema[], K extends keyof any> = {
     [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K>;
 };
 export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
     [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
 }) : never;
-export type TPick<T extends TSchema, K extends keyof any> = T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
+export type TPick<T extends TSchema, K extends keyof any> = T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
 export type TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
@@ -304,7 +303,7 @@ export type TRequiredArray<T extends TSchema[]> = Assert<{
 export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
 }, TProperties>>;
-export type TRequired<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
+export type TRequired<T extends TSchema> = T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
 export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
 export interface StringOptions<Format extends string> extends SchemaOptions {
     minLength?: number;
@@ -531,8 +530,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
     /** `[Standard]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
-    Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
+    /** `[Standard]` Creates a Composite object type. */
+    Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[Standard]` Creates a Enum type */
     Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
     /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */

package/typebox.js

@@ -1465,15 +1465,48 @@ class StandardTypeBuilder extends TypeBuilder {
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
-    Composite(schemas, options) {
+    /** `[Standard]` Creates a Composite object type. */
+    Composite(objects, options) {
+        const isOptionalAll = (objects, key) => objects.every((object) => !(key in object.properties) || IsOptional(object.properties[key]));
+        const IsOptional = (schema) => TypeGuard.TOptional(schema) || TypeGuard.TReadonlyOptional(schema);
+        const [required, optional] = [new Set(), new Set()];
+        for (const object of objects) {
+            for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+                if (isOptionalAll(objects, key))
+                    optional.add(key);
+            }
+        }
+        for (const object of objects) {
+            for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+                if (!optional.has(key))
+                    required.add(key);
+            }
+        }
         const properties = {};
-        for (const object of schemas) {
-            for (const [key, property] of globalThis.Object.entries(object.properties)) {
-                properties[key] = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {});
+        for (const object of objects) {
+            for (const [key, schema] of Object.entries(object.properties)) {
+                const property = TypeClone.Clone(schema, {});
+                if (!optional.has(key))
+                    delete property[exports.Modifier];
+                if (key in properties) {
+                    const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False;
+                    const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False;
+                    if (!left && !right)
+                        properties[key] = exports.Type.Never();
+                    if (!left && right)
+                        properties[key] = property;
+                }
+                else {
+                    properties[key] = property;
+                }
             }
         }
-        return this.Object(properties, options);
+        if (required.size > 0) {
+            return this.Create({ ...options, [exports.Kind]: 'Object', [exports.Hint]: 'Composite', type: 'object', properties, required: [...required] });
+        }
+        else {
+            return this.Create({ ...options, [exports.Kind]: 'Object', [exports.Hint]: 'Composite', type: 'object', properties });
+        }
     }
     /** `[Standard]` Creates a Enum type */
     Enum(item, options = {}) {

package/value/check.js

@@ -53,6 +53,24 @@ var ValueCheck;
     // ----------------------------------------------------------------------
     // Guards
     // ----------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsInteger(value) {
+        return globalThis.Number.isInteger(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    // ----------------------------------------------------------------------
+    // Policies
+    // ----------------------------------------------------------------------
+    function IsExactOptionalProperty(value, key) {
+        return index_1.TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
     function IsObject(value) {
         const result = typeof value === 'object' && value !== null;
         return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
@@ -60,26 +78,14 @@ var ValueCheck;
     function IsRecordObject(value) {
         return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
     }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
     function IsNumber(value) {
         const result = typeof value === 'number';
         return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
     }
-    function IsInteger(value) {
-        return globalThis.Number.isInteger(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
     function IsVoid(value) {
         const result = value === undefined;
         return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
     }
-    function IsDefined(value) {
-        return value !== undefined;
-    }
     // ----------------------------------------------------------------------
     // Types
     // ----------------------------------------------------------------------
@@ -255,7 +261,7 @@ var ValueCheck;
                 }
             }
             else {
-                if (knownKey in value && !Visit(property, references, value[knownKey])) {
+                if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
                     return false;
                 }
             }