@sinclair/typebox 0.33.21 → 0.34.0

package/build/esm/{parse → syntax}/static.d.mts

@@ -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>,
@@ -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/esm/type/guard/kind.d.mts

@@ -11,6 +11,7 @@ import type { TAsyncIterator } from '../async-iterator/index.mjs';
 import type { TBigInt } from '../bigint/index.mjs';
 import type { TConstructor } from '../constructor/index.mjs';
 import type { TFunction } from '../function/index.mjs';
+import type { TImport } from '../module/index.mjs';
 import type { TInteger } from '../integer/index.mjs';
 import type { TIntersect } from '../intersect/index.mjs';
 import type { TIterator } from '../iterator/index.mjs';
@@ -57,6 +58,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;

package/build/esm/type/guard/kind.mjs

@@ -41,6 +41,10 @@ export function IsFunction(value) {
     return IsKindOf(value, 'Function');
 }
 /** `[Kind-Only]` Returns true if the given value is TInteger */
+export function IsImport(value) {
+    return IsKindOf(value, 'Import');
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
 export function IsInteger(value) {
     return IsKindOf(value, 'Integer');
 }

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

@@ -12,6 +12,7 @@ import type { TAsyncIterator } from '../async-iterator/index.mjs';
 import type { TBigInt } from '../bigint/index.mjs';
 import type { TConstructor } from '../constructor/index.mjs';
 import type { TFunction } from '../function/index.mjs';
+import type { TImport } from '../module/index.mjs';
 import type { TInteger } from '../integer/index.mjs';
 import type { TIntersect } from '../intersect/index.mjs';
 import type { TIterator } from '../iterator/index.mjs';
@@ -59,6 +60,8 @@ export declare function IsConstructor(value: unknown): value is TConstructor;
 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/esm/type/guard/type.mjs

@@ -173,6 +173,18 @@ export function IsFunction(value) {
         value.parameters.every(schema => IsSchema(schema)) &&
         IsSchema(value.returns));
 }
