@sinclair/typebox 0.33.22 → 0.34.1

package/build/cjs/syntax/static.d.ts

@@ -16,6 +16,7 @@ type SemiColon = ';';
 type SingleQuote = "'";
 type DoubleQuote = '"';
 type Tilde = '`';
+type Equals = '=';
 interface DelimitTailMapping<_ = unknown> extends Static.IMapping {
     output: (this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer I, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, I, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer Rest extends unknown[]] ? [A, B, C, D, E, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer Rest extends unknown[]] ? [A, B, C, D, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer Rest extends unknown[]] ? [A, B, C, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer Rest extends unknown[]] ? [A, B, ...Rest] : this['input'] extends [_, infer A, _, infer Rest extends unknown[]] ? [A, ...Rest] : this['input'] extends [_, infer Rest extends unknown[]] ? [...Rest] : this['input'] extends [_] ? [] : [
     ]);
@@ -41,10 +42,90 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
     Static.Tuple<[Parser, DelimitTail<Parser, Delimiter>]>,
     Static.Tuple<[]>
 ], DelimitMapping>);
+type Deref<Context extends Types.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : Types.TRef<Ref>);
+interface ExportModifierMapping extends Static.IMapping {
+    output: this['input'] extends [string] ? true : false;
+}
+type ExportModifier = Static.Union<[
+    Static.Tuple<[Static.Const<'export'>]>,
+    Static.Tuple<[]>
+], ExportModifierMapping>;
+interface TypeAliasDeclarationMapping extends Static.IMapping {
+    output: this['input'] extends [infer _Export extends boolean, 'type', infer Ident extends string, Equals, infer Type extends Types.TSchema] ? {
+        [_ in Ident]: Type;
+    } : never;
+}
+type TypeAliasDeclaration = Static.Tuple<[
+    ExportModifier,
+    Static.Const<'type'>,
+    Static.Ident,
+    Static.Const<Equals>,
+    Type
+], TypeAliasDeclarationMapping>;
+type HeritageListDelimiter = Static.Union<[Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>, Static.Tuple<[Static.Const<Comma>]>]>;
+type HeritageListReduce<Values extends string[], Context extends Types.TProperties, Result extends Types.TSchema[] = []> = (Values extends [infer Ref extends string, ...infer Rest extends string[]] ? HeritageListReduce<Rest, Context, [...Result, Deref<Context, Ref>]> : Result);
+interface HeritageListMapping extends Static.IMapping {
+    output: (this['context'] extends Types.TProperties ? this['input'] extends string[] ? HeritageListReduce<this['input'], this['context']> : [] : []);
+}
+type HeritageList = Static.Union<[Delimit<Static.Ident, HeritageListDelimiter>], HeritageListMapping>;
+interface HeritageMapping extends Static.IMapping {
+    output: this['input'] extends ['extends', infer List extends Types.TSchema[]] ? List : [];
+}
+type Heritage = Static.Union<[
+    Static.Tuple<[Static.Const<'extends'>, HeritageList]>,
+    Static.Tuple<[]>
+], HeritageMapping>;
+interface InterfaceDeclarationMapping extends Static.IMapping {
+    output: this['input'] extends [boolean, 'interface', infer Ident extends string, infer Heritage extends Types.TSchema[], LBrace, infer Properties extends Types.TProperties, RBrace] ? {
+        [_ in Ident]: Types.TIntersectEvaluated<[...Heritage, Types.TObject<Properties>]>;
+    } : never;
+}
+type InterfaceDeclaration = Static.Tuple<[
+    ExportModifier,
+    Static.Const<'interface'>,
+    Static.Ident,
+    Heritage,
+    Static.Const<LBrace>,
+    Properties,
+    Static.Const<RBrace>
+], InterfaceDeclarationMapping>;
+type ModuleType = Static.Union<[
+    InterfaceDeclaration,
+    TypeAliasDeclaration
+]>;
+type ModulePropertiesDelimiter = Static.Union<[
+    Static.Tuple<[Static.Const<SemiColon>, Static.Const<Newline>]>,
+    Static.Tuple<[Static.Const<SemiColon>]>,
+    Static.Tuple<[Static.Const<Newline>]>
+]>;
+type ModulePropertiesReduce<Value extends unknown[], Result extends Types.TProperties = {}> = (Value extends [infer ModuleType extends Types.TProperties, unknown[], ...infer Rest extends unknown[]] ? ModulePropertiesReduce<Rest, Result & ModuleType> : Value extends [infer ModuleType extends Types.TProperties] ? ModulePropertiesReduce<[], Result & ModuleType> : Types.Evaluate<Result>);
+interface ModulePropertiesMapping extends Static.IMapping {
+    output: this['input'] extends unknown[] ? ModulePropertiesReduce<this['input']> : never;
+}
+type ModuleProperties = Static.Union<[
+    Static.Tuple<[ModuleType, ModulePropertiesDelimiter, ModuleProperties]>,
+    Static.Tuple<[ModuleType]>,
+    Static.Tuple<[]>
+], ModulePropertiesMapping>;
+type ModuleIdentifier = Static.Union<[
+    Static.Tuple<[Static.Ident]>,
+    Static.Tuple<[]>
+]>;
+interface ModuleDeclarationMapping extends Static.IMapping {
+    output: this['input'] extends [boolean, 'module', infer _Ident extends string[], LBrace, infer Properties extends Types.TProperties, RBrace] ? Types.TModule<Properties> : never;
+}
+type ModuleDeclaration = Static.Tuple<[
+    ExportModifier,
+    Static.Const<'module'>,
+    ModuleIdentifier,
+    Static.Const<LBrace>,
+    ModuleProperties,
+    Static.Const<RBrace>
+], ModuleDeclarationMapping>;
 interface ReferenceMapping extends Static.IMapping {
-    output: this['input'] extends [infer Key extends string] ? Key extends keyof this['context'] ? this['context'][Key] : Types.TRef<Types.TUnknown> : never;
+    output: this['context'] extends Types.TProperties ? this['input'] extends string ? Deref<this['context'], this['input']> : never : never;
 }
