@sinclair/typebox 0.29.6 → 0.30.0-dev-2

package/value/hash.js

@@ -27,7 +27,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueHash = exports.ValueHashError = void 0;
+exports.Hash = exports.ByteMarker = exports.ValueHashError = void 0;
+const ValueGuard = require("./guard");
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 class ValueHashError extends Error {
     constructor(value) {
         super(`Hash: Unable to hash value`);
@@ -35,174 +39,128 @@ class ValueHashError extends Error {
     }
 }
 exports.ValueHashError = ValueHashError;
-var ValueHash;
-(function (ValueHash) {
-    let ByteMarker;
-    (function (ByteMarker) {
-        ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
-        ByteMarker[ByteMarker["Null"] = 1] = "Null";
-        ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
-        ByteMarker[ByteMarker["Number"] = 3] = "Number";
-        ByteMarker[ByteMarker["String"] = 4] = "String";
-        ByteMarker[ByteMarker["Object"] = 5] = "Object";
-        ByteMarker[ByteMarker["Array"] = 6] = "Array";
-        ByteMarker[ByteMarker["Date"] = 7] = "Date";
-        ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
-        ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
-        ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
-    })(ByteMarker || (ByteMarker = {}));
-    // ----------------------------------------------------
-    // State
-    // ----------------------------------------------------
-    let Hash = globalThis.BigInt('14695981039346656037');
-    const [Prime, Size] = [globalThis.BigInt('1099511628211'), globalThis.BigInt('2') ** globalThis.BigInt('64')];
-    const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i));
-    const F64 = new globalThis.Float64Array(1);
-    const F64In = new globalThis.DataView(F64.buffer);
-    const F64Out = new globalThis.Uint8Array(F64.buffer);
-    // ----------------------------------------------------
-    // Guards
-    // ----------------------------------------------------
-    function IsDate(value) {
-        return value instanceof globalThis.Date;
+// --------------------------------------------------------------------------
+// ByteMarker
+// --------------------------------------------------------------------------
+var ByteMarker;
+(function (ByteMarker) {
+    ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
+    ByteMarker[ByteMarker["Null"] = 1] = "Null";
+    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+    ByteMarker[ByteMarker["Number"] = 3] = "Number";
+    ByteMarker[ByteMarker["String"] = 4] = "String";
+    ByteMarker[ByteMarker["Object"] = 5] = "Object";
+    ByteMarker[ByteMarker["Array"] = 6] = "Array";
+    ByteMarker[ByteMarker["Date"] = 7] = "Date";
+    ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
+    ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
+    ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
+})(ByteMarker || (exports.ByteMarker = ByteMarker = {}));
+// --------------------------------------------------------------------------
+// State
+// --------------------------------------------------------------------------
+let Accumulator = BigInt('14695981039346656037');
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('2') ** BigInt('64')];
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+const F64In = new DataView(F64.buffer);
+const F64Out = new Uint8Array(F64.buffer);
+// --------------------------------------------------------------------------
+// Hashing Functions
+// --------------------------------------------------------------------------
+function ArrayType(value) {
+    FNV1A64(ByteMarker.Array);
+    for (const item of value) {
+        Visit(item);
     }
-    function IsUint8Array(value) {
-        return value instanceof globalThis.Uint8Array;
-    }
-    function IsArray(value) {
-        return globalThis.Array.isArray(value);
-    }
-    function IsBoolean(value) {
-        return typeof value === 'boolean';
-    }
-    function IsNull(value) {
-        return value === null;
-    }
-    function IsNumber(value) {
-        return typeof value === 'number';
-    }
-    function IsSymbol(value) {
-        return typeof value === 'symbol';
-    }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    function IsUndefined(value) {
-        return value === undefined;
-    }
-    // ----------------------------------------------------
-    // Encoding
-    // ----------------------------------------------------
-    function Array(value) {
-        FNV1A64(ByteMarker.Array);
-        for (const item of value) {
-            Visit(item);
-        }
-    }
-    function Boolean(value) {
-        FNV1A64(ByteMarker.Boolean);
-        FNV1A64(value ? 1 : 0);
-    }
-    function BigInt(value) {
-        FNV1A64(ByteMarker.BigInt);
-        F64In.setBigInt64(0, value);
-        for (const byte of F64Out) {
-            FNV1A64(byte);
-        }
-    }
-    function Date(value) {
-        FNV1A64(ByteMarker.Date);
-        Visit(value.getTime());
-    }
-    function Null(value) {
-        FNV1A64(ByteMarker.Null);
-    }
-    function Number(value) {
-        FNV1A64(ByteMarker.Number);
-        F64In.setFloat64(0, value);
-        for (const byte of F64Out) {
-            FNV1A64(byte);
-        }
-    }
-    function Object(value) {
-        FNV1A64(ByteMarker.Object);
-        for (const key of globalThis.Object.keys(value).sort()) {
-            Visit(key);
-            Visit(value[key]);
-        }
-    }
-    function String(value) {
-        FNV1A64(ByteMarker.String);
-        for (let i = 0; i < value.length; i++) {
-            FNV1A64(value.charCodeAt(i));
-        }
-    }
-    function Symbol(value) {
-        FNV1A64(ByteMarker.Symbol);
-        Visit(value.description);
-    }
-    function Uint8Array(value) {
-        FNV1A64(ByteMarker.Uint8Array);
-        for (let i = 0; i < value.length; i++) {
-            FNV1A64(value[i]);
-        }
+}
+function BooleanType(value) {
+    FNV1A64(ByteMarker.Boolean);
+    FNV1A64(value ? 1 : 0);
+}
+function BigIntType(value) {
+    FNV1A64(ByteMarker.BigInt);
+    F64In.setBigInt64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64(byte);
     }
-    function Undefined(value) {
-        return FNV1A64(ByteMarker.Undefined);
+}
+function DateType(value) {
+    FNV1A64(ByteMarker.Date);
+    Visit(value.getTime());
+}
+function NullType(value) {
+    FNV1A64(ByteMarker.Null);
+}
+function NumberType(value) {
+    FNV1A64(ByteMarker.Number);
+    F64In.setFloat64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64(byte);
     }
-    function Visit(value) {
-        if (IsArray(value)) {
-            Array(value);
-        }
-        else if (IsBoolean(value)) {
-            Boolean(value);
-        }
-        else if (IsBigInt(value)) {
-            BigInt(value);
-        }
-        else if (IsDate(value)) {
-            Date(value);
-        }
-        else if (IsNull(value)) {
-            Null(value);
-        }
-        else if (IsNumber(value)) {
-            Number(value);
-        }
-        else if (IsObject(value)) {
-            Object(value);
-        }
-        else if (IsString(value)) {
-            String(value);
-        }
-        else if (IsSymbol(value)) {
-            Symbol(value);
-        }
-        else if (IsUint8Array(value)) {
-            Uint8Array(value);
-        }
-        else if (IsUndefined(value)) {
-            Undefined(value);
-        }
-        else {
-            throw new ValueHashError(value);
-        }
+}
+function ObjectType(value) {
+    FNV1A64(ByteMarker.Object);
+    for (const key of globalThis.Object.keys(value).sort()) {
+        Visit(key);
+        Visit(value[key]);
     }
-    function FNV1A64(byte) {
-        Hash = Hash ^ Bytes[byte];
-        Hash = (Hash * Prime) % Size;
+}
+function StringType(value) {
+    FNV1A64(ByteMarker.String);
+    for (let i = 0; i < value.length; i++) {
+        FNV1A64(value.charCodeAt(i));
     }
-    /** Creates a FNV1A-64 non cryptographic hash of the given value */
-    function Create(value) {
-        Hash = globalThis.BigInt('14695981039346656037');
-        Visit(value);
-        return Hash;
+}
+function SymbolType(value) {
+    FNV1A64(ByteMarker.Symbol);
+    Visit(value.description);
+}
+function Uint8ArrayType(value) {
+    FNV1A64(ByteMarker.Uint8Array);
+    for (let i = 0; i < value.length; i++) {
+        FNV1A64(value[i]);
     }
-    ValueHash.Create = Create;
-})(ValueHash || (exports.ValueHash = ValueHash = {}));
+}
+function UndefinedType(value) {
+    return FNV1A64(ByteMarker.Undefined);
+}
+function Visit(value) {
+    if (ValueGuard.IsArray(value))
+        return ArrayType(value);
+    if (ValueGuard.IsBoolean(value))
+        return BooleanType(value);
+    if (ValueGuard.IsBigInt(value))
+        return BigIntType(value);
+    if (ValueGuard.IsDate(value))
+        return DateType(value);
+    if (ValueGuard.IsNull(value))
+        return NullType(value);
+    if (ValueGuard.IsNumber(value))
+        return NumberType(value);
+    if (ValueGuard.IsPlainObject(value))
+        return ObjectType(value);
+    if (ValueGuard.IsString(value))
+        return StringType(value);
+    if (ValueGuard.IsSymbol(value))
+        return SymbolType(value);
+    if (ValueGuard.IsUint8Array(value))
+        return Uint8ArrayType(value);
+    if (ValueGuard.IsUndefined(value))
+        return UndefinedType(value);
+    throw new ValueHashError(value);
+}
+function FNV1A64(byte) {
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
+}
+// --------------------------------------------------------------------------
+// Hash
+// --------------------------------------------------------------------------
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
+function Hash(value) {
+    Accumulator = BigInt('14695981039346656037');
+    Visit(value);
+    return Accumulator;
+}
+exports.Hash = Hash;

package/value/index.d.ts

@@ -1,6 +1,5 @@
-export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index';
-export { ValueHash } from './hash';
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
 export { Edit, Insert, Update, Delete } from './delta';
 export { Mutable } from './mutate';
-export * from './pointer';
-export * from './value';
+export { ValuePointer } from './pointer';
+export { Value } from './value';

package/value/index.js

@@ -26,31 +26,17 @@ 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);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueHash = exports.ValueErrorType = exports.ValueErrorIterator = void 0;
+exports.Value = exports.ValuePointer = exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
-Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
-var hash_1 = require("./hash");
-Object.defineProperty(exports, "ValueHash", { enumerable: true, get: function () { return hash_1.ValueHash; } });
+Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
 var delta_1 = require("./delta");
 Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_1.Edit; } });
 Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_1.Insert; } });
 Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_1.Update; } });
 Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_1.Delete; } });