+/** Returns true if the given value is TImport */
+export 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 */
 export function IsInteger(value) {
     return (IsKindOf(value, 'Integer') &&

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

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

package/build/esm/type/index.mjs

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

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

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

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

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

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

@@ -0,0 +1,71 @@
+import { Ensure } from '../helpers/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+import { SchemaOptions, TSchema } from '../schema/index.mjs';
+import { TObject, TProperties } from '../object/index.mjs';
+import { TConstructor } from '../constructor/index.mjs';
+import { TFunction } from '../function/index.mjs';
+import { TTuple } from '../tuple/index.mjs';
+import { TIntersect } from '../intersect/index.mjs';
+import { TUnion } from '../union/index.mjs';
+import { TArray } from '../array/index.mjs';
+import { TAsyncIterator } from '../async-iterator/index.mjs';
+import { TIterator } from '../iterator/index.mjs';
+import { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { TAny } from '../any/index.mjs';
+import { TBigInt } from '../bigint/index.mjs';
+import { TBoolean } from '../boolean/index.mjs';
+import { TDate } from '../date/index.mjs';
+import { TInteger } from '../integer/index.mjs';
+import { TNever } from '../never/index.mjs';
+import { TNumber } from '../number/index.mjs';
+import { TNull } from '../null/index.mjs';
+import { TRef } from '../ref/index.mjs';
+import { TRegExp } from '../regexp/index.mjs';
+import { TString } from '../string/index.mjs';
+import { TSymbol } from '../symbol/index.mjs';
+import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index.mjs';
+import { TUint8Array } from '../uint8array/index.mjs';
+import { TUndefined } from '../undefined/index.mjs';
+import { TUnknown } from '../unknown/index.mjs';
+import { TVoid } from '../void/index.mjs';
+import { Static } from '../static/index.mjs';
+type InferImport<Properties extends TProperties, Key extends keyof Properties, ModuleProperties extends TProperties> = (Infer<Properties[Key], ModuleProperties>);
+type InferRef<Ref extends string, Properties extends TProperties> = (Ref extends keyof Properties ? Infer<Properties[Ref], Properties> : never);
+type InferObject<Properties extends TProperties, ModuleProperties extends TProperties> = {
+    [K in keyof Properties]: Infer<Properties[K], ModuleProperties>;
+} & {};
+type InferConstructor<Parameters extends TSchema[], InstanceType extends TSchema, Properties extends TProperties> = Ensure<new (...args: InferTuple<Parameters, Properties>) => Infer<InstanceType, Properties>>;
+type InferFunction<Parameters extends TSchema[], ReturnType extends TSchema, Properties extends TProperties> = Ensure<(...args: InferTuple<Parameters, Properties>) => Infer<ReturnType, Properties>>;
+type InferTuple<Types extends TSchema[], Properties extends TProperties, Result extends unknown[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? InferTuple<R, Properties, [...Result, Infer<L, Properties>]> : Result);
+type InferIntersect<Types extends TSchema[], Properties extends TProperties, Result extends unknown = unknown> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? InferIntersect<R, Properties, Result & Infer<L, Properties>> : Result);
+type InferUnion<Types extends TSchema[], Properties extends TProperties, Result extends unknown = never> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? InferUnion<R, Properties, Result | Infer<L, Properties>> : Result);
+type InferArray<Type extends TSchema, Module extends TProperties> = (Ensure<Array<Infer<Type, Module>>>);
+type InferAsyncIterator<Type extends TSchema, Properties extends TProperties> = (Ensure<AsyncIterableIterator<Infer<Type, Properties>>>);
+type InferIterator<Type extends TSchema, Properties extends TProperties> = (Ensure<IterableIterator<Infer<Type, Properties>>>);
+type Infer<Type extends TSchema, Properties extends TProperties = {}> = (Type extends TImport<infer S extends TProperties, infer K extends string> ? InferImport<S, K, S> : Type extends TRef<infer S extends string> ? InferRef<S, Properties> : Type extends TObject<infer S extends TProperties> ? InferObject<S, Properties> : Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? InferConstructor<S, R, Properties> : Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? InferFunction<S, R, Properties> : Type extends TTuple<infer S extends TSchema[]> ? InferTuple<S, Properties> : Type extends TIntersect<infer S extends TSchema[]> ? InferIntersect<S, Properties> : Type extends TUnion<infer S extends TSchema[]> ? InferUnion<S, Properties> : Type extends TArray<infer S extends TSchema> ? InferArray<S, Properties> : Type extends TAsyncIterator<infer S extends TSchema> ? InferAsyncIterator<S, Properties> : Type extends TIterator<infer S extends TSchema> ? InferIterator<S, Properties> : Type extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? Static<TTemplateLiteral<S>> : Type extends TLiteral<infer S extends TLiteralValue> ? S : Type extends TAny ? any : Type extends TBigInt ? bigint : Type extends TBoolean ? boolean : Type extends TDate ? Date : Type extends TInteger ? number : Type extends TNever ? never : Type extends TNumber ? number : Type extends TRegExp ? string : Type extends TString ? string : Type extends TSymbol ? symbol : Type extends TNull ? null : Type extends TUint8Array ? Uint8Array : Type extends TUndefined ? undefined : Type extends TUnknown ? unknown : Type extends TVoid ? void : never);
+export interface TDefinitions<ModuleProperties extends TProperties> extends TSchema {
+    static: {
+        [K in keyof ModuleProperties]: Static<ModuleProperties[K]>;
+    };
+    $defs: ModuleProperties;
+}
+export interface TImport<ModuleProperties extends TProperties = {}, Key extends keyof ModuleProperties = keyof ModuleProperties> extends TSchema {
+    [Kind]: 'Import';
+    static: InferImport<ModuleProperties, Key, ModuleProperties>;
+    $defs: ModuleProperties;
+    $ref: Key;
+}
+export declare class TModule<Properties extends TProperties> {
+    private readonly $defs;
+    private readonly options;
+    constructor($defs: Properties, options?: SchemaOptions);
+    /** `[Json]` Returns the Type definitions for this module */
+    Defs(): TDefinitions<Properties>;
+    /** `[Json]` Imports a Type by Key. */
+    Import<Key extends keyof Properties>(key: Key, options?: SchemaOptions): TImport<Properties, Key>;
+    /** `[Internal]` For each definition, assign an `$id` property. */
+    private ResolveDefinitionsWithIdentifiers;
+}
+/** `[Json]` Creates a Type Definition Module. */
+export declare function Module<Properties extends TProperties>(properties: Properties): TModule<Properties>;
+export {};

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

@@ -0,0 +1,28 @@
+import { CreateType } from '../create/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+export class TModule {
+    constructor($defs, options = {}) {
+        this.$defs = $defs;
+        this.options = options;
+    }
+    /** `[Json]` Returns the Type definitions for this module */
+    Defs() {
+        return CreateType({ $defs: this.ResolveDefinitionsWithIdentifiers() }, this.options);
+    }
+    /** `[Json]` Imports a Type by Key. */
+    Import(key, options) {
+        return CreateType({ [Kind]: 'Import', $defs: this.ResolveDefinitionsWithIdentifiers(), $ref: key }, options);
+    }
+    /** `[Internal]` For each definition, assign an `$id` property. */
+    ResolveDefinitionsWithIdentifiers() {
+        return globalThis.Object.getOwnPropertyNames(this.$defs).reduce((Result, Key) => ({ ...Result, [Key]: { ...this.$defs[Key], $id: Key } }), {});
+    }
+}
+/** `[Json]` Creates a Type Definition Module. */
+export function Module(properties) {
+    return new TModule(properties);
+}

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

