@sinclair/typebox 0.33.22 → 0.34.1

package/build/esm/type/type/json.mjs

@@ -3,7 +3,6 @@ import { Array } from '../array/index.mjs';
 import { Boolean } from '../boolean/index.mjs';
 import { Composite } from '../composite/index.mjs';
 import { Const } from '../const/index.mjs';
-import { Deref } from '../deref/index.mjs';
 import { Enum } from '../enum/index.mjs';
 import { Exclude } from '../exclude/index.mjs';
 import { Extends } from '../extends/index.mjs';
@@ -18,6 +17,7 @@ import { Mapped } from '../mapped/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Not } from '../not/index.mjs';
 import { Null } from '../null/index.mjs';
+import { Module } from '../module/index.mjs';
 import { Number } from '../number/index.mjs';
 import { Object } from '../object/index.mjs';
 import { Omit } from '../omit/index.mjs';
@@ -31,7 +31,6 @@ import { Recursive } from '../recursive/index.mjs';
 import { Ref } from '../ref/index.mjs';
 import { Required } from '../required/index.mjs';
 import { Rest } from '../rest/index.mjs';
-import { Strict } from '../strict/index.mjs';
 import { String } from '../string/index.mjs';
 import { TemplateLiteral } from '../template-literal/index.mjs';
 import { Transform } from '../transform/index.mjs';