-type Reference = Static.Tuple<[Static.Ident], ReferenceMapping>;
+type Reference = Static.Ident<ReferenceMapping>;
 interface LiteralBooleanMapping extends Static.IMapping {
     output: this['input'] extends `${infer S extends boolean}` ? Types.TLiteral<S> : never;
 }
@@ -171,38 +252,35 @@ type Expr = Static.Tuple<[
     ExprTerm,
     ExprTail
 ], ExprBinaryMapping>;
-export type Type = Expr;
+type Type = Expr;
 interface PropertyKeyStringMapping extends Static.IMapping {
     output: this['input'];
 }
 type PropertyKeyString = Static.String<[SingleQuote, DoubleQuote], PropertyKeyStringMapping>;
 type PropertyKey = Static.Union<[Static.Ident, PropertyKeyString]>;
-interface PropertyReadonlyMapping extends Static.IMapping {
+interface ReadonlyMapping extends Static.IMapping {
     output: this['input'] extends ['readonly'] ? true : false;
 }
-type PropertyReadonly = Static.Union<[Static.Tuple<[Static.Const<'readonly'>]>, Static.Tuple<[]>], PropertyReadonlyMapping>;
-interface PropertyOptionalMapping extends Static.IMapping {
+type Readonly = Static.Union<[Static.Tuple<[Static.Const<'readonly'>]>, Static.Tuple<[]>], ReadonlyMapping>;
+interface OptionalMapping extends Static.IMapping {
     output: this['input'] extends [Question] ? true : false;
 }
-type PropertyOptional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], PropertyOptionalMapping>;
+type Optional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], OptionalMapping>;
 interface PropertyMapping extends Static.IMapping {
-    output: this['input'] extends [infer Readonly extends boolean, infer Key extends string, infer Optional extends boolean, string, infer Type extends Types.TSchema] ? {
+    output: this['input'] extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends Types.TSchema] ? {
         [_ in Key]: ([
-            Readonly,
-            Optional
+            IsReadonly,
+            IsOptional
         ] extends [true, true] ? Types.TReadonlyOptional<Type> : [
-            Readonly,
-            Optional
+            IsReadonly,
+            IsOptional
         ] extends [true, false] ? Types.TReadonly<Type> : [
-            Readonly,
-            Optional
+            IsReadonly,
+            IsOptional
         ] extends [false, true] ? Types.TOptional<Type> : Type);
     } : never;
 }
