@sinclair/typebox 0.33.3 → 0.33.5

package/build/esm/value/convert/convert.mjs

@@ -56,7 +56,7 @@ function TryConvertLiteral(schema, value) {
     return (IsString(schema.const) ? TryConvertLiteralString(value, schema.const) :
         IsNumber(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
             IsBoolean(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
-                Clone(value));
+                value);
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
@@ -139,16 +139,14 @@ function FromNumber(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    const isConvertable = IsObject(value);
-    if (!isConvertable)
+    if (!IsObject(value))
         return value;
-    const result = {};
-    for (const key of Object.keys(value)) {
-        result[key] = HasPropertyKey(schema.properties, key)
-            ? Visit(schema.properties[key], references, value[key])
-            : value[key];
+    for (const propertyKey of Object.getOwnPropertyNames(schema.properties)) {
+        if (!HasPropertyKey(value, propertyKey))
+            continue;
+        value[propertyKey] = Visit(schema.properties[propertyKey], references, value[propertyKey]);
     }
-    return result;
+    return value;
 }
 function FromRecord(schema, references, value) {
     const isConvertable = IsObject(value);
@@ -156,11 +154,10 @@ function FromRecord(schema, references, value) {
         return value;
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[propertyKey];
-    const result = {};
     for (const [propKey, propValue] of Object.entries(value)) {
-        result[propKey] = Visit(property, references, propValue);
+        value[propKey] = Visit(property, references, propValue);
     }
-    return result;
+    return value;
 }
 function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
@@ -190,15 +187,19 @@ function FromUndefined(schema, references, value) {
 }
 function FromUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
-        const converted = Visit(subschema, references, value);
+        const converted = Visit(subschema, references, Clone(value));
         if (!Check(subschema, references, converted))
             continue;
         return converted;
     }
     return value;
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 function Visit(schema, references, value) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         case 'Array':
@@ -241,10 +242,8 @@ function Visit(schema, references, value) {
             return Default(value);
     }
 }
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 // prettier-ignore
 export function Convert(...args) {
-    return args.length === 3
-        ? Visit(args[0], args[1], args[2])
-        : Visit(args[0], [], args[1]);
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
 }

package/build/esm/value/create/create.mjs

@@ -380,8 +380,12 @@ function FromKind(schema, references) {
         throw new Error('User defined types must specify a default value');
     }
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 function Visit(schema, references) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Any':

package/build/esm/value/default/default.mjs

@@ -9,7 +9,7 @@ import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsSchema } from '../../type/guard/type.mjs';
+import { IsKind } from '../../type/guard/kind.mjs';
 // ------------------------------------------------------------------
 // ValueOrDefault
 // ------------------------------------------------------------------
@@ -17,16 +17,10 @@ function ValueOrDefault(schema, value) {
     return value === undefined && 'default' in schema ? Clone(schema.default) : value;
 }
 // ------------------------------------------------------------------
-// IsCheckable
+// HasDefaultProperty
 // ------------------------------------------------------------------
-function IsCheckable(schema) {
-    return IsSchema(schema) && schema[Kind] !== 'Unsafe';
-}
-// ------------------------------------------------------------------
-// IsDefaultSchema
-// ------------------------------------------------------------------
-function IsDefaultSchema(value) {
-    return IsSchema(value) && 'default' in value;
+function HasDefaultProperty(schema) {
+    return IsKind(schema) && 'default' in schema;
 }
 // ------------------------------------------------------------------
 // Types
@@ -55,12 +49,12 @@ function FromObject(schema, references, value) {
     const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
     // properties
     for (const key of knownPropertyKeys) {
-        if (!IsDefaultSchema(schema.properties[key]))
+        if (!HasDefaultProperty(schema.properties[key]))
             continue;
         defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
     }
     // return if not additional properties
-    if (!IsDefaultSchema(additionalPropertiesSchema))
+    if (!HasDefaultProperty(additionalPropertiesSchema))
         return defaulted;
     // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
@@ -79,12 +73,12 @@ function FromRecord(schema, references, value) {
     const knownPropertyKey = new RegExp(propertyKeyPattern);
     // properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
-        if (!(knownPropertyKey.test(key) && IsDefaultSchema(propertySchema)))
+        if (!(knownPropertyKey.test(key) && HasDefaultProperty(propertySchema)))
             continue;
         defaulted[key] = Visit(propertySchema, references, defaulted[key]);
     }
     // return if not additional properties
-    if (!IsDefaultSchema(additionalPropertiesSchema))
+    if (!HasDefaultProperty(additionalPropertiesSchema))
         return defaulted;
     // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
@@ -115,14 +109,18 @@ function FromUnion(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     for (const inner of schema.anyOf) {
         const result = Visit(inner, references, defaulted);
-        if (IsCheckable(inner) && Check(inner, result)) {
+        if (Check(inner, result)) {
             return result;
         }
     }
     return defaulted;
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 function Visit(schema, references, value) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Array':

package/build/esm/value/equal/equal.mjs

@@ -1,9 +1,9 @@
-import { IsStandardObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // Equality Checks
 // ------------------------------------------------------------------
 function ObjectType(left, right) {
-    if (!IsStandardObject(right))
+    if (!IsObject(right))
         return false;
     const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
     const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
@@ -32,14 +32,14 @@ function ValueType(left, right) {
 // ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 export function Equal(left, right) {
-    if (IsStandardObject(left))
-        return ObjectType(left, right);
     if (IsDate(left))
         return DateType(left, right);
     if (IsTypedArray(left))
         return TypedArrayType(left, right);
     if (IsArray(left))
         return ArrayType(left, right);
+    if (IsObject(left))
+        return ObjectType(left, right);
     if (IsValueType(left))
         return ValueType(left, right);
     throw new Error('ValueEquals: Unable to compare value');

package/build/esm/value/hash/hash.mjs

@@ -1,4 +1,4 @@
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsStandardObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
@@ -119,7 +119,7 @@ function Visit(value) {
         return NullType(value);
     if (IsNumber(value))
         return NumberType(value);
-    if (IsStandardObject(value))
+    if (IsObject(value))
         return ObjectType(value);
     if (IsString(value))
         return StringType(value);

package/build/esm/value/index.d.mts

@@ -1,5 +1,6 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
 export * from './guard/index.mjs';
+export * from './assert/index.mjs';
 export * from './cast/index.mjs';
 export * from './check/index.mjs';
 export * from './clean/index.mjs';
@@ -11,6 +12,7 @@ export * from './delta/index.mjs';
 export * from './equal/index.mjs';
 export * from './hash/index.mjs';
 export * from './mutate/index.mjs';
+export * from './parse/index.mjs';
 export * from './pointer/index.mjs';
 export * from './transform/index.mjs';
 export { Value } from './value/index.mjs';

package/build/esm/value/index.mjs

@@ -9,6 +9,7 @@ export * from './guard/index.mjs';
 // ------------------------------------------------------------------
 // Operators
 // ------------------------------------------------------------------
+export * from './assert/index.mjs';
 export * from './cast/index.mjs';
 export * from './check/index.mjs';
 export * from './clean/index.mjs';
@@ -20,6 +21,7 @@ export * from './delta/index.mjs';
 export * from './equal/index.mjs';
 export * from './hash/index.mjs';
 export * from './mutate/index.mjs';
+export * from './parse/index.mjs';
 export * from './pointer/index.mjs';
 export * from './transform/index.mjs';
 // ------------------------------------------------------------------

package/build/esm/value/mutate/mutate.mjs

@@ -1,4 +1,4 @@
-import { IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
@@ -11,7 +11,7 @@ export class ValueMutateError extends TypeBoxError {
     }
 }
 function ObjectType(root, path, current, next) {
-    if (!IsStandardObject(current)) {
+    if (!IsObject(current)) {
         ValuePointer.Set(root, path, Clone(next));
     }
     else {
@@ -63,7 +63,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if (IsTypedArray(next))
         return TypedArrayType(root, path, current, next);
-    if (IsStandardObject(next))
+    if (IsObject(next))
         return ObjectType(root, path, current, next);
     if (IsValueType(next))
         return ValueType(root, path, current, next);
@@ -76,8 +76,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return ((IsStandardObject(current) && IsArray(next)) ||
-        (IsArray(current) && IsStandardObject(next)));
+    return ((IsObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/build/esm/value/parse/index.d.mts

@@ -0,0 +1 @@
+export * from './parse.mjs';

package/build/esm/value/parse/index.mjs

@@ -0,0 +1 @@
+export * from './parse.mjs';

package/build/esm/value/parse/parse.d.mts

@@ -0,0 +1,6 @@
+import { TSchema } from '../../type/schema/index.mjs';
+import { StaticDecode } from '../../type/static/index.mjs';
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;

package/build/esm/value/parse/parse.mjs

@@ -0,0 +1,25 @@
+import { TransformDecode, HasTransform } from '../transform/index.mjs';
+import { Assert } from '../assert/assert.mjs';
+import { Default } from '../default/default.mjs';
+import { Convert } from '../convert/convert.mjs';
+import { Clean } from '../clean/clean.mjs';
+import { Clone } from '../clone/index.mjs';
+// prettier-ignore
+const ParseReducer = [
+    (_schema, _references, value) => Clone(value),
+    (schema, references, value) => Default(schema, references, value),
+    (schema, references, value) => Clean(schema, references, value),
+    (schema, references, value) => Convert(schema, references, value),
+    (schema, references, value) => { Assert(schema, references, value); return value; },
+    (schema, references, value) => (HasTransform(schema, references) ? TransformDecode(schema, references, value) : value),
+];
+// ------------------------------------------------------------------
+// ParseValue
+// ------------------------------------------------------------------
+function ParseValue(schema, references, value) {
+    return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value);
+}
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse(...args) {
+    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+}

package/build/esm/value/transform/decode.mjs

@@ -1,3 +1,4 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
@@ -6,11 +7,11 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -54,7 +55,7 @@ function FromArray(schema, references, path, value) {
 }
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
-    if (!IsStandardObject(value) || IsValueType(value))
+    if (!IsObject(value) || IsValueType(value))
         return Default(schema, path, value);
     const knownEntries = KeyOfPropertyEntries(schema);
     const knownKeys = knownEntries.map(entry => entry[0]);
@@ -80,14 +81,22 @@ function FromNot(schema, references, path, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, path, value) {
-    if (!IsStandardObject(value))
+    if (!IsObject(value))
         return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = { ...value };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!HasPropertyKey(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if (IsUndefinedValue(knownProperties[key]) && (!IsUndefined(schema.properties[key]) ||
+            TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // decode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!IsSchema(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
@@ -102,7 +111,7 @@ function FromObject(schema, references, path, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
-    if (!IsStandardObject(value))
+    if (!IsObject(value))
         return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -150,9 +159,13 @@ function FromUnion(schema, references, path, value) {
     }
     return Default(schema, path, value);
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references, path, value) {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
+    const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         case 'Array':

package/build/esm/value/transform/encode.mjs

@@ -1,3 +1,4 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
@@ -6,11 +7,11 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -55,7 +56,7 @@ function FromArray(schema, references, path, value) {
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!IsStandardObject(value) || IsValueType(value))
+    if (!IsObject(value) || IsValueType(value))
         return defaulted;
     const knownEntries = KeyOfPropertyEntries(schema);
     const knownKeys = knownEntries.map(entry => entry[0]);
@@ -83,14 +84,22 @@ function FromNot(schema, references, path, value) {
 // prettier-ignore
 function FromObject(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!IsStandardObject(defaulted))
+    if (!IsObject(defaulted))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = { ...defaulted };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!HasPropertyKey(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if (IsUndefinedValue(knownProperties[key]) && (!IsUndefined(schema.properties[key]) ||
+            TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // encode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!IsSchema(schema.additionalProperties)) {
         return knownProperties;
     }
@@ -106,7 +115,7 @@ function FromObject(schema, references, path, value) {
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!IsStandardObject(value))
+    if (!IsObject(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -116,7 +125,7 @@ function FromRecord(schema, references, path, value) {
             knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
         }
     if (!IsSchema(schema.additionalProperties)) {
-        return Default(schema, path, knownProperties);
+        return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
@@ -162,9 +171,13 @@ function FromUnion(schema, references, path, value) {
     }
     return Default(schema, path, value);
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references, path, value) {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
+    const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         case 'Array':

package/build/esm/value/transform/has.mjs

@@ -72,9 +72,13 @@ function FromTuple(schema, references) {
 function FromUnion(schema, references) {
     return IsTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     if (schema.$id && visited.has(schema.$id))
         return false;

package/build/esm/value/value/value.d.mts

@@ -3,6 +3,10 @@ import { Edit } from '../delta/index.mjs';
 import { ValueErrorIterator } from '../../errors/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { Static, StaticDecode, StaticEncode } from '../../type/static/index.mjs';
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export declare function Assert<T extends TSchema, R = Static<T>>(schema: T, references: TSchema[], value: unknown): asserts value is R;
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export declare function Assert<T extends TSchema, R = Static<T>>(schema: T, value: unknown): asserts value is R;
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
@@ -19,9 +23,9 @@ export declare function Check<T extends TSchema>(schema: T, value: unknown): val
 export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[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. */
 export declare function Clean(schema: TSchema, value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
@@ -37,6 +41,10 @@ export declare function Default(schema: TSchema, value: unknown): unknown;
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
 /** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
 /** Returns an iterator for each error in this value. */

package/build/esm/value/value/value.mjs

@@ -1,4 +1,5 @@
 import { HasTransform, TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
+import { Assert as AssertValue } from '../assert/index.mjs';
 import { Mutate as MutateValue } from '../mutate/index.mjs';
 import { Hash as HashValue } from '../hash/index.mjs';
 import { Equal as EqualValue } from '../equal/index.mjs';
@@ -8,9 +9,14 @@ import { Convert as ConvertValue } from '../convert/index.mjs';
 import { Create as CreateValue } from '../create/index.mjs';
 import { Clean as CleanValue } from '../clean/index.mjs';
 import { Check as CheckValue } from '../check/index.mjs';
+import { Parse as ParseValue } from '../parse/index.mjs';
 import { Default as DefaultValue } from '../default/index.mjs';
 import { Diff as DiffValue, Patch as PatchValue } from '../delta/index.mjs';
 import { Errors as ValueErrors } from '../../errors/index.mjs';
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export function Assert(...args) {
+    return AssertValue.apply(AssertValue, args);
+}
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export function Cast(...args) {
     return CastValue.apply(CastValue, args);
@@ -27,7 +33,7 @@ export function Check(...args) {
 export function Clean(...args) {
     return CleanValue.apply(CleanValue, args);
 }
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(...args) {
     return ConvertValue.apply(ConvertValue, args);
 }
@@ -54,6 +60,10 @@ export function Encode(...args) {
         throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
     return encoded;
 }
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse(...args) {
+    return ParseValue.apply(ParseValue, args);
+}
 /** Returns an iterator for each error in this value. */
 export function Errors(...args) {
     return ValueErrors.apply(ValueErrors, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.3",
+  "version": "0.33.5",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",