@@ -41,35 +40,20 @@ import { Unknown } from '../unknown/index.mjs';
 import { Unsafe } from '../unsafe/index.mjs';
 /** Json Type Builder with Static Resolution for TypeScript */
 export class JsonTypeBuilder {
-    // ------------------------------------------------------------------------
-    // Strict
-    // ------------------------------------------------------------------------
-    /**
-     * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
-     * to use the JSON parse/stringify to remove compositing symbols if needed. This
-     * is how Strict works internally.
-     *
-     * ```typescript
-     * JSON.parse(JSON.stringify(Type.String()))
-     * ```
-     */
-    Strict(schema) {
-        return Strict(schema);
-    }
     // ------------------------------------------------------------------------
     // Modifiers
     // ------------------------------------------------------------------------
     /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional(schema) {
-        return ReadonlyOptional(schema);
+    ReadonlyOptional(type) {
+        return ReadonlyOptional(type);
     }
     /** `[Json]` Creates a Readonly property */
-    Readonly(schema, enable) {
-        return Readonly(schema, enable ?? true);
+    Readonly(type, enable) {
+        return Readonly(type, enable ?? true);
     }
     /** `[Json]` Creates a Optional property */
-    Optional(schema, enable) {
-        return Optional(schema, enable ?? true);
+    Optional(type, enable) {
+        return Optional(type, enable ?? true);
     }
     // ------------------------------------------------------------------------
     // Types
@@ -79,8 +63,8 @@ export class JsonTypeBuilder {
         return Any(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options) {
-        return Array(schema, options);
+    Array(items, options) {
+        return Array(items, options);
     }
     /** `[Json]` Creates a Boolean type */
     Boolean(options) {
@@ -98,10 +82,6 @@ export class JsonTypeBuilder {
     Const(value, options) {
         return Const(value, options);
     }
-    /** `[Json]` Creates a dereferenced type */
-    Deref(schema, references) {
-        return Deref(schema, references);
-    }
     /** `[Json]` Creates a Enum type */
     Enum(item, options) {
         return Enum(item, options);
@@ -119,40 +99,44 @@ export class JsonTypeBuilder {
         return Extract(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options) {
-        return Index(schema, unresolved, options);
+    Index(type, key, options) {
+        return Index(type, key, options);
     }
     /** `[Json]` Creates an Integer type */
     Integer(options) {
         return Integer(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options) {
-        return Intersect(T, options);
+    Intersect(types, options) {
+        return Intersect(types, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options) {
-        return KeyOf(schema, options);
+    KeyOf(type, options) {
+        return KeyOf(type, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options) {
-        return Literal(value, options);
+    Literal(literalValue, options) {
+        return Literal(literalValue, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options) {
-        return Lowercase(schema, options);
+    Lowercase(type, options) {
+        return Lowercase(type, options);
     }
     /** `[Json]` Creates a Mapped object type */
     Mapped(key, map, options) {
         return Mapped(key, map, options);
     }
+    /** `[Json]` Creates a Type Definition Module. */
+    Module(properties) {
+        return Module(properties);
+    }
     /** `[Json]` Creates a Never type */
     Never(options) {
         return Never(options);
     }
     /** `[Json]` Creates a Not type */
-    Not(schema, options) {
-        return Not(schema, options);
+    Not(type, options) {
+        return Not(type, options);
     }
     /** `[Json]` Creates a Null type */
     Null(options) {
@@ -167,36 +151,36 @@ export class JsonTypeBuilder {
         return Object(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options) {
-        return Omit(schema, unresolved, options);
+    Omit(schema, selector, options) {
+        return Omit(schema, selector, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options) {
-        return Partial(schema, options);
+    Partial(type, options) {
+        return Partial(type, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options) {
-        return Pick(schema, unresolved, options);
+    Pick(type, key, options) {
+        return Pick(type, key, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options) {
-        return Record(key, schema, options);
+    Record(key, value, options) {
+        return Record(key, value, options);
     }
     /** `[Json]` Creates a Recursive type */
     Recursive(callback, options) {
         return Recursive(callback, options);
     }
     /** `[Json]` Creates a Ref type. */
-    Ref(unresolved, options) {
-        return Ref(unresolved, options);
+    Ref($ref, options) {
+        return Ref($ref, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options) {
-        return Required(schema, options);
+    Required(type, options) {
+        return Required(type, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest(schema) {
-        return Rest(schema);
+    Rest(type) {
+        return Rest(type);
     }
     /** `[Json]` Creates a String type */
     String(options) {
@@ -207,20 +191,20 @@ export class JsonTypeBuilder {
         return TemplateLiteral(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
-    Transform(schema) {
-        return Transform(schema);
+    Transform(type) {
+        return Transform(type);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options) {
-        return Tuple(items, options);
+    Tuple(types, options) {
+        return Tuple(types, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options) {
-        return Uncapitalize(schema, options);
+    Uncapitalize(type, options) {
+        return Uncapitalize(type, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options) {
-        return Union(schemas, options);
+    Union(types, options) {
+        return Union(types, options);
     }
     /** `[Json]` Creates an Unknown type */
     Unknown(options) {

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

@@ -9,7 +9,6 @@ export { Const } from '../const/index.mjs';
 export { Constructor } from '../constructor/index.mjs';
 export { ConstructorParameters } from '../constructor-parameters/index.mjs';
 export { Date } from '../date/index.mjs';
-export { Deref } from '../deref/index.mjs';
 export { Enum } from '../enum/index.mjs';
 export { Exclude } from '../exclude/index.mjs';
 export { Extends } from '../extends/index.mjs';
@@ -24,6 +23,7 @@ export { Iterator } from '../iterator/index.mjs';
 export { KeyOf } from '../keyof/index.mjs';
 export { Literal } from '../literal/index.mjs';
 export { Mapped } from '../mapped/index.mjs';
+export { Module } from '../module/index.mjs';
 export { Never } from '../never/index.mjs';
 export { Not } from '../not/index.mjs';
 export { Null } from '../null/index.mjs';
@@ -45,7 +45,6 @@ export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';
 export { String } from '../string/index.mjs';
-export { Strict } from '../strict/index.mjs';
 export { Symbol } from '../symbol/index.mjs';
 export { TemplateLiteral } from '../template-literal/index.mjs';
 export { Transform } from '../transform/index.mjs';

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

@@ -12,7 +12,6 @@ export { Const } from '../const/index.mjs';
 export { Constructor } from '../constructor/index.mjs';
 export { ConstructorParameters } from '../constructor-parameters/index.mjs';
 export { Date } from '../date/index.mjs';
-export { Deref } from '../deref/index.mjs';
 export { Enum } from '../enum/index.mjs';
 export { Exclude } from '../exclude/index.mjs';
 export { Extends } from '../extends/index.mjs';
@@ -27,6 +26,7 @@ export { Iterator } from '../iterator/index.mjs';
 export { KeyOf } from '../keyof/index.mjs';
 export { Literal } from '../literal/index.mjs';
 export { Mapped } from '../mapped/index.mjs';
+export { Module } from '../module/index.mjs';
 export { Never } from '../never/index.mjs';
 export { Not } from '../not/index.mjs';
 export { Null } from '../null/index.mjs';
@@ -48,7 +48,6 @@ export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';
 export { String } from '../string/index.mjs';
-export { Strict } from '../strict/index.mjs';
 export { Symbol } from '../symbol/index.mjs';
 export { TemplateLiteral } from '../template-literal/index.mjs';
 export { Transform } from '../transform/index.mjs';

package/build/esm/type/union/union-evaluated.d.mts

@@ -3,11 +3,11 @@ import { type TNever } from '../never/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import type { TUnion } from './union-type.mjs';
-type TIsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : TIsUnionOptional<R> : false);
-type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<R, [...Acc, L]> : Acc);
-type TRemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> : T);
-type TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (TIsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
-export type TUnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveUnion<T>);
+type TIsUnionOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? true : TIsUnionOptional<Right> : false);
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<Right, [...Result, Left]> : Result);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TResolveUnion<Types extends TSchema[], Result extends TSchema[] = TRemoveOptionalFromRest<Types>, IsOptional extends boolean = TIsUnionOptional<Types>> = (IsOptional extends true ? TOptional<TUnion<Result>> : TUnion<Result>);
+export type TUnionEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveUnion<Types>);
 /** `[Json]` Creates an evaluated Union type */
-export declare function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export declare function UnionEvaluated<Types extends TSchema[], Result = TUnionEvaluated<Types>>(T: [...Types], options?: SchemaOptions): Result;
 export {};

package/build/esm/type/union/union-evaluated.mjs

@@ -9,27 +9,28 @@ import { UnionCreate } from './union-create.mjs';
 // ------------------------------------------------------------------
 import { IsOptional } from '../guard/kind.mjs';
 // prettier-ignore
-function IsUnionOptional(T) {
-    return T.some(L => IsOptional(L));
+function IsUnionOptional(types) {
+    return types.some(type => IsOptional(type));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L);
+function RemoveOptionalFromRest(types) {
+    return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {
     return (Discard(T, [OptionalKind]));
 }
 // prettier-ignore
-function ResolveUnion(T, options) {
-    return (IsUnionOptional(T)
-        ? Optional(UnionCreate(RemoveOptionalFromRest(T), options))
-        : UnionCreate(RemoveOptionalFromRest(T), options));
+function ResolveUnion(types, options) {
+    const isOptional = IsUnionOptional(types);
+    return (isOptional
+        ? Optional(UnionCreate(RemoveOptionalFromRest(types), options))
+        : UnionCreate(RemoveOptionalFromRest(types), options));
 }
 /** `[Json]` Creates an evaluated Union type */
 export function UnionEvaluated(T, options) {
     // prettier-ignore
-    return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CreateType(T[0], options) :
+    return (T.length === 1 ? CreateType(T[0], options) :
+        T.length === 0 ? Never(options) :
             ResolveUnion(T, options));
 }

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

@@ -3,4 +3,4 @@ import { type TNever } from '../never/index.mjs';
 import type { TUnion } from './union-type.mjs';
 export type Union<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TUnion<T>);
 /** `[Json]` Creates a Union type */
-export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T>;
+export declare function Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;

package/build/esm/type/union/union.mjs

@@ -2,9 +2,9 @@ import { Never } from '../never/index.mjs';
 import { CreateType } from '../create/type.mjs';
 import { UnionCreate } from './union-create.mjs';
 /** `[Json]` Creates a Union type */
-export function Union(T, options) {
+export function Union(types, options) {
     // prettier-ignore
-    return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CreateType(T[0], options) :
-            UnionCreate(T, options));
+    return (types.length === 0 ? Never(options) :
+        types.length === 1 ? CreateType(types[0], options) :
+            UnionCreate(types, options));
 }

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

@@ -4,7 +4,7 @@ import { Kind } from '../../type/symbols/index.mjs';
 import { Create } from '../create/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
-import { Deref } from '../deref/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -98,6 +98,11 @@ function FromConstructor(schema, references, value) {
     }
     return result;
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromIntersect(schema, references, value) {
     const created = Create(schema, references);
     const mapped = IsObject(created) && IsObject(value) ? { ...created, ...value } : value;
@@ -161,7 +166,7 @@ function FromUnion(schema, references, value) {
     return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? Pushref(schema, references) : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         // --------------------------------------------------------------
@@ -171,6 +176,8 @@ function Visit(schema, references, value) {
             return FromArray(schema_, references_, value);
         case 'Constructor':
             return FromConstructor(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Never':

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

@@ -1,5 +1,5 @@
 import { TypeSystemPolicy } from '../../system/index.mjs';
-import { Deref } from '../deref/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
 import { Hash } from '../hash/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { KeyOfPattern } from '../../type/keyof/index.mjs';
@@ -12,9 +12,9 @@ import { Never } from '../../type/never/index.mjs';
 // ------------------------------------------------------------------
 import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../guard/index.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsSchema } from '../../type/guard/type.mjs';
+import { IsSchema } from '../../type/guard/kind.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -135,6 +135,11 @@ function FromDate(schema, references, value) {
 function FromFunction(schema, references, value) {
     return IsFunction(value);
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromInteger(schema, references, value) {
     if (!IsInteger(value)) {
         return false;
@@ -380,7 +385,7 @@ function FromKind(schema, references, value) {
     return func(schema, value);
 }
 function Visit(schema, references, value) {
-    const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
+    const references_ = IsDefined(schema.$id) ? Pushref(schema, references) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Any':
@@ -399,6 +404,8 @@ function Visit(schema, references, value) {
             return FromDate(schema_, references_, value);
         case 'Function':
             return FromFunction(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Integer':
             return FromInteger(schema_, references_, value);
         case 'Intersect':

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

@@ -1,7 +1,7 @@
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
-import { Deref } from '../deref/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
@@ -27,6 +27,11 @@ function FromArray(schema, references, value) {
         return value;
     return value.map((value) => Visit(schema.items, references, value));
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
     const intersections = schema.allOf.map((schema) => Visit(schema, references, Clone(value)));
@@ -109,11 +114,13 @@ function FromUnion(schema, references, value) {
     return value;
 }
 function Visit(schema, references, value) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? Pushref(schema, references) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Object':

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

@@ -123,6 +123,11 @@ function FromBoolean(schema, references, value) {
 function FromDate(schema, references, value) {
     return TryConvertDate(value);
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
@@ -207,6 +212,8 @@ function Visit(schema, references, value) {
             return FromBoolean(schema_, references_, value);
         case 'Date':
             return FromDate(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Integer':
             return FromInteger(schema_, references_, value);
         case 'Intersect':

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

@@ -118,6 +118,11 @@ function FromFunction(schema, references) {
         return () => Visit(schema.returns, references);
     }
 }
+function FromImport(schema, references) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions]);
+}
 function FromInteger(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return FromDefault(schema.default);
@@ -401,6 +406,8 @@ function Visit(schema, references) {
             return FromDate(schema_, references_);
         case 'Function':
             return FromFunction(schema_, references_);
+        case 'Import':
+            return FromImport(schema_, references_);
         case 'Integer':
             return FromInteger(schema_, references_);
         case 'Intersect':

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

@@ -40,6 +40,11 @@ function FromDate(schema, references, value) {
     // special case intercept for dates
     return IsDate(value) ? value : ValueOrDefault(schema, value);
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromIntersect(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     return schema.allOf.reduce((acc, schema) => {
@@ -133,6 +138,8 @@ function Visit(schema, references, value) {
             return FromArray(schema_, references_, value);
         case 'Date':
             return FromDate(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Object':

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

@@ -9,9 +9,9 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type.mjs';
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/kind.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -76,6 +76,15 @@ function FromIntersect(schema, references, path, value) {
         }
     return Default(schema, path, unknownProperties);
 }
+// prettier-ignore
+function FromImport(schema, references, path, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    const transform = schema[TransformKind];
+    // Note: we need to re-spec the target as TSchema + [TransformKind]
+    const transformTarget = { [TransformKind]: transform, ...target };
+    return Visit(transformTarget, [...references, ...definitions], path, value);
+}
 function FromNot(schema, references, path, value) {
     return Default(schema, path, Visit(schema.not, references, path, value));
 }
@@ -166,6 +175,8 @@ function Visit(schema, references, path, value) {
     switch (schema[Kind]) {
         case 'Array':
             return FromArray(schema_, references_, path, value);
+        case 'Import':
+            return FromImport(schema_, references_, path, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, path, value);
         case 'Not':

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

@@ -9,9 +9,9 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type.mjs';
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/kind.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -54,6 +54,15 @@ function FromArray(schema, references, path, value) {
         : defaulted;
 }
 // prettier-ignore
+function FromImport(schema, references, path, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    const transform = schema[TransformKind];
+    // Note: we need to re-spec the target as TSchema + [TransformKind]
+    const transformTarget = { [TransformKind]: transform, ...target };
+    return Visit(transformTarget, [...references, ...definitions], path, value);
+}
+// prettier-ignore
 function FromIntersect(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
     if (!IsObject(value) || IsValueType(value))
@@ -178,6 +187,8 @@ function Visit(schema, references, path, value) {
     switch (schema[Kind]) {
         case 'Array':
             return FromArray(schema_, references_, path, value);
+        case 'Import':
+            return FromImport(schema_, references_, path, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, path, value);
         case 'Not':

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

@@ -1,9 +1,9 @@
 import { Deref, Pushref } from '../deref/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
+import { IsTransform, IsSchema } from '../../type/guard/kind.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------

package/package.json

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