@sinclair/typebox 0.32.0-dev-15 → 0.32.0-dev-17

package/build/require/value/transform/decode.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformDecode = exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
 const type_1 = require("../../type/guard/type");
@@ -8,6 +35,10 @@ const index_3 = require("../../type/keyof/index");
 const index_4 = require("../../type/indexed/index");
 const index_5 = require("../deref/index");
 const index_6 = require("../check/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+// thrown externally
 class TransformDecodeCheckError extends Error {
     constructor(schema, value, error) {
         super(`Unable to decode due to invalid value`);
@@ -25,6 +56,10 @@ class TransformDecodeError extends Error {
     }
 }
 exports.TransformDecodeError = TransformDecodeError;
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+// prettier-ignore
 function Default(schema, value) {
     try {
         return (0, type_1.TTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
@@ -33,11 +68,13 @@ function Default(schema, value) {
         throw new TransformDecodeError(schema, value, error);
     }
 }
+// prettier-ignore
 function TArray(schema, references, value) {
     return ((0, index_2.IsArray)(value))
         ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
         : Default(schema, value);
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
         return Default(schema, value);
@@ -62,6 +99,7 @@ function TIntersect(schema, references, value) {
 function TNot(schema, references, value) {
     return Default(schema, Visit(schema.not, references, value));
 }
+// prettier-ignore
 function TObject(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value))
         return Default(schema, value);
@@ -83,6 +121,7 @@ function TObject(schema, references, value) {
     }, knownProperties);
     return Default(schema, unknownProperties);
 }
+// prettier-ignore
 function TRecord(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value))
         return Default(schema, value);
@@ -105,28 +144,34 @@ function TRecord(schema, references, value) {
     }, knownProperties);
     return Default(schema, unknownProperties);
 }
+// prettier-ignore
 function TRef(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
+// prettier-ignore
 function TThis(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
+// prettier-ignore
 function TTuple(schema, references, value) {
     return ((0, index_2.IsArray)(value) && (0, index_2.IsArray)(schema.items))
         ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
         : Default(schema, value);
 }
+// prettier-ignore
 function TUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
         if (!(0, index_6.Check)(subschema, references, value))
             continue;
+        // note: ensure interior is decoded first
         const decoded = Visit(subschema, references, value);
         return Default(schema, decoded);
     }
     return Default(schema, value);
 }
+// prettier-ignore
 function Visit(schema, references, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
@@ -155,6 +200,11 @@ function Visit(schema, references, value) {
             return Default(schema_, value);
     }
 }
+/**
+ * `[Internal]` Decodes the value and returns the result. This function requires that
+ * the caller `Check` the value before use. Passing unchecked values may result in
+ * undefined behavior. Refer to the `Value.Decode()` for implementation details.
+ */
 function TransformDecode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/require/value/transform/encode.d.ts

@@ -11,4 +11,10 @@ export declare class TransformEncodeError extends Error {
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);
 }
+/**
+ * `[Internal]` Encodes the value and returns the result. This function expects the
+ * caller to pass a statically checked value. This function does not check the encoded
+ * result, meaning the result should be passed to `Check` before use. Refer to the
+ * `Value.Encode()` function for implementation details.
+ */
 export declare function TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/require/value/transform/encode.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformEncode = exports.TransformEncodeError = exports.TransformEncodeCheckError = void 0;
 const type_1 = require("../../type/guard/type");