-type Property = Static.Tuple<[PropertyReadonly, PropertyKey, PropertyOptional, Static.Const<Colon>, Type], PropertyMapping>;
-type PropertiesEvaluate<T> = {
-    [K in keyof T]: T[K];
-} & {};
+type Property = Static.Tuple<[Readonly, PropertyKey, Optional, Static.Const<Colon>, Type], PropertyMapping>;
 type PropertyDelimiter = Static.Union<[
     Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>,
     Static.Tuple<[Static.Const<SemiColon>, Static.Const<Newline>]>,
@@ -210,7 +288,7 @@ type PropertyDelimiter = Static.Union<[
     Static.Tuple<[Static.Const<SemiColon>]>,
     Static.Tuple<[Static.Const<Newline>]>
 ]>;
-type PropertiesReduce<PropertiesArray extends Types.TProperties[], Result extends Types.TProperties = {}> = (PropertiesArray extends [infer Left extends Types.TProperties, ...infer Right extends Types.TProperties[]] ? PropertiesReduce<Right, PropertiesEvaluate<Result & Left>> : Result);
+type PropertiesReduce<PropertiesArray extends Types.TProperties[], Result extends Types.TProperties = {}> = (PropertiesArray extends [infer Left extends Types.TProperties, ...infer Right extends Types.TProperties[]] ? PropertiesReduce<Right, Types.Evaluate<Result & Left>> : Result);
 interface PropertiesMapping extends Static.IMapping {
     output: this['input'] extends Types.TProperties[] ? PropertiesReduce<this['input']> : never;
 }
@@ -263,7 +341,7 @@ type Constructor = Static.Tuple<[
     Type
 ], ConstructorMapping>;
 interface MappedMapping extends Static.IMapping {
-    output: this['input'] extends [LBrace, LBracket, infer Key extends string, 'in', infer Right extends Types.TSchema, RBracket, Colon, infer Type extends Types.TSchema, RBrace] ? Types.TLiteral<'Mapped types not supported'> : this['input'];
+    output: this['input'] extends [LBrace, LBracket, infer _Key extends string, 'in', infer _Right extends Types.TSchema, RBracket, Colon, infer Type extends Types.TSchema, RBrace] ? Types.TLiteral<'Mapped types not supported'> : this['input'];
 }
 type Mapped = Static.Tuple<[
     Static.Const<LBrace>,
@@ -378,7 +456,7 @@ type Partial = Static.Tuple<[
     Static.Const<RAngle>
 ], PartialMapping>;
 interface RequiredMapping extends Static.IMapping {
-    output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TPartial<Type> : never;
+    output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TRequired<Type> : never;
 }
 type Required = Static.Tuple<[
     Static.Const<'Required'>,
@@ -387,7 +465,7 @@ type Required = Static.Tuple<[
     Static.Const<RAngle>
 ], RequiredMapping>;
 interface PickMapping extends Static.IMapping {
-    output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TPick<Type, Types.TIndexPropertyKeys<PropertyKey>> : never;
+    output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TPick<Type, Key> : never;
 }
 type Pick = Static.Tuple<[
     Static.Const<'Pick'>,
@@ -398,7 +476,7 @@ type Pick = Static.Tuple<[
     Static.Const<RAngle>
 ], PickMapping>;
 interface OmitMapping extends Static.IMapping {
-    output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TOmit<Type, Types.TIndexPropertyKeys<PropertyKey>> : never;
+    output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TOmit<Type, Key> : never;
 }
 type Omit = Static.Tuple<[
     Static.Const<'Omit'>,
@@ -468,4 +546,10 @@ type Uncapitalize = Static.Tuple<[
 ], UncapitalizeMapping>;
 type Date = Static.Const<'Date', Static.As<Types.TDate>>;
 type Uint8Array = Static.Const<'Uint8Array', Static.As<Types.TUint8Array>>;
+export type Main = Static.Union<[
+    ModuleDeclaration,
+    TypeAliasDeclaration,
+    InterfaceDeclaration,
+    Type
+]>;
 export {};

package/build/cjs/type/array/array.d.ts

@@ -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>(items: T, options?: ArrayOptions): TArray<T>;
+export declare function Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
 export {};

package/build/cjs/type/awaited/awaited.d.ts

@@ -1,9 +1,14 @@
+import { Ensure } from '../helpers/index';
 import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TComputed } from '../computed/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPromise } from '../promise/index';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TAwaited<L>]> : Acc;
-export type TAwaited<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TAwaited<S> : T;
+import { type TRef } from '../ref/index';
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<(TComputed<'Awaited', [TComputed<Target, Parameters>]>)>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Awaited', [TRef<Ref>]>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, [...Result, TAwaited<Left>]> : Result);
+export type TAwaited<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TPromise<infer Type extends TSchema> ? TAwaited<Type> : Type);
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TAwaited<T>;
+export declare function Awaited<T extends TSchema>(type: T, options?: SchemaOptions): TAwaited<T>;
 export {};

package/build/cjs/type/awaited/awaited.js

@@ -2,40 +2,40 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Awaited = Awaited;
-const index_1 = require("../intersect/index");
-const index_2 = require("../union/index");
 const type_1 = require("../create/type");
+const index_1 = require("../computed/index");
+const index_2 = require("../intersect/index");
+const index_3 = require("../union/index");
+const index_4 = require("../ref/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromRest(T) {
-    return T.map(L => AwaitedResolve(L));
+function FromComputed(target, parameters) {
+    return (0, index_1.Computed)('Awaited', [(0, index_1.Computed)(target, parameters)]);
 }
 // prettier-ignore
-function FromIntersect(T) {
-    return (0, index_1.Intersect)(FromRest(T));
+function FromRef($ref) {
+    return (0, index_1.Computed)('Awaited', [(0, index_4.Ref)($ref)]);
 }
 // prettier-ignore
-function FromUnion(T) {
-    return (0, index_2.Union)(FromRest(T));
+function FromIntersect(types) {
+    return (0, index_2.Intersect)(FromRest(types));
 }
 // prettier-ignore
-function FromPromise(T) {
-    return AwaitedResolve(T);
+function FromUnion(types) {
+    return (0, index_3.Union)(FromRest(types));
 }
-// ----------------------------------------------------------------
-// AwaitedResolve
-// ----------------------------------------------------------------
 // prettier-ignore
-function AwaitedResolve(T) {
-    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf) :
-        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-            (0, kind_1.IsPromise)(T) ? FromPromise(T.item) :
-                T);
+function FromPromise(type) {
+    return Awaited(type);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => Awaited(type));
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-function Awaited(T, options) {
-    return (0, type_1.CreateType)(AwaitedResolve(T), options);
+function Awaited(type, options) {
+    return (0, type_1.CreateType)((0, kind_1.IsComputed)(type) ? FromComputed(type.target, type.parameters) : (0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf) : (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) : (0, kind_1.IsPromise)(type) ? FromPromise(type.item) : (0, kind_1.IsRef)(type) ? FromRef(type.$ref) : type, options);
 }

package/build/cjs/type/computed/computed.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/symbols';
+export interface TComputed<Target extends string = string, Parameters extends TSchema[] = []> extends TSchema {
+    [Kind]: 'Computed';
+    target: Target;
+    parameters: Parameters;
+}
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+export declare function Computed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: [...Parameters], options?: SchemaOptions): TComputed<Target, Parameters>;

package/build/cjs/type/computed/computed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Computed = Computed;
+const index_1 = require("../create/index");
+const symbols_1 = require("../symbols/symbols");
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+function Computed(target, parameters, options) {
+    return (0, index_1.CreateType)({ [symbols_1.Kind]: 'Computed', target, parameters }, options);
+}

package/build/cjs/type/computed/index.d.ts

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

package/build/cjs/type/{deref → computed}/index.js

@@ -15,4 +15,4 @@ 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 });
-__exportStar(require("./deref"), exports);
+__exportStar(require("./computed"), exports);

package/build/cjs/type/guard/kind.d.ts

@@ -1,8 +1,9 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
 import { TransformOptions } from '../transform/index';
-import { TTemplateLiteral } from '../template-literal/index';
-import { TArray } from '../array/index';
-import { TBoolean } from '../boolean/index';
+import type { TTemplateLiteral } from '../template-literal/index';
+import type { TArray } from '../array/index';
+import type { TBoolean } from '../boolean/index';
+import type { TComputed } from '../computed/index';
 import type { TRecord } from '../record/index';
 import type { TString } from '../string/index';
 import type { TUnion } from '../union/index';
@@ -11,10 +12,11 @@ import type { TAsyncIterator } from '../async-iterator/index';
 import type { TBigInt } from '../bigint/index';
 import type { TConstructor } from '../constructor/index';
 import type { TFunction } from '../function/index';
+import type { TImport } from '../module/index';
 import type { TInteger } from '../integer/index';
 import type { TIntersect } from '../intersect/index';
 import type { TIterator } from '../iterator/index';
-import type { TLiteral } from '../literal/index';
+import type { TLiteral, TLiteralValue } from '../literal/index';
 import type { TMappedKey, TMappedResult } from '../mapped/index';
 import type { TNever } from '../never/index';
 import type { TNot } from '../not/index';
@@ -50,6 +52,8 @@ export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator
 export declare function IsBigInt(value: unknown): value is TBigInt;
 /** `[Kind-Only]` Returns true if the given value is TBoolean */
 export declare function IsBoolean(value: unknown): value is TBoolean;
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+export declare function IsComputed(value: unknown): value is TComputed;
 /** `[Kind-Only]` Returns true if the given value is TConstructor */
 export declare function IsConstructor(value: unknown): value is TConstructor;
 /** `[Kind-Only]` Returns true if the given value is TDate */
@@ -57,6 +61,8 @@ export declare function IsDate(value: unknown): value is TDate;
 /** `[Kind-Only]` Returns true if the given value is TFunction */
 export declare function IsFunction(value: unknown): value is TFunction;
 /** `[Kind-Only]` Returns true if the given value is TInteger */
+export declare function IsImport(value: unknown): value is TImport;
+/** `[Kind-Only]` Returns true if the given value is TInteger */
 export declare function IsInteger(value: unknown): value is TInteger;
 /** `[Kind-Only]` Returns true if the given schema is TProperties */
 export declare function IsProperties(value: unknown): value is TProperties;
@@ -74,6 +80,8 @@ export declare function IsLiteralString(value: unknown): value is TLiteral<strin
 export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
 /** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
 export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
 /** `[Kind-Only]` Returns true if the given value is TLiteral */
 export declare function IsLiteral(value: unknown): value is TLiteral;
 /** `[Kind-Only]` Returns true if the given value is a TMappedKey */

package/build/cjs/type/guard/kind.js

@@ -8,9 +8,11 @@ exports.IsArray = IsArray;
 exports.IsAsyncIterator = IsAsyncIterator;
 exports.IsBigInt = IsBigInt;
 exports.IsBoolean = IsBoolean;
+exports.IsComputed = IsComputed;
 exports.IsConstructor = IsConstructor;
 exports.IsDate = IsDate;
 exports.IsFunction = IsFunction;
+exports.IsImport = IsImport;
 exports.IsInteger = IsInteger;
 exports.IsProperties = IsProperties;
 exports.IsIntersect = IsIntersect;
@@ -19,6 +21,7 @@ exports.IsKindOf = IsKindOf;
 exports.IsLiteralString = IsLiteralString;
 exports.IsLiteralNumber = IsLiteralNumber;
 exports.IsLiteralBoolean = IsLiteralBoolean;
+exports.IsLiteralValue = IsLiteralValue;
 exports.IsLiteral = IsLiteral;
 exports.IsMappedKey = IsMappedKey;
 exports.IsMappedResult = IsMappedResult;
@@ -76,6 +79,10 @@ function IsBigInt(value) {
 function IsBoolean(value) {
     return IsKindOf(value, 'Boolean');
 }
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+function IsComputed(value) {
+    return IsKindOf(value, 'Computed');
+}
 /** `[Kind-Only]` Returns true if the given value is TConstructor */
 function IsConstructor(value) {
     return IsKindOf(value, 'Constructor');
@@ -89,6 +96,10 @@ function IsFunction(value) {
     return IsKindOf(value, 'Function');
 }
 /** `[Kind-Only]` Returns true if the given value is TInteger */
+function IsImport(value) {
+    return IsKindOf(value, 'Import');
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
 function IsInteger(value) {
     return IsKindOf(value, 'Integer');
 }
@@ -120,6 +131,10 @@ function IsLiteralNumber(value) {
 function IsLiteralBoolean(value) {
     return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
 }
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+function IsLiteralValue(value) {
+    return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
+}
 /** `[Kind-Only]` Returns true if the given value is TLiteral */
 function IsLiteral(value) {
     return IsKindOf(value, 'Literal');

package/build/cjs/type/guard/type.d.ts

@@ -1,9 +1,10 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
 import { TypeBoxError } from '../error/index';
 import { TransformOptions } from '../transform/index';
-import { TTemplateLiteral } from '../template-literal/index';
-import { TArray } from '../array/index';
-import { TBoolean } from '../boolean/index';
+import type { TTemplateLiteral } from '../template-literal/index';
+import type { TArray } from '../array/index';
+import type { TBoolean } from '../boolean/index';
+import type { TComputed } from '../computed/index';
 import type { TRecord } from '../record/index';
 import type { TString } from '../string/index';
 import type { TUnion } from '../union/index';
@@ -12,6 +13,7 @@ import type { TAsyncIterator } from '../async-iterator/index';
 import type { TBigInt } from '../bigint/index';
 import type { TConstructor } from '../constructor/index';
 import type { TFunction } from '../function/index';
+import type { TImport } from '../module/index';
 import type { TInteger } from '../integer/index';
 import type { TIntersect } from '../intersect/index';
 import type { TIterator } from '../iterator/index';
@@ -53,12 +55,16 @@ export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator
 export declare function IsBigInt(value: unknown): value is TBigInt;
 /** Returns true if the given value is TBoolean */
 export declare function IsBoolean(value: unknown): value is TBoolean;
+/** Returns true if the given value is TComputed */
+export declare function IsComputed(value: unknown): value is TComputed;
 /** Returns true if the given value is TConstructor */
 export declare function IsConstructor(value: unknown): value is TConstructor;
 /** Returns true if the given value is TDate */
 export declare function IsDate(value: unknown): value is TDate;
 /** Returns true if the given value is TFunction */
 export declare function IsFunction(value: unknown): value is TFunction;
+/** Returns true if the given value is TImport */
+export declare function IsImport(value: unknown): value is TImport;
 /** Returns true if the given value is TInteger */
 export declare function IsInteger(value: unknown): value is TInteger;
 /** Returns true if the given schema is TProperties */

package/build/cjs/type/guard/type.js

@@ -9,9 +9,11 @@ exports.IsArray = IsArray;
 exports.IsAsyncIterator = IsAsyncIterator;
 exports.IsBigInt = IsBigInt;
 exports.IsBoolean = IsBoolean;
+exports.IsComputed = IsComputed;
 exports.IsConstructor = IsConstructor;
 exports.IsDate = IsDate;
 exports.IsFunction = IsFunction;
+exports.IsImport = IsImport;
 exports.IsInteger = IsInteger;
 exports.IsProperties = IsProperties;
 exports.IsIntersect = IsIntersect;
@@ -61,6 +63,7 @@ const KnownTypes = [
     'AsyncIterator',
     'BigInt',
     'Boolean',
+    'Computed',
     'Constructor',
     'Date',
     'Enum',
@@ -194,6 +197,10 @@ function IsBoolean(value) {
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TComputed */
+function IsComputed(value) {
+    return IsKindOf(value, 'Computed') && IsString(value.target) && ValueGuard.IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+}
 /** Returns true if the given value is TConstructor */
 function IsConstructor(value) {
     // prettier-ignore
@@ -225,6 +232,18 @@ function IsFunction(value) {
         value.parameters.every(schema => IsSchema(schema)) &&
         IsSchema(value.returns));
 }
+/** Returns true if the given value is TImport */
+function IsImport(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Import') &&
+        ValueGuard.HasPropertyKey(value, '$defs') &&
+        ValueGuard.IsObject(value.$defs) &&
+        IsProperties(value.$defs) &&
+        ValueGuard.HasPropertyKey(value, '$ref') &&
+        ValueGuard.IsString(value.$ref) &&
+        value.$ref in value.$defs // required
+    );
+}
 /** Returns true if the given value is TInteger */
 function IsInteger(value) {
     return (IsKindOf(value, 'Integer') &&

package/build/cjs/type/index.d.ts

@@ -10,7 +10,6 @@ export * from './const/index';
 export * from './constructor/index';
 export * from './constructor-parameters/index';
 export * from './date/index';
-export * from './deref/index';
 export * from './discard/index';
 export * from './enum/index';
 export * from './error/index';
@@ -29,6 +28,7 @@ export * from './iterator/index';
 export * from './keyof/index';
 export * from './literal/index';
 export * from './mapped/index';
+export * from './module/index';
 export * from './never/index';
 export * from './not/index';
 export * from './null/index';
@@ -54,7 +54,6 @@ export * from './return-type/index';
 export * from './schema/index';
 export * from './sets/index';
 export * from './static/index';
-export * from './strict/index';
 export * from './string/index';
 export * from './symbol/index';
 export * from './symbols/index';

package/build/cjs/type/index.js

@@ -27,7 +27,6 @@ __exportStar(require("./const/index"), exports);
 __exportStar(require("./constructor/index"), exports);
 __exportStar(require("./constructor-parameters/index"), exports);
 __exportStar(require("./date/index"), exports);
-__exportStar(require("./deref/index"), exports);
 __exportStar(require("./discard/index"), exports);
 __exportStar(require("./enum/index"), exports);
 __exportStar(require("./error/index"), exports);
@@ -46,6 +45,7 @@ __exportStar(require("./iterator/index"), exports);
 __exportStar(require("./keyof/index"), exports);
 __exportStar(require("./literal/index"), exports);
 __exportStar(require("./mapped/index"), exports);
+__exportStar(require("./module/index"), exports);
 __exportStar(require("./never/index"), exports);
 __exportStar(require("./not/index"), exports);
 __exportStar(require("./null/index"), exports);
@@ -71,7 +71,6 @@ __exportStar(require("./return-type/index"), exports);
 __exportStar(require("./schema/index"), exports);
 __exportStar(require("./sets/index"), exports);
 __exportStar(require("./static/index"), exports);
-__exportStar(require("./strict/index"), exports);
 __exportStar(require("./string/index"), exports);
 __exportStar(require("./symbol/index"), exports);
 __exportStar(require("./symbols/index"), exports);

package/build/cjs/type/indexed/indexed-from-mapped-key.d.ts

@@ -3,11 +3,11 @@ import type { Ensure, Evaluate } from '../helpers/index';
 import type { TProperties } from '../object/index';
 import { type TIndex } from './indexed';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
-type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TIndex<T, [K]>;
+type TMappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TIndex<Type, [Key]>;
 };
-type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>> : Acc);
-type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<T, K['keys']>>;
-export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
+type TMappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TMappedIndexPropertyKeys<Type, Right, Result & TMappedIndexPropertyKey<Type, Left>> : Result);
+type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<Type, MappedKey['keys']>>;
+export type TIndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>> = (Ensure<TMappedResult<Properties>>);
+export declare function IndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

package/build/cjs/type/indexed/indexed-from-mapped-key.js

@@ -6,21 +6,21 @@ const indexed_1 = require("./indexed");
 const index_1 = require("../mapped/index");
 const value_1 = require("../clone/value");
 // prettier-ignore
-function MappedIndexPropertyKey(T, K, options) {
-    return { [K]: (0, indexed_1.Index)(T, [K], (0, value_1.Clone)(options)) };
+function MappedIndexPropertyKey(type, key, options) {
+    return { [key]: (0, indexed_1.Index)(type, [key], (0, value_1.Clone)(options)) };
 }
 // prettier-ignore
-function MappedIndexPropertyKeys(T, K, options) {
-    return K.reduce((Acc, L) => {
-        return { ...Acc, ...MappedIndexPropertyKey(T, L, options) };
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, left) => {
+        return { ...result, ...MappedIndexPropertyKey(type, left, options) };
     }, {});
 }
 // prettier-ignore
-function MappedIndexProperties(T, K, options) {
-    return MappedIndexPropertyKeys(T, K.keys, options);
+function MappedIndexProperties(type, mappedKey, options) {
+    return MappedIndexPropertyKeys(type, mappedKey.keys, options);
 }
 // prettier-ignore
-function IndexFromMappedKey(T, K, options) {
-    const P = MappedIndexProperties(T, K, options);
-    return (0, index_1.MappedResult)(P);
+function IndexFromMappedKey(type, mappedKey, options) {
+    const properties = MappedIndexProperties(type, mappedKey, options);
+    return (0, index_1.MappedResult)(properties);
 }