@sinclair/typebox 0.32.34 → 0.33.0

package/build/cjs/type/type/json.js

@@ -71,19 +71,19 @@ class JsonTypeBuilder {
     // Types
     // ------------------------------------------------------------------------
     /** `[Json]` Creates an Any type */
-    Any(options = {}) {
+    Any(options) {
         return (0, index_1.Any)(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options = {}) {
+    Array(schema, options) {
         return (0, index_2.Array)(schema, options);
     }
     /** `[Json]` Creates a Boolean type */
-    Boolean(options = {}) {
+    Boolean(options) {
         return (0, index_3.Boolean)(options);
     }
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize(schema, options = {}) {
+    Capitalize(schema, options) {
         return (0, index_14.Capitalize)(schema, options);
     }
     /** `[Json]` Creates a Composite object type */
@@ -91,7 +91,7 @@ class JsonTypeBuilder {
         return (0, index_4.Composite)(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
     }
     /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const(value, options = {}) {
+    Const(value, options) {
         return (0, index_5.Const)(value, options);
     }
     /** `[Json]` Creates a dereferenced type */
@@ -99,51 +99,51 @@ class JsonTypeBuilder {
         return (0, index_6.Deref)(schema, references);
     }
     /** `[Json]` Creates a Enum type */
-    Enum(item, options = {}) {
+    Enum(item, options) {
         return (0, index_7.Enum)(item, options);
     }
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude(unionType, excludedMembers, options = {}) {
+    Exclude(unionType, excludedMembers, options) {
         return (0, index_8.Exclude)(unionType, excludedMembers, options);
     }
     /** `[Json]` Creates a Conditional type */
-    Extends(L, R, T, F, options = {}) {
+    Extends(L, R, T, F, options) {
         return (0, index_9.Extends)(L, R, T, F, options);
     }
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract(type, union, options = {}) {
+    Extract(type, union, options) {
         return (0, index_10.Extract)(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options = {}) {
+    Index(schema, unresolved, options) {
         return (0, index_11.Index)(schema, unresolved, options);
     }
     /** `[Json]` Creates an Integer type */
-    Integer(options = {}) {
+    Integer(options) {
         return (0, index_12.Integer)(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options = {}) {
+    Intersect(T, options) {
         return (0, index_13.Intersect)(T, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options = {}) {
+    KeyOf(schema, options) {
         return (0, index_15.KeyOf)(schema, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options = {}) {
+    Literal(value, options) {
         return (0, index_16.Literal)(value, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options = {}) {
+    Lowercase(schema, options) {
         return (0, index_14.Lowercase)(schema, options);
     }
     /** `[Json]` Creates a Mapped object type */
-    Mapped(key, map, options = {}) {
+    Mapped(key, map, options) {
         return (0, index_17.Mapped)(key, map, options);
     }
     /** `[Json]` Creates a Never type */
-    Never(options = {}) {
+    Never(options) {
         return (0, index_18.Never)(options);
     }
     /** `[Json]` Creates a Not type */
@@ -151,43 +151,43 @@ class JsonTypeBuilder {
         return (0, index_19.Not)(schema, options);
     }
     /** `[Json]` Creates a Null type */
-    Null(options = {}) {
+    Null(options) {
         return (0, index_20.Null)(options);
     }
     /** `[Json]` Creates a Number type */
-    Number(options = {}) {
+    Number(options) {
         return (0, index_21.Number)(options);
     }
     /** `[Json]` Creates an Object type */
-    Object(properties, options = {}) {
+    Object(properties, options) {
         return (0, index_22.Object)(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options = {}) {
+    Omit(schema, unresolved, options) {
         return (0, index_23.Omit)(schema, unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options = {}) {
+    Partial(schema, options) {
         return (0, index_25.Partial)(schema, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options = {}) {
+    Pick(schema, unresolved, options) {
         return (0, index_26.Pick)(schema, unresolved, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options = {}) {
+    Record(key, schema, options) {
         return (0, index_29.Record)(key, schema, options);
     }
     /** `[Json]` Creates a Recursive type */
-    Recursive(callback, options = {}) {
+    Recursive(callback, options) {
         return (0, index_30.Recursive)(callback, options);
     }
     /** `[Json]` Creates a Ref type. */
-    Ref(unresolved, options = {}) {
+    Ref(unresolved, options) {
         return (0, index_31.Ref)(unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options = {}) {
+    Required(schema, options) {
         return (0, index_32.Required)(schema, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
@@ -195,11 +195,11 @@ class JsonTypeBuilder {
         return (0, index_33.Rest)(schema);
     }
     /** `[Json]` Creates a String type */
-    String(options = {}) {
+    String(options) {
         return (0, index_35.String)(options);
     }
     /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral(unresolved, options = {}) {
+    TemplateLiteral(unresolved, options) {
         return (0, index_36.TemplateLiteral)(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
@@ -207,27 +207,27 @@ class JsonTypeBuilder {
         return (0, index_37.Transform)(schema);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options = {}) {
+    Tuple(items, options) {
         return (0, index_38.Tuple)(items, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options = {}) {
+    Uncapitalize(schema, options) {
         return (0, index_14.Uncapitalize)(schema, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options = {}) {
+    Union(schemas, options) {
         return (0, index_39.Union)(schemas, options);
     }
     /** `[Json]` Creates an Unknown type */
-    Unknown(options = {}) {
+    Unknown(options) {
         return (0, index_40.Unknown)(options);
     }
     /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe(options = {}) {
+    Unsafe(options) {
         return (0, index_41.Unsafe)(options);
     }
     /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase(schema, options = {}) {
+    Uppercase(schema, options) {
         return (0, index_14.Uppercase)(schema, options);
     }
 }

package/build/cjs/type/uint8array/uint8array.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uint8Array = Uint8Array;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Uint8Array type */
-function Uint8Array(options = {}) {
-    return { ...options, [index_1.Kind]: 'Uint8Array', type: 'Uint8Array' };
+function Uint8Array(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Uint8Array', type: 'Uint8Array' }, options);
 }

package/build/cjs/type/undefined/undefined.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Undefined = Undefined;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Undefined type */
-function Undefined(options = {}) {
-    return { ...options, [index_1.Kind]: 'Undefined', type: 'undefined' };
+function Undefined(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Undefined', type: 'undefined' }, options);
 }

package/build/cjs/type/union/union-create.d.ts

@@ -1,3 +1,3 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import { TUnion } from './union-type';
-export declare function UnionCreate<T extends TSchema[]>(T: [...T], options: SchemaOptions): TUnion<T>;
+export declare function UnionCreate<T extends TSchema[]>(T: [...T], options?: SchemaOptions): TUnion<T>;

package/build/cjs/type/union/union-create.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnionCreate = UnionCreate;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 function UnionCreate(T, options) {
-    return { ...options, [index_1.Kind]: 'Union', anyOf: (0, type_1.CloneRest)(T) };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Union', anyOf: T }, options);
 }

package/build/cjs/type/union/union-evaluated.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnionEvaluated = UnionEvaluated;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const index_3 = require("../never/index");
 const index_4 = require("../optional/index");
@@ -31,9 +31,9 @@ function ResolveUnion(T, options) {
         : (0, union_create_1.UnionCreate)(RemoveOptionalFromRest(T), options));
 }
 /** `[Json]` Creates an evaluated Union type */
-function UnionEvaluated(T, options = {}) {
+function UnionEvaluated(T, options) {
     // prettier-ignore
     return (T.length === 0 ? (0, index_3.Never)(options) :
-        T.length === 1 ? (0, type_1.CloneType)(T[0], options) :
+        T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
             ResolveUnion(T, options));
 }

package/build/cjs/type/union/union.js

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Union = Union;
 const index_1 = require("../never/index");
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const union_create_1 = require("./union-create");
 /** `[Json]` Creates a Union type */
-function Union(T, options = {}) {
+function Union(T, options) {
     // prettier-ignore
     return (T.length === 0 ? (0, index_1.Never)(options) :
-        T.length === 1 ? (0, type_1.CloneType)(T[0], options) :
+        T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
             (0, union_create_1.UnionCreate)(T, options));
 }

package/build/cjs/type/unknown/unknown.js

@@ -2,11 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unknown = Unknown;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates an Unknown type */
-function Unknown(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Unknown',
-    };
+function Unknown(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Unknown' }, options);
 }

package/build/cjs/type/unsafe/unsafe.js

@@ -2,11 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unsafe = Unsafe;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
 function Unsafe(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: options[index_1.Kind] ?? 'Unsafe',
-    };
+    return (0, type_1.CreateType)({ [index_1.Kind]: options[index_1.Kind] ?? 'Unsafe' }, options);
 }

package/build/cjs/type/void/void.js

@@ -2,12 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Void = Void;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Void type */
-function Void(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Void',
-        type: 'void',
-    };
+function Void(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Void', type: 'void' }, options);
 }

package/build/cjs/value/convert/convert.js

@@ -155,6 +155,9 @@ function FromObject(schema, references, value) {
     return result;
 }
 function FromRecord(schema, references, value) {
+    const isConvertable = (0, index_5.IsObject)(value);
+    if (!isConvertable)
+        return value;
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[propertyKey];
     const result = {};

package/build/esm/errors/function.mjs

@@ -94,7 +94,7 @@ export function DefaultErrorFunction(error) {
         case ValueErrorType.ObjectMinProperties:
             return `Expected object to have at least ${error.schema.minProperties} properties`;
         case ValueErrorType.ObjectRequiredProperty:
-            return 'Required property';
+            return 'Expected required property';
         case ValueErrorType.Promise:
             return 'Expected Promise';
         case ValueErrorType.RegExp:

package/build/esm/index.d.mts

@@ -1,4 +1,5 @@
 export * from './type/clone/index.mjs';
+export * from './type/create/index.mjs';
 export * from './type/error/index.mjs';
 export * from './type/guard/index.mjs';
 export * from './type/helpers/index.mjs';

package/build/esm/index.mjs

@@ -2,6 +2,7 @@
 // Infrastructure
 // ------------------------------------------------------------------
 export * from './type/clone/index.mjs';
+export * from './type/create/index.mjs';
 export * from './type/error/index.mjs';
 export * from './type/guard/index.mjs';
 export * from './type/helpers/index.mjs';

package/build/esm/system/policy.d.mts

@@ -1,5 +1,13 @@
 export declare namespace TypeSystemPolicy {
-    /** Shared assertion routines used by the value and errors modules */
+    /**
+     * Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+     * references for embedded types, which may cause side effects if type properties are explicitly updated
+     * outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+     * preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+     * it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+     * fastest way to instantiate types. The default setting is `default`.
+     */
+    let InstanceMode: 'default' | 'clone' | 'freeze';
     /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     let ExactOptionalPropertyTypes: boolean;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */

package/build/esm/system/policy.mjs

@@ -2,9 +2,20 @@ import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard/index.m
 export var TypeSystemPolicy;
 (function (TypeSystemPolicy) {
     // ------------------------------------------------------------------
-    // TypeSystemPolicy
+    // TypeSystemPolicy: Instancing
+    // ------------------------------------------------------------------
+    /**
+     * Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+     * references for embedded types, which may cause side effects if type properties are explicitly updated
+     * outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+     * preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+     * it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+     * fastest way to instantiate types. The default setting is `default`.
+     */
+    TypeSystemPolicy.InstanceMode = 'default';
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy: Checking
     // ------------------------------------------------------------------
-    /** Shared assertion routines used by the value and errors modules */
     /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     TypeSystemPolicy.ExactOptionalPropertyTypes = false;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */

package/build/esm/type/any/any.mjs

@@ -1,5 +1,6 @@
+import { CreateType } from '../create/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates an Any type */
-export function Any(options = {}) {
-    return { ...options, [Kind]: 'Any' };
+export function Any(options) {
+    return CreateType({ [Kind]: 'Any' }, options);
 }

package/build/esm/type/array/array.d.mts

@@ -24,5 +24,5 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
     items: T;
 }
 /** `[Json]` Creates an Array type */
-export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+export declare function Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
 export {};

package/build/esm/type/array/array.mjs

@@ -1,11 +1,6 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates an Array type */
-export function Array(schema, options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Array',
-        type: 'array',
-        items: CloneType(schema),
-    };
+export function Array(items, options) {
+    return CreateType({ [Kind]: 'Array', type: 'array', items }, options);
 }

package/build/esm/type/async-iterator/async-iterator.mjs

@@ -1,11 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 /** `[JavaScript]` Creates a AsyncIterator type */
-export function AsyncIterator(items, options = {}) {
-    return {
-        ...options,
-        [Kind]: 'AsyncIterator',
-        type: 'AsyncIterator',
-        items: CloneType(items),
-    };
+export function AsyncIterator(items, options) {
+    return CreateType({ [Kind]: 'AsyncIterator', type: 'AsyncIterator', items }, options);
 }

package/build/esm/type/awaited/awaited.mjs

@@ -1,6 +1,6 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -32,6 +32,6 @@ function AwaitedResolve(T) {
                 T);
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export function Awaited(T, options = {}) {
-    return CloneType(AwaitedResolve(T), options);
+export function Awaited(T, options) {
+    return CreateType(AwaitedResolve(T), options);
 }

package/build/esm/type/bigint/bigint.mjs

@@ -1,9 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
 /** `[JavaScript]` Creates a BigInt type */
-export function BigInt(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'BigInt',
-        type: 'bigint',
-    };
+export function BigInt(options) {
+    return CreateType({ [Kind]: 'BigInt', type: 'bigint' }, options);
 }

package/build/esm/type/boolean/boolean.mjs

@@ -1,9 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
 /** `[Json]` Creates a Boolean type */
-export function Boolean(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Boolean',
-        type: 'boolean',
-    };
+export function Boolean(options) {
+    return CreateType({ [Kind]: 'Boolean', type: 'boolean' }, options);
 }

package/build/esm/type/clone/type.d.mts

@@ -1,4 +1,4 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { TSchema, SchemaOptions } from '../schema/index.mjs';
 /** Clones a Rest */
 export declare function CloneRest<T extends TSchema[]>(schemas: T): T;
 /** Clones a Type */

package/build/esm/type/clone/type.mjs

@@ -4,6 +4,6 @@ export function CloneRest(schemas) {
     return schemas.map((schema) => CloneType(schema));
 }
 /** Clones a Type */
-export function CloneType(schema, options = {}) {
-    return { ...Clone(schema), ...options };
+export function CloneType(schema, options) {
+    return options === undefined ? Clone(schema) : Clone({ ...options, ...schema });
 }

package/build/esm/type/composite/composite.mjs

@@ -34,7 +34,7 @@ function CompositeProperties(T, K) {
     return Acc;
 }
 // prettier-ignore
-export function Composite(T, options = {}) {
+export function Composite(T, options) {
     const K = CompositeKeys(T);
     const P = CompositeProperties(T, K);
     const R = Object(P, options);

package/build/esm/type/const/const.mjs

@@ -11,7 +11,7 @@ import { Readonly } from '../readonly/index.mjs';
 import { Undefined } from '../undefined/index.mjs';
 import { Uint8Array } from '../uint8array/index.mjs';
 import { Unknown } from '../unknown/index.mjs';
-import { CloneType } from '../clone/index.mjs';
+import { CreateType } from '../create/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -49,6 +49,6 @@ function FromValue(value, root) {
                                                             Object({}));
 }
 /** `[JavaScript]` Creates a readonly const type from the given value. */
-export function Const(T, options = {}) {
-    return CloneType(FromValue(T, true), options);
+export function Const(T, options) {
+    return CreateType(FromValue(T, true), options);
 }

package/build/esm/type/constructor/constructor.mjs

@@ -1,12 +1,6 @@
-import { CloneType, CloneRest } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a Constructor type */
 export function Constructor(parameters, returns, options) {
-    return {
-        ...options,
-        [Kind]: 'Constructor',
-        type: 'Constructor',
-        parameters: CloneRest(parameters),
-        returns: CloneType(returns),
-    };
+    return CreateType({ [Kind]: 'Constructor', type: 'Constructor', parameters, returns }, options);
 }

package/build/esm/type/constructor-parameters/constructor-parameters.mjs

@@ -1,6 +1,5 @@
 import { Tuple } from '../tuple/index.mjs';
-import { CloneRest } from '../clone/type.mjs';
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-export function ConstructorParameters(schema, options = {}) {
-    return Tuple(CloneRest(schema.parameters), { ...options });
+export function ConstructorParameters(schema, options) {
+    return Tuple(schema.parameters, options);
 }

package/build/esm/type/create/immutable.d.mts

@@ -0,0 +1,2 @@
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+export declare function Immutable<T>(value: T): T;

package/build/esm/type/create/immutable.mjs

@@ -0,0 +1,37 @@
+import * as ValueGuard from '../guard/value.mjs';
+function ImmutableArray(value) {
+    return globalThis.Object.freeze(value).map((value) => Immutable(value));
+}
+function ImmutableDate(value) {
+    return value;
+}
+function ImmutableUint8Array(value) {
+    return value;
+}
+function ImmutableRegExp(value) {
+    return value;
+}
+function ImmutableObject(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    return globalThis.Object.freeze(result);
+}
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+export function Immutable(value) {
+    return ValueGuard.IsArray(value)
+        ? ImmutableArray(value)
+        : ValueGuard.IsDate(value)
+            ? ImmutableDate(value)
+            : ValueGuard.IsUint8Array(value)
+                ? ImmutableUint8Array(value)
+                : ValueGuard.IsRegExp(value)
+                    ? ImmutableRegExp(value)
+                    : ValueGuard.IsObject(value)
+                        ? ImmutableObject(value)
+                        : value;
+}

package/build/esm/type/create/index.d.mts

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

package/build/esm/type/create/index.mjs

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

package/build/esm/type/create/type.d.mts

@@ -0,0 +1,3 @@
+import { SchemaOptions } from '../schema/schema.mjs';
+/** Creates TypeBox schematics using the configured InstanceMode */
+export declare function CreateType(schema: Record<any, unknown>, options?: SchemaOptions): unknown;