@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-18

package/build/require/value/clean/clean.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clean = void 0;
 const index_1 = require("../guard/index");
@@ -8,12 +9,21 @@ const index_3 = require("../check/index");
 const index_4 = require("../clone/index");
 const index_5 = require("../deref/index");
 const index_6 = require("../../type/symbols/index");
+// ------------------------------------------------------------------
+// IsSchema
+// ------------------------------------------------------------------
 function IsSchema(schema) {
     return (0, type_1.TSchema)(schema);
 }
+// ------------------------------------------------------------------
+// IsCheckable
+// ------------------------------------------------------------------
 function IsCheckable(schema) {
     return (0, type_1.TSchema)(schema) && schema[index_6.Kind] !== 'Unsafe';
 }
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
 function TArray(schema, references, value) {
     if (!(0, index_1.IsArray)(value))
         return value;
@@ -37,7 +47,7 @@ function TIntersect(schema, references, value) {
 }
 function TObject(schema, references, value) {
     if (!(0, index_1.IsObject)(value) || (0, index_1.IsArray)(value))
-        return value;
+        return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
     for (const key of Object.getOwnPropertyNames(value)) {
         if (key in schema.properties) {
@@ -87,6 +97,7 @@ function TTuple(schema, references, value) {
     for (let i = 0; i < length; i++) {
         value[i] = Visit(schema.items[i], references, value[i]);
     }
+    // prettier-ignore
     return value.length > length
         ? value.slice(0, length)
         : value;
@@ -123,6 +134,7 @@ function Visit(schema, references, value) {
             return value;
     }
 }
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 function Clean(...args) {
     return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
 }

package/build/require/value/clean/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/clone/clone.d.ts

@@ -1 +1,2 @@
+/** Returns a clone of the given value */
 export declare function Clone<T extends unknown>(value: T): T;

package/build/require/value/clone/clone.js

@@ -1,7 +1,11 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clone = void 0;
 const index_1 = require("../guard/index");
+// --------------------------------------------------------------------------
+// Clonable
+// --------------------------------------------------------------------------
 function ObjectType(value) {
     const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)];
     return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
@@ -18,6 +22,10 @@ function DateType(value) {
 function ValueType(value) {
     return value;
 }
+// --------------------------------------------------------------------------
+// Clone
+// --------------------------------------------------------------------------
+/** Returns a clone of the given value */
 function Clone(value) {
     if ((0, index_1.IsArray)(value))
         return ArrayType(value);

package/build/require/value/clone/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/convert/convert.d.ts

@@ -3,5 +3,7 @@ export declare class ValueConvertUnknownTypeError extends Error {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;

package/build/require/value/convert/convert.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Convert = exports.ValueConvertUnknownTypeError = void 0;
 const index_1 = require("../guard/index");
@@ -8,6 +9,9 @@ const index_4 = require("../deref/index");
 const type_1 = require("../../type/guard/type");
 const index_5 = require("../../type/symbols/index");
 const index_6 = require("../../type/composite/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class ValueConvertUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
@@ -15,6 +19,9 @@ class ValueConvertUnknownTypeError extends Error {
     }
 }
 exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
+// ------------------------------------------------------------------
+// Conversions
+// ------------------------------------------------------------------
 function IsStringNumeric(value) {
     return (0, index_1.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
@@ -42,6 +49,9 @@ function IsDateTimeStringWithoutTimeZone(value) {
 function IsDateString(value) {
     return (0, index_1.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
+// ------------------------------------------------------------------
+// Convert
+// ------------------------------------------------------------------
 function TryConvertLiteralString(value, target) {
     const conversion = TryConvertString(value);
     return conversion === target ? conversion : value;
@@ -54,6 +64,7 @@ function TryConvertLiteralBoolean(value, target) {
     const conversion = TryConvertBoolean(value);
     return conversion === target ? conversion : value;
 }
+// prettier-ignore
 function TryConvertLiteral(schema, value) {
     return ((0, index_1.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
         (0, index_1.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
@@ -81,6 +92,14 @@ function TryConvertNull(value) {
 function TryConvertUndefined(value) {
     return (0, index_1.IsString)(value) && value === 'undefined' ? undefined : value;
 }
+// ------------------------------------------------------------------
+// note: this function may return an invalid dates for the regex
+// tests above. Invalid dates will however be checked during the
+// casting function and will return a epoch date if invalid.
+// Consider better string parsing for the iso dates in future
+// revisions.
+// ------------------------------------------------------------------
+// prettier-ignore
 function TryConvertDate(value) {
     return ((0, index_1.IsDate)(value) ? value :
         (0, index_1.IsNumber)(value) ? new Date(value) :
@@ -94,9 +113,15 @@ function TryConvertDate(value) {
                                         IsDateString(value) ? new Date(`${value}T00:00:00.000Z`) :
                                             value);
 }
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
 function Default(value) {
     return value;
 }
+// ------------------------------------------------------------------
+// Convert
+// ------------------------------------------------------------------
 function TArray(schema, references, value) {
     if ((0, index_1.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
@@ -115,11 +140,12 @@ function TDate(schema, references, value) {
 function TInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
     const allObjects = schema.allOf.every(schema => (0, type_1.TObject)(schema));
     if (allObjects)
         return Visit((0, index_6.Composite)(schema.allOf), references, value);
-    return Visit(schema.allOf[0], references, value);
+    return Visit(schema.allOf[0], references, value); // todo: fix this
 }
 function TLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
@@ -130,6 +156,7 @@ function TNull(schema, references, value) {
 function TNumber(schema, references, value) {
     return TryConvertNumber(value);
 }
+// prettier-ignore
 function TObject(schema, references, value) {
     const isConvertable = (0, index_1.IsObject)(value);
     if (!isConvertable)
@@ -161,6 +188,7 @@ function TSymbol(schema, references, value) {
 function TThis(schema, references, value) {
     return Visit((0, index_4.Deref)(schema, references), references, value);
 }
+// prettier-ignore
 function TTuple(schema, references, value) {
     const isConvertable = (0, index_1.IsArray)(value) && !(0, index_1.IsUndefined)(schema.items);
     if (!isConvertable)
@@ -227,6 +255,8 @@ function Visit(schema, references, value) {
             return Default(value);
     }
 }
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+// prettier-ignore
 function Convert(...args) {
     return args.length === 3
         ? Visit(args[0], args[1], args[2])

package/build/require/value/convert/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/create/create.d.ts

@@ -25,5 +25,7 @@ export declare class ValueCreateRecursiveInstantiationError extends Error {
     readonly recursiveMaxDepth: number;
     constructor(schema: TSchema, recursiveMaxDepth: number);
 }
+/** Creates a value from the given schema and references */
 export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+/** Creates a value from the given schema */
 export declare function Create<T extends TSchema>(schema: T): Static<T>;

package/build/require/value/create/create.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Create = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const index_1 = require("../guard/index");
@@ -8,6 +9,9 @@ const index_4 = require("../../type/template-literal/index");
 const index_5 = require("../../type/patterns/index");
 const index_6 = require("../../type/registry/index");
 const index_7 = require("../../type/symbols/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class ValueCreateUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
@@ -51,6 +55,9 @@ class ValueCreateRecursiveInstantiationError extends Error {
     }
 }
 exports.ValueCreateRecursiveInstantiationError = ValueCreateRecursiveInstantiationError;
+// ------------------------------------------------------------------
+// Create
+// ------------------------------------------------------------------
 function TAny(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
@@ -159,6 +166,13 @@ function TIntersect(schema, references) {
         return schema.default;
     }
     else {
+        // --------------------------------------------------------------
+        // Note: The best we can do here is attempt to instance each
+        // sub type and apply through object assign. For non-object
+        // sub types, we just escape the assignment and just return
+        // the value. In the latter case, this is typically going to
+        // be a consequence of an illogical intersection.
+        // --------------------------------------------------------------
         const value = schema.allOf.reduce((acc, schema) => {
             const next = Visit(schema, references);
             return typeof next === 'object' ? { ...acc, ...next } : next;
@@ -454,8 +468,12 @@ function Visit(schema, references) {
             return TKind(schema_, references_);
     }
 }
+// ------------------------------------------------------------------
+// State
+// ------------------------------------------------------------------
 const recursiveMaxDepth = 512;
 let recursiveDepth = 0;
+/** Creates a value from the given schema */
 function Create(...args) {
     recursiveDepth = 0;
     return args.length === 2 ? Visit(args[0], args[1]) : Visit(args[0], []);

package/build/require/value/create/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/default/default.d.ts

@@ -1,3 +1,5 @@
 import type { TSchema } from '../../type/schema/index';
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;

package/build/require/value/default/default.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Default = void 0;
 const index_1 = require("../guard/index");
@@ -6,15 +7,27 @@ const type_1 = require("../../type/guard/type");
 const index_2 = require("../check/index");
 const index_3 = require("../deref/index");
 const index_4 = require("../../type/symbols/index");
+// ------------------------------------------------------------------
+// ValueOrDefault
+// ------------------------------------------------------------------
 function ValueOrDefault(schema, value) {
     return !(value === undefined) || !('default' in schema) ? value : schema.default;
 }
+// ------------------------------------------------------------------
+// IsCheckable
+// ------------------------------------------------------------------
 function IsCheckable(schema) {
     return (0, type_1.TSchema)(schema) && schema[index_4.Kind] !== 'Unsafe';
 }
+// ------------------------------------------------------------------
+// IsDefaultSchema
+// ------------------------------------------------------------------
 function IsDefaultSchema(value) {
     return (0, type_1.TSchema)(value) && 'default' in value;
 }
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
 function TArray(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!(0, index_1.IsArray)(defaulted))
@@ -37,13 +50,16 @@ function TObject(schema, references, value) {
         return defaulted;
     const additionalPropertiesSchema = schema.additionalProperties;
     const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
+    // properties
     for (const key of knownPropertyKeys) {
         if (!IsDefaultSchema(schema.properties[key]))
             continue;
         defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
     }
+    // return if not additional properties
     if (!IsDefaultSchema(additionalPropertiesSchema))
         return defaulted;
+    // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (knownPropertyKeys.includes(key))
             continue;
@@ -58,13 +74,16 @@ function TRecord(schema, references, value) {
     const additionalPropertiesSchema = schema.additionalProperties;
     const [propertyKeyPattern, propertySchema] = Object.entries(schema.patternProperties)[0];
     const knownPropertyKey = new RegExp(propertyKeyPattern);
+    // properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (!(knownPropertyKey.test(key) && IsDefaultSchema(propertySchema)))
             continue;
         defaulted[key] = Visit(propertySchema, references, defaulted[key]);
     }
+    // return if not additional properties
     if (!IsDefaultSchema(additionalPropertiesSchema))
         return defaulted;
+    // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (knownPropertyKey.test(key))
             continue;
@@ -123,6 +142,7 @@ function Visit(schema, references, value) {
             return ValueOrDefault(schema_, value);
     }
 }
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 function Default(...args) {
     return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
 }

package/build/require/value/default/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/delta/delta.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Patch = exports.Diff = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
 const index_1 = require("../guard/index");
@@ -24,6 +25,9 @@ exports.Delete = (0, index_5.Object)({
     path: (0, index_6.String)(),
 });
 exports.Edit = (0, index_8.Union)([exports.Insert, exports.Update, exports.Delete]);
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class ValueDeltaObjectWithSymbolKeyError extends Error {
     constructor(key) {
         super('Cannot diff objects with symbol keys');
@@ -38,6 +42,9 @@ class ValueDeltaUnableToDiffUnknownValue extends Error {
     }
 }
 exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
+// ------------------------------------------------------------------
+// Command Factory
+// ------------------------------------------------------------------
 function CreateUpdate(path, value) {
     return { type: 'update', path, value };
 }
@@ -47,6 +54,9 @@ function CreateInsert(path, value) {
 function CreateDelete(path) {
     return { type: 'delete', path };
 }
+// ------------------------------------------------------------------
+// Diffing Generators
+// ------------------------------------------------------------------
 function* ObjectType(path, current, next) {
     if (!(0, index_1.IsPlainObject)(next))
         return yield CreateUpdate(path, next);
@@ -118,10 +128,16 @@ function* Visit(path, current, next) {
         return yield* ValueType(path, current, next);
     throw new ValueDeltaUnableToDiffUnknownValue(current);
 }
+// ------------------------------------------------------------------
+// Diff
+// ------------------------------------------------------------------
 function Diff(current, next) {
     return [...Visit('', current, next)];
 }
 exports.Diff = Diff;
+// ------------------------------------------------------------------
+// Patch
+// ------------------------------------------------------------------
 function IsRootUpdate(edits) {
     return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
 }

package/build/require/value/delta/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/deref/deref.d.ts

@@ -5,4 +5,5 @@ export declare class TypeDereferenceError extends Error {
     readonly schema: TRef | TThis;
     constructor(schema: TRef | TThis);
 }
+/** Dereferences a schema from the references array or throws if not found */
 export declare function Deref(schema: TRef | TThis, references: TSchema[]): TSchema;

package/build/require/value/deref/deref.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deref = exports.TypeDereferenceError = void 0;
 class TypeDereferenceError extends Error {
@@ -8,6 +9,7 @@ class TypeDereferenceError extends Error {
     }
 }
 exports.TypeDereferenceError = TypeDereferenceError;
+/** Dereferences a schema from the references array or throws if not found */
 function Deref(schema, references) {
     const index = references.findIndex((target) => target.$id === schema.$ref);
     if (index === -1)

package/build/require/value/deref/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/equal/equal.d.ts

@@ -1 +1,2 @@
+/** Returns true if the left value deep-equals the right */
 export declare function Equal<T>(left: T, right: unknown): right is T;

package/build/require/value/equal/equal.js

@@ -1,7 +1,11 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Equal = void 0;
 const index_1 = require("../guard/index");
+// ------------------------------------------------------------------
+// Equality Checks
+// ------------------------------------------------------------------
 function ObjectType(left, right) {
     if (!(0, index_1.IsPlainObject)(right))
         return false;
@@ -27,6 +31,10 @@ function TypedArrayType(left, right) {
 function ValueType(left, right) {
     return left === right;
 }
+// ------------------------------------------------------------------
+// Equal
+// ------------------------------------------------------------------
+/** Returns true if the left value deep-equals the right */
 function Equal(left, right) {
     if ((0, index_1.IsPlainObject)(left))
         return ObjectType(left, right);

package/build/require/value/equal/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/guard/guard.d.ts

@@ -2,23 +2,43 @@ export type ObjectType = Record<PropertyKey, unknown>;
 export type ArrayType = unknown[];
 export type ValueType = null | undefined | symbol | bigint | number | boolean | string;
 export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/** Returns true if this value is an async iterator */
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
+/** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<any>;
+/** Returns true if this value is a typed array */
 export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if this value is a Promise */
 export declare function IsPromise(value: unknown): value is Promise<unknown>;
+/** Returns true if the value is a Uint8Array */
 export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if this value is a Date */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value has this property key */
 export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
+/** Returns true if this object is not an instance of any other type */
 export declare function IsPlainObject(value: unknown): value is ObjectType;
+/** Returns true of this value is an object type */
 export declare function IsObject(value: unknown): value is ObjectType;
+/** Returns true if this value is an array, but not a typed array */
 export declare function IsArray(value: unknown): value is ArrayType;
+/** Returns true if this value is an undefined */
 export declare function IsUndefined(value: unknown): value is undefined;
+/** Returns true if this value is an null */
 export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is an boolean */
 export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is an number */
 export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an integer */
 export declare function IsInteger(value: unknown): value is number;
+/** Returns true if this value is bigint */
 export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is string */
 export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is a function */
 export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is a symbol */
 export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a value type such as number, string, boolean */
 export declare function IsValueType(value: unknown): value is ValueType;