@@ -1,12 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-export interface TRef<T extends TSchema = TSchema> extends TSchema {
+export interface TRef<Ref extends string = string> extends TSchema {
     [Kind]: 'Ref';
-    static: Static<T, this['params']>;
-    $ref: string;
+    static: unknown;
+    $ref: Ref;
 }
 /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-export declare function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
-/** `[Json]` Creates a Ref type. */
-export declare function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+export declare function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;

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

@@ -1,14 +1,6 @@
 import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
-// ------------------------------------------------------------------
-// ValueGuard
-// ------------------------------------------------------------------
-import { IsString, IsUndefined } from '../guard/value.mjs';
-/** `[Json]` Creates a Ref type. */
-export function Ref(unresolved, options) {
-    if (IsString(unresolved))
-        return CreateType({ [Kind]: 'Ref', $ref: unresolved }, options);
-    if (IsUndefined(unresolved.$id))
-        throw new Error('Reference target type must specify an $id');
-    return CreateType({ [Kind]: 'Ref', $ref: unresolved.$id }, options);
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+export function Ref($ref, options) {
+    return CreateType({ [Kind]: 'Ref', $ref }, options);
 }

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

@@ -23,7 +23,7 @@ export type TDecodeProperties<T extends TProperties> = {
     [K in keyof T]: TDecodeType<T[K]>;
 };
 export type TDecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TDecodeRest<R, [...Acc, TDecodeType<L>]> : Acc;
-export type TDecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<TDecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> : T);
+export type TDecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> : T extends TRef<infer S extends string> ? TRef<S> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> : T);
 export type StaticDecodeIsAny<T> = boolean extends (T extends TSchema ? true : false) ? true : false;
 /** Creates an decoded static type from a TypeBox type */
 export type StaticDecode<T extends TSchema, P extends unknown[] = []> = StaticDecodeIsAny<T> extends true ? unknown : Static<TDecodeType<T>, P>;

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

@@ -3,7 +3,6 @@ import { type TArray, type ArrayOptions } from '../array/index.mjs';
 import { type TBoolean } from '../boolean/index.mjs';
 import { type TComposite } from '../composite/index.mjs';
 import { type TConst } from '../const/index.mjs';
-import { type TDeref } from '../deref/index.mjs';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index.mjs';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
@@ -19,6 +18,7 @@ import { type TNever } from '../never/index.mjs';
 import { type TNot } from '../not/index.mjs';
 import { type TNull } from '../null/index.mjs';
 import { type TMappedKey } from '../mapped/index.mjs';
+import { TModule } from '../module/index.mjs';
 import { type TNumber, type NumberOptions } from '../number/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index.mjs';
@@ -33,7 +33,6 @@ import { type TRef } from '../ref/index.mjs';
 import { type TRequired, type TRequiredFromMappedResult } from '../required/index.mjs';
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
-import { type TStrict } from '../strict/index.mjs';
 import { type TString, type StringOptions } from '../string/index.mjs';
 import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index.mjs';
 import { TransformDecodeBuilder } from '../transform/index.mjs';
@@ -43,16 +42,6 @@ import { type TUnknown } from '../unknown/index.mjs';
 import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
 /** Json Type Builder with Static Resolution for TypeScript */
 export declare class JsonTypeBuilder {
-    /**
-     * @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<T extends TSchema>(schema: T): TStrict<T>;
     /** `[Json]` Creates a Readonly and Optional property */
     ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
     /** `[Json]` Creates a Readonly property */
@@ -83,8 +72,6 @@ export declare class JsonTypeBuilder {
     Composite<T extends TSchema[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[JavaScript]` Creates a readonly const type from the given value. */
     Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
-    /** `[Json]` Creates a dereferenced type */
-    Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
     /** `[Json]` Creates a Enum type */
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
@@ -129,6 +116,8 @@ export declare class JsonTypeBuilder {
     Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
     /** `[Json]` Creates a Mapped object type */
     Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+    /** `[Json]` Creates a Type Definition Module. */
+    Module<Properties extends TProperties>(properties: Properties): TModule<Properties>;
     /** `[Json]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
     /** `[Json]` Creates a Not type */
@@ -163,10 +152,8 @@ export declare class JsonTypeBuilder {
     Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecordOrObject<K, T>;
     /** `[Json]` Creates a Recursive type */
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     /** `[Json]` Creates a Ref type. */
-    Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+    Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
     /** `[Json]` Constructs a type where all properties are required */
     Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
     /** `[Json]` Constructs a type where all properties are required */

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,21 +40,6 @@ 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
     // ------------------------------------------------------------------------
@@ -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);
@@ -146,6 +126,10 @@ export class JsonTypeBuilder {
     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);
@@ -187,8 +171,8 @@ export class JsonTypeBuilder {
         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) {

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';