-__exportStar(require("./pointer"), exports);
-__exportStar(require("./value"), exports);
+var pointer_1 = require("./pointer");
+Object.defineProperty(exports, "ValuePointer", { enumerable: true, get: function () { return pointer_1.ValuePointer; } });
+var value_1 = require("./value");
+Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return value_1.Value; } });

package/value/mutate.d.ts

@@ -7,7 +7,5 @@ export declare class ValueMutateInvalidRootMutationError extends Error {
 export type Mutable = {
     [key: string]: unknown;
 } | unknown[];
-export declare namespace ValueMutate {
-    /** Performs a deep mutable value assignment while retaining internal references. */
-    function Mutate(current: Mutable, next: Mutable): void;
-}
+/** Performs a deep mutable value assignment while retaining internal references */
+export declare function Mutate(current: Mutable, next: Mutable): void;

package/value/mutate.js

@@ -27,10 +27,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueMutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
-const is_1 = require("./is");
+exports.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
 const pointer_1 = require("./pointer");
-const clone_1 = require("./clone");
+const ValueClone = require("./clone");
+const ValueGuard = require("./guard");
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 class ValueMutateTypeMismatchError extends Error {
     constructor() {
         super('ValueMutate: Cannot assign due type mismatch of assignable values');
@@ -43,79 +46,84 @@ class ValueMutateInvalidRootMutationError extends Error {
     }
 }
 exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
-var ValueMutate;
-(function (ValueMutate) {
-    function Object(root, path, current, next) {
-        if (!is_1.Is.Object(current)) {
-            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
-        }
-        else {
-            const currentKeys = globalThis.Object.keys(current);
-            const nextKeys = globalThis.Object.keys(next);
-            for (const currentKey of currentKeys) {
-                if (!nextKeys.includes(currentKey)) {
-                    delete current[currentKey];
-                }
-            }
-            for (const nextKey of nextKeys) {
-                if (!currentKeys.includes(nextKey)) {
-                    current[nextKey] = null;
-                }
-            }
-            for (const nextKey of nextKeys) {
-                Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
-            }
-        }
+function ObjectType(root, path, current, next) {
+    if (!ValueGuard.IsPlainObject(current)) {
+        pointer_1.ValuePointer.Set(root, path, ValueClone.Clone(next));
     }
-    function Array(root, path, current, next) {
-        if (!is_1.Is.Array(current)) {
-            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
-        }
-        else {
-            for (let index = 0; index < next.length; index++) {
-                Visit(root, `${path}/${index}`, current[index], next[index]);
+    else {
+        const currentKeys = Object.keys(current);
+        const nextKeys = Object.keys(next);
+        for (const currentKey of currentKeys) {
+            if (!nextKeys.includes(currentKey)) {
+                delete current[currentKey];
             }
-            current.splice(next.length);
         }
-    }
-    function TypedArray(root, path, current, next) {
-        if (is_1.Is.TypedArray(current) && current.length === next.length) {
-            for (let i = 0; i < current.length; i++) {
-                current[i] = next[i];
+        for (const nextKey of nextKeys) {
+            if (!currentKeys.includes(nextKey)) {
+                current[nextKey] = null;
             }
         }
-        else {
-            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        for (const nextKey of nextKeys) {
+            Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
         }
     }
-    function Value(root, path, current, next) {
-        if (current === next)
-            return;
-        pointer_1.ValuePointer.Set(root, path, next);
+}
+function ArrayType(root, path, current, next) {
+    if (!ValueGuard.IsArray(current)) {
+        pointer_1.ValuePointer.Set(root, path, ValueClone.Clone(next));
     }
-    function Visit(root, path, current, next) {
-        if (is_1.Is.Array(next)) {
-            return Array(root, path, current, next);
-        }
-        else if (is_1.Is.TypedArray(next)) {
-            return TypedArray(root, path, current, next);
-        }
-        else if (is_1.Is.Object(next)) {
-            return Object(root, path, current, next);
-        }
-        else if (is_1.Is.Value(next)) {
-            return Value(root, path, current, next);
+    else {
+        for (let index = 0; index < next.length; index++) {
+            Visit(root, `${path}/${index}`, current[index], next[index]);
         }
+        current.splice(next.length);
     }
-    /** Performs a deep mutable value assignment while retaining internal references. */
-    function Mutate(current, next) {
-        if (is_1.Is.TypedArray(current) || is_1.Is.Value(current) || is_1.Is.TypedArray(next) || is_1.Is.Value(next)) {
-            throw new ValueMutateInvalidRootMutationError();
-        }
-        if ((is_1.Is.Object(current) && is_1.Is.Array(next)) || (is_1.Is.Array(current) && is_1.Is.Object(next))) {
-            throw new ValueMutateTypeMismatchError();
+}
+function TypedArrayType(root, path, current, next) {
+    if (ValueGuard.IsTypedArray(current) && current.length === next.length) {
+        for (let i = 0; i < current.length; i++) {
+            current[i] = next[i];
         }
-        Visit(current, '', current, next);
     }
-    ValueMutate.Mutate = Mutate;
-})(ValueMutate || (exports.ValueMutate = ValueMutate = {}));
+    else {
+        pointer_1.ValuePointer.Set(root, path, ValueClone.Clone(next));
+    }
+}
+function ValueType(root, path, current, next) {
+    if (current === next)
+        return;
+    pointer_1.ValuePointer.Set(root, path, next);
+}
+function Visit(root, path, current, next) {
+    if (ValueGuard.IsArray(next))
+        return ArrayType(root, path, current, next);
+    if (ValueGuard.IsTypedArray(next))
+        return TypedArrayType(root, path, current, next);
+    if (ValueGuard.IsPlainObject(next))
+        return ObjectType(root, path, current, next);
+    if (ValueGuard.IsValueType(next))
+        return ValueType(root, path, current, next);
+}
+// --------------------------------------------------------------------------
+// Mutate
+// --------------------------------------------------------------------------
+function IsNonMutableValue(value) {
+    return ValueGuard.IsTypedArray(value) || ValueGuard.IsValueType(value);
+}
+function IsMismatchedValue(current, next) {
+    // prettier-ignore
+    return ((ValueGuard.IsPlainObject(current) && ValueGuard.IsArray(next)) ||
+        (ValueGuard.IsArray(current) && ValueGuard.IsPlainObject(next)));
+}
+// --------------------------------------------------------------------------
+// Mutate
+// --------------------------------------------------------------------------
+/** Performs a deep mutable value assignment while retaining internal references */
+function Mutate(current, next) {
+    if (IsNonMutableValue(current) || IsNonMutableValue(next))
+        throw new ValueMutateInvalidRootMutationError();
+    if (IsMismatchedValue(current, next))
+        throw new ValueMutateTypeMismatchError();
+    Visit(current, '', current, next);
+}
+exports.Mutate = Mutate;

package/value/pointer.js

@@ -28,6 +28,9 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 class ValuePointerRootSetError extends Error {
     constructor(value, path, update) {
         super('ValuePointer: Cannot set root value');
@@ -45,6 +48,9 @@ class ValuePointerRootDeleteError extends Error {
     }
 }
 exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
+// --------------------------------------------------------------------------
+// ValuePointer
+// --------------------------------------------------------------------------
 /** Provides functionality to update values through RFC6901 string pointers */
 var ValuePointer;
 (function (ValuePointer) {
@@ -102,7 +108,7 @@ var ValuePointer;
             next = next[component];
             key = component;
         }
-        if (globalThis.Array.isArray(owner)) {
+        if (Array.isArray(owner)) {
             const index = parseInt(key);
             owner.splice(index, 1);
         }
@@ -123,7 +129,7 @@ var ValuePointer;
             next = next[component];
             key = component;
         }
-        return globalThis.Object.getOwnPropertyNames(owner).includes(key);
+        return Object.getOwnPropertyNames(owner).includes(key);
     }
     ValuePointer.Has = Has;
     /** Gets the value at the given pointer */

package/value/value.d.ts

@@ -1,39 +1,39 @@
+import * as ValueErrors from '../errors/index';
+import * as ValueMutate from './mutate';
+import * as ValueDelta from './delta';
 import * as Types from '../typebox';
-import { ValueErrorIterator } from '../errors/index';
-import { Mutable } from './mutate';
-import { Edit } from './delta';
-/** Provides functions to perform structural updates to JavaScript values */
+/** Functions to perform structural operations on JavaScript values */
 export declare namespace Value {
-    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
-    function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;
-    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+    function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>;
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
     function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
-    /** Creates a value from the given type */
-    function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
+    /** Creates a value from the given type and references */
+    function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;
     /** Creates a value from the given type */
     function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
-    /** Returns true if the value matches the given type. */
-    function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
-    /** Returns true if the value matches the given type. */
+    /** Returns true if the value matches the given type and references */
+    function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>;
+    /** Returns true if the value matches the given type */
     function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
-    /** Converts any type mismatched values to their target type if a conversion is possible. */
-    function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): unknown;
-    /** Converts any type mismatched values to their target type if a conversion is possible. */
+    /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+    function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): unknown;
+    /** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
     function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown;
     /** Returns a structural clone of the given value */
     function Clone<T>(value: T): T;
     /** Returns an iterator for each error in this value. */
-    function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): ValueErrorIterator;
+    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrors.ValueErrorIterator;
     /** Returns an iterator for each error in this value. */
-    function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator;
+    function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrors.ValueErrorIterator;
     /** Returns true if left and right values are structurally equal */
     function Equal<T>(left: T, right: unknown): right is T;
     /** Returns edits to transform the current value into the next value */
-    function Diff(current: unknown, next: unknown): Edit[];
+    function Diff(current: unknown, next: unknown): ValueDelta.Edit[];
     /** Returns a FNV1A-64 non cryptographic hash of the given value */
     function Hash(value: unknown): bigint;
     /** Returns a new value with edits applied to the given value */
-    function Patch<T = any>(current: unknown, edits: Edit[]): T;
+    function Patch<T = any>(current: unknown, edits: ValueDelta.Edit[]): T;
     /** Performs a deep mutable value assignment while retaining internal references. */
-    function Mutate(current: Mutable, next: Mutable): void;
+    function Mutate(current: ValueMutate.Mutable, next: ValueMutate.Mutable): void;
 }