@@ -8,6 +35,9 @@ const index_3 = require("../../type/keyof/index");
 const index_4 = require("../../type/indexed/index");
 const index_5 = require("../deref/index");
 const index_6 = require("../check/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class TransformEncodeCheckError extends Error {
     constructor(schema, value, error) {
         super(`Unable to encode due to invalid value`);
@@ -25,6 +55,10 @@ class TransformEncodeError extends Error {
     }
 }
 exports.TransformEncodeError = TransformEncodeError;
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+// prettier-ignore
 function Default(schema, value) {
     try {
         return (0, type_1.TTransform)(schema) ? schema[index_1.TransformKind].Encode(value) : value;
@@ -33,12 +67,14 @@ function Default(schema, value) {
         throw new TransformEncodeError(schema, value, error);
     }
 }
+// prettier-ignore
 function TArray(schema, references, value) {
     const defaulted = Default(schema, value);
     return (0, index_2.IsArray)(defaulted)
         ? defaulted.map((value) => Visit(schema.items, references, value))
         : defaulted;
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
@@ -60,9 +96,11 @@ function TIntersect(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TNot(schema, references, value) {
     return Default(schema.not, Default(schema, value));
 }
+// prettier-ignore
 function TObject(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value))
@@ -84,6 +122,7 @@ function TObject(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TRecord(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value))
@@ -106,27 +145,33 @@ function TRecord(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TRef(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     const resolved = Visit(target, references, value);
     return Default(schema, resolved);
 }
+// prettier-ignore
 function TThis(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     const resolved = Visit(target, references, value);
     return Default(schema, resolved);
 }
+// prettier-ignore
 function TTuple(schema, references, value) {
     const value1 = Default(schema, value);
     return (0, index_2.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
 }
+// prettier-ignore
 function TUnion(schema, references, value) {
+    // test value against union variants
     for (const subschema of schema.anyOf) {
         if (!(0, index_6.Check)(subschema, references, value))
             continue;
         const value1 = Visit(subschema, references, value);
         return Default(schema, value1);
     }
+    // test transformed value against union variants
     for (const subschema of schema.anyOf) {
         const value1 = Visit(subschema, references, value);
         if (!(0, index_6.Check)(schema, references, value1))
@@ -135,6 +180,7 @@ function TUnion(schema, references, value) {
     }
     return Default(schema, value);
 }
+// prettier-ignore
 function Visit(schema, references, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
@@ -161,6 +207,12 @@ function Visit(schema, references, value) {
             return Default(schema_, value);
     }
 }
+/**
+ * `[Internal]` Encodes the value and returns the result. This function expects the
+ * caller to pass a statically checked value. This function does not check the encoded
+ * result, meaning the result should be passed to `Check` before use. Refer to the
+ * `Value.Encode()` function for implementation details.
+ */
 function TransformEncode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/require/value/transform/has.d.ts

@@ -1,2 +1,3 @@
 import type { TSchema } from '../../type/schema/index';
+/** Returns true if this schema contains a transform codec */
 export declare function HasTransform(schema: TSchema, references: TSchema[]): boolean;

package/build/require/value/transform/has.js

@@ -1,60 +1,102 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasTransform = void 0;
 const type_1 = require("../../type/guard/type");
 const index_1 = require("../guard/index");
 const index_2 = require("../deref/index");
 const index_3 = require("../../type/symbols/index");
+// prettier-ignore
 function TArray(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TAsyncIterator(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TConstructor(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TFunction(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TIntersect(schema, references) {
     return (0, type_1.TTransform)(schema) || (0, type_1.TTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TIterator(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TNot(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.not, references);
 }
+// prettier-ignore
 function TObject(schema, references) {
     return ((0, type_1.TTransform)(schema) ||
         Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
         ((0, type_1.TSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
 }
+// prettier-ignore
 function TPromise(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.item, references);
 }
+// prettier-ignore
 function TRecord(schema, references) {
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[pattern];
     return (0, type_1.TTransform)(schema) || Visit(property, references) || ((0, type_1.TSchema)(schema.additionalProperties) && (0, type_1.TTransform)(schema.additionalProperties));
 }
+// prettier-ignore
 function TRef(schema, references) {
     if ((0, type_1.TTransform)(schema))
         return true;
     return Visit((0, index_2.Deref)(schema, references), references);
 }
+// prettier-ignore
 function TThis(schema, references) {
     if ((0, type_1.TTransform)(schema))
         return true;
     return Visit((0, index_2.Deref)(schema, references), references);
 }
+// prettier-ignore
 function TTuple(schema, references) {
     return (0, type_1.TTransform)(schema) || (!(0, index_1.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
 }
+// prettier-ignore
 function TUnion(schema, references) {
     return (0, type_1.TTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function Visit(schema, references) {
     const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
@@ -96,6 +138,7 @@ function Visit(schema, references) {
     }
 }
 const visited = new Set();
+/** Returns true if this schema contains a transform codec */
 function HasTransform(schema, references) {
     visited.clear();
     return Visit(schema, references);

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

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 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/value/index.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
 exports.Value = require("./value");

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

@@ -3,27 +3,51 @@ import { Edit } from '../delta/index';
 import { ValueErrorIterator } from '../../errors/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static, StaticDecode, StaticEncode } from '../../type/static/index';
+/** 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. */
 export declare function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>;
+/** Creates a value from the given type and references */
 export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+/** Creates a value from the given type */
 export declare function Create<T extends TSchema>(schema: T): Static<T>;
+/** Returns true if the value matches the given type and references */
 export declare function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>;
+/** Returns true if the value matches the given type */
 export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;
+/** `[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<T extends TSchema>(schema: T, 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<T extends TSchema>(schema: T, 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, references: TSchema[], value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
 export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
+/** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+/** `[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;
+/** Encodes a value or throws if error */
 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;
+/** 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. */
 export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;
+/** Returns true if left and right values are structurally equal */
 export declare function Equal<T>(left: T, right: unknown): right is T;
+/** Returns edits to transform the current value into the next value */
 export declare function Diff(current: unknown, next: unknown): Edit[];
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
 export declare function Hash(value: unknown): bigint;
+/** Returns a new value with edits applied to the given value */
 export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 export declare function Mutate(current: Mutable, next: Mutable): void;

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

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mutate = exports.Patch = exports.Hash = exports.Diff = exports.Equal = exports.Errors = exports.Encode = exports.Default = exports.Decode = exports.Clone = exports.Convert = exports.Clean = exports.Check = exports.Create = exports.Cast = void 0;
 const index_1 = require("../transform/index");
@@ -14,30 +41,37 @@ const index_10 = require("../check/index");
 const index_11 = require("../default/index");
 const index_12 = require("../delta/index");
 const index_13 = require("../../errors/index");
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 function Cast(...args) {
     return index_5.Cast.apply(index_5.Cast, args);
 }
 exports.Cast = Cast;
+/** Creates a value from the given type */
 function Create(...args) {
     return index_8.Create.apply(index_8.Create, args);
 }
 exports.Create = Create;
+/** Returns true if the value matches the given type */
 function Check(...args) {
     return index_10.Check.apply(index_10.Check, args);
 }
 exports.Check = Check;
+/** `[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 index_9.Clean.apply(index_9.Clean, args);
 }
 exports.Clean = Clean;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
 function Convert(...args) {
     return index_7.Convert.apply(index_7.Convert, args);
 }
 exports.Convert = Convert;
+/** Returns a structural clone of the given value */
 function Clone(value) {
     return (0, index_6.Clone)(value);
 }
 exports.Clone = Clone;
+/** Decodes a value or throws if error */
 function Decode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     if (!Check(schema, references, value))
@@ -45,10 +79,12 @@ function Decode(...args) {
     return (0, index_1.TransformDecode)(schema, references, value);
 }
 exports.Decode = Decode;
+/** `[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 index_11.Default.apply(index_11.Default, args);
 }
 exports.Default = Default;
+/** Encodes a value or throws if error */
 function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     const encoded = (0, index_1.TransformEncode)(schema, references, value);
@@ -57,26 +93,32 @@ function Encode(...args) {
     return encoded;
 }
 exports.Encode = Encode;
+/** Returns an iterator for each error in this value. */
 function Errors(...args) {
     return index_13.Errors.apply(index_13.Errors, args);
 }
 exports.Errors = Errors;
+/** Returns true if left and right values are structurally equal */
 function Equal(left, right) {
     return (0, index_4.Equal)(left, right);
 }
 exports.Equal = Equal;
+/** Returns edits to transform the current value into the next value */
 function Diff(current, next) {
     return (0, index_12.Diff)(current, next);
 }
 exports.Diff = Diff;
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
 function Hash(value) {
     return (0, index_3.Hash)(value);
 }
 exports.Hash = Hash;
+/** Returns a new value with edits applied to the given value */
 function Patch(current, edits) {
     return (0, index_12.Patch)(current, edits);
 }
 exports.Patch = Patch;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 function Mutate(current, next) {
     (0, index_2.Mutate)(current, next);
 }

package/package.json

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