@sinclair/typebox 0.33.22 → 0.34.0

package/build/cjs/compiler/compiler.d.ts

@@ -1,7 +1,7 @@
 import { ValueErrorIterator } from '../errors/index';
 import { TypeBoxError } from '../type/error/index';
 import type { TSchema } from '../type/schema/index';
-import type { Static, StaticDecode } from '../type/static/index';
+import type { Static, StaticDecode, StaticEncode } from '../type/static/index';
 export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends TSchema> {
     private readonly schema;
@@ -19,7 +19,7 @@ export declare class TypeCheck<T extends TSchema> {
     /** Decodes a value or throws if error */
     Decode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
     /** Encodes a value or throws if error */
-    Encode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
+    Encode<Static = StaticEncode<T>, Result extends Static = Static>(value: unknown): Result;
 }
 export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/cjs/compiler/compiler.js

@@ -262,6 +262,11 @@ var TypeCompiler;
     function* FromFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
+    function* FromImport(schema, references, value) {
+        const definitions = globalThis.Object.values(schema.$defs);
+        const target = schema.$defs[schema.$ref];
+        yield* Visit(target, [...references, ...definitions], value);
+    }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
         if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
@@ -379,9 +384,13 @@ var TypeCompiler;
     function* FromRef(schema, references, value) {
         const target = (0, index_5.Deref)(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
-        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
-        if (state.functions.has(schema.$ref))
+        // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
+        // passes. This operation is very awkward as we are using the functions state to store values to
+        // enable self referential types to terminate. This needs to be refactored.
+        const recursiveEnd = `_recursion_end_for_${schema.$ref}`;
+        if (state.functions.has(recursiveEnd))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
+        state.functions.set(recursiveEnd, ''); // terminate recursion here by setting the name.
         yield* Visit(target, references, value);
     }
     function* FromRegExp(schema, references, value) {
@@ -488,6 +497,8 @@ var TypeCompiler;
                 return yield* FromDate(schema_, references_, value);
             case 'Function':
                 return yield* FromFunction(schema_, references_, value);
+            case 'Import':
+                return yield* FromImport(schema_, references_, value);
             case 'Integer':
                 return yield* FromInteger(schema_, references_, value);
             case 'Intersect':

package/build/cjs/errors/errors.js

@@ -239,6 +239,11 @@ function* FromFunction(schema, references, path, value) {
     if (!(0, index_10.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
+function* FromImport(schema, references, path, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    yield* Visit(target, [...references, ...definitions], path, value);
+}
 function* FromInteger(schema, references, path, value) {
     if (!(0, index_10.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
@@ -530,6 +535,8 @@ function* Visit(schema, references, path, value) {
             return yield* FromDate(schema_, references_, path, value);
         case 'Function':
             return yield* FromFunction(schema_, references_, path, value);
+        case 'Import':
+            return yield* FromImport(schema_, references_, path, value);
         case 'Integer':
             return yield* FromInteger(schema_, references_, path, value);
         case 'Intersect':

package/build/cjs/index.d.ts

@@ -18,7 +18,6 @@ export * from './type/const/index';
 export * from './type/constructor/index';
 export * from './type/constructor-parameters/index';
 export * from './type/date/index';
-export * from './type/deref/index';
 export * from './type/enum/index';
 export * from './type/exclude/index';
 export * from './type/extends/index';
@@ -32,6 +31,7 @@ export * from './type/iterator/index';
 export * from './type/intrinsic/index';
 export * from './type/keyof/index';
 export * from './type/literal/index';
+export * from './type/module/index';
 export * from './type/mapped/index';
 export * from './type/never/index';
 export * from './type/not/index';
@@ -55,7 +55,6 @@ export * from './type/rest/index';
 export * from './type/return-type/index';
 export * from './type/schema/index';
 export * from './type/static/index';
-export * from './type/strict/index';
 export * from './type/string/index';
 export * from './type/symbol/index';
 export * from './type/template-literal/index';

package/build/cjs/index.js

@@ -41,7 +41,6 @@ __exportStar(require("./type/const/index"), exports);
 __exportStar(require("./type/constructor/index"), exports);
 __exportStar(require("./type/constructor-parameters/index"), exports);
 __exportStar(require("./type/date/index"), exports);
-__exportStar(require("./type/deref/index"), exports);
 __exportStar(require("./type/enum/index"), exports);
 __exportStar(require("./type/exclude/index"), exports);
 __exportStar(require("./type/extends/index"), exports);
@@ -55,6 +54,7 @@ __exportStar(require("./type/iterator/index"), exports);
 __exportStar(require("./type/intrinsic/index"), exports);
 __exportStar(require("./type/keyof/index"), exports);
 __exportStar(require("./type/literal/index"), exports);
+__exportStar(require("./type/module/index"), exports);
 __exportStar(require("./type/mapped/index"), exports);
 __exportStar(require("./type/never/index"), exports);
 __exportStar(require("./type/not/index"), exports);
@@ -78,7 +78,6 @@ __exportStar(require("./type/rest/index"), exports);
 __exportStar(require("./type/return-type/index"), exports);
 __exportStar(require("./type/schema/index"), exports);
 __exportStar(require("./type/static/index"), exports);
-__exportStar(require("./type/strict/index"), exports);
 __exportStar(require("./type/string/index"), exports);
 __exportStar(require("./type/symbol/index"), exports);
 __exportStar(require("./type/template-literal/index"), exports);

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

@@ -1,16 +1,15 @@
+import * as Types from '../type/index';
 import { Static } from './parsebox/index';
-import { TSchema, SchemaOptions } from '../type/schema/index';
-import { StaticDecode } from '../type/static/index';
-import { Type } from './static';
-/** `[Experimental]` Infers a TypeBox type from TypeScript syntax. */
-export type StaticParseAsSchema<Context extends Record<PropertyKey, TSchema>, Code extends string> = Static.Parse<Type, Code, Context>[0];
-/** `[Experimental]` Infers a TypeScript type from TypeScript syntax. */
-export type StaticParseAsType<Context extends Record<PropertyKey, TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends TSchema ? StaticDecode<Type> : undefined;
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
-export declare function Parse<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): StaticParseAsSchema<Context, Code>;
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
-export declare function Parse<Code extends string>(code: Code, options?: SchemaOptions): StaticParseAsSchema<{}, Code>;
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
-export declare function ParseOnly<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined;
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax */
-export declare function ParseOnly<Code extends string>(code: Code, options?: SchemaOptions): TSchema | undefined;
+import { Main } from './static';
+/** `[Syntax]` Infers a TypeBox type from TypeScript syntax. */
+export type StaticParseAsSchema<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = Static.Parse<Main, Code, Context>[0];
+/** `[Syntax]` Infers a TypeScript type from TypeScript syntax. */
+export type StaticParseAsType<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends Types.TSchema ? Types.StaticDecode<Type> : undefined;
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
+export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<Context, Code>;
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
+export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<{}, Code>;
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
+export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax */
+export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;

package/build/cjs/syntax/parse.js

@@ -3,16 +3,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parse = Parse;
 exports.ParseOnly = ParseOnly;
-const type_1 = require("../type/create/type");
+const Types = require("../type/index");
 const runtime_1 = require("./runtime");
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
 function Parse(...args) {
     return ParseOnly.apply(null, args);
 }
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
 function ParseOnly(...args) {
     const withContext = typeof args[0] === 'string' ? false : true;
     const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const type = runtime_1.Module.Parse('Type', code, context)[0];
-    return (type !== undefined ? (0, type_1.CreateType)(type, options) : undefined);
+    const type = runtime_1.Module.Parse('Main', code, context)[0];
+    // Note: Parsing may return either a ModuleInstance or Type. We only apply options on the Type.
+    return Types.KindGuard.IsSchema(type) ? Types.CloneType(type, options) : type;
 }

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

@@ -1,6 +1,18 @@
 import { Runtime } from './parsebox/index';
 import * as Types from '../type/index';
 export declare const Module: Runtime.Module<{
+    ExportModifier: Runtime.IUnion<boolean>;
+    HeritageList: Runtime.IUnion<Types.TSchema[]>;
+    Heritage: Runtime.IUnion<unknown[]>;
+    InterfaceDeclaration: Runtime.ITuple<{
+        [x: string]: Types.TIntersect<[...Types.TRef<string>[], Types.TObject<Types.TProperties>]>;
+    }>;
+    TypeAliasDeclaration: Runtime.ITuple<{
+        [x: string]: Types.TSchema;
+    }>;
+    ModuleType: Runtime.IUnion<unknown>;
+    ModuleProperties: Runtime.IUnion<Types.TProperties>;
+    ModuleDeclaration: Runtime.ITuple<Types.TModule<Types.TProperties>>;
     Literal: Runtime.IUnion<Types.TLiteral<string> | Types.TLiteral<number> | Types.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<Types.TAny | Types.TNever | Types.TString | Types.TBoolean | Types.TNumber | Types.TInteger | Types.TBigInt | Types.TNull | Types.TSymbol | Types.TUndefined | Types.TUnknown | Types.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;
@@ -14,14 +26,14 @@ export declare const Module: Runtime.Module<{
     Expr: Runtime.ITuple<Types.TSchema>;
     Type: Runtime.IRef<unknown>;
     PropertyKey: Runtime.IUnion<string>;
-    PropertyReadonly: Runtime.IUnion<boolean>;
-    PropertyOptional: Runtime.IUnion<boolean>;
+    Readonly: Runtime.IUnion<boolean>;
+    Optional: Runtime.IUnion<boolean>;
     Property: Runtime.ITuple<{
         [x: string]: Types.TSchema;
     }>;
     PropertyDelimiter: Runtime.IUnion<[","] | [",", "\n"] | [";"] | [";", "\n"] | ["\n"]>;
-    Properties: Runtime.IUnion<unknown[]>;
-    Object: Runtime.ITuple<Types.TObject<Record<string, Types.TSchema>>>;
+    Properties: Runtime.IUnion<Types.TProperties>;
+    Object: Runtime.ITuple<Types.TObject<Types.TProperties>>;
     Elements: Runtime.IUnion<unknown[]>;
     Tuple: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
     Parameter: Runtime.ITuple<Types.TSchema>;
@@ -52,4 +64,5 @@ export declare const Module: Runtime.Module<{
     Date: Runtime.IConst<Types.TDate>;
     Uint8Array: Runtime.IConst<Types.TUint8Array>;
     Reference: Runtime.IIdent<Types.TSchema>;
+    Main: Runtime.IUnion<unknown>;
 }>;

package/build/cjs/syntax/runtime.js

@@ -23,6 +23,7 @@ const SemiColon = ';';
 const SingleQuote = "'";
 const DoubleQuote = '"';
 const Tilde = '`';
+const Equals = '=';
 // ------------------------------------------------------------------
 // DestructureRight
 // ------------------------------------------------------------------
@@ -33,12 +34,133 @@ function DestructureRight(values) {
         : [values, undefined];
 }
 // ------------------------------------------------------------------
+// Deref
+// ------------------------------------------------------------------
+const Deref = (context, key) => {
+    return key in context ? context[key] : Types.Ref(key);
+};
+// ------------------------------------------------------------------
+// ExportModifier
+// ------------------------------------------------------------------
+// prettier-ignore
+const ExportModifierMapping = (values) => {
+    return values.length === 1;
+};
+// prettier-ignore
+const ExportModifier = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Const('export')]), index_1.Runtime.Tuple([])
+], ExportModifierMapping);
+// ------------------------------------------------------------------
+// TypeAliasDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const TypeAliasDeclarationMapping = (_Export, _Keyword, Ident, _Equals, Type) => {
+    return { [Ident]: Type };
+};
+// prettier-ignore
+const TypeAliasDeclaration = index_1.Runtime.Tuple([
+    index_1.Runtime.Ref('ExportModifier'),
+    index_1.Runtime.Const('type'),
+    index_1.Runtime.Ident(),
+    index_1.Runtime.Const(Equals),
+    index_1.Runtime.Ref('Type')
+], value => TypeAliasDeclarationMapping(...value));
+// ------------------------------------------------------------------
+// HeritageList
+// ------------------------------------------------------------------
+// prettier-ignore (note, heritage list should disallow trailing comma)
+const HeritageListDelimiter = index_1.Runtime.Union([index_1.Runtime.Tuple([index_1.Runtime.Const(Comma), index_1.Runtime.Const(Newline)]), index_1.Runtime.Tuple([index_1.Runtime.Const(Comma)])]);
+// prettier-ignore
+const HeritageListMapping = (values, context) => {
+    return (values.length === 3 ? [Deref(context, values[0]), ...values[2]] :
+        values.length === 1 ? [Deref(context, values[0])] :
+            []);
+};
+// prettier-ignore
+const HeritageList = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Ident(), HeritageListDelimiter, index_1.Runtime.Ref('HeritageList')]),
+    index_1.Runtime.Tuple([index_1.Runtime.Ident()]),
+    index_1.Runtime.Tuple([])
+], HeritageListMapping);
+// ------------------------------------------------------------------
+// Heritage
+// ------------------------------------------------------------------
+// prettier-ignore
+const HeritageMapping = (values) => {
+    return (values.length === 2 ? values[1] : []);
+};
+// prettier-ignore
+const Heritage = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Const('extends'), index_1.Runtime.Ref('HeritageList')]),
+    index_1.Runtime.Tuple([])
+], HeritageMapping);
+// ------------------------------------------------------------------
+// InterfaceDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const InterfaceDeclarationMapping = (_0, _1, Ident, Heritage, _4, Properties, _6) => {
+    return { [Ident]: Types.Intersect([...Heritage, Types.Object(Properties)]) };
+};
+// prettier-ignore
+const InterfaceDeclaration = index_1.Runtime.Tuple([
+    index_1.Runtime.Ref('ExportModifier'),
+    index_1.Runtime.Const('interface'),
+    index_1.Runtime.Ident(),
+    index_1.Runtime.Ref('Heritage'),
+    index_1.Runtime.Const(LBrace),
+    index_1.Runtime.Ref('Properties'),
+    index_1.Runtime.Const(RBrace),
+], values => InterfaceDeclarationMapping(...values));
+// ------------------------------------------------------------------
+// ModuleType
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModuleType = index_1.Runtime.Union([
+    index_1.Runtime.Ref('InterfaceDeclaration'),
+    index_1.Runtime.Ref('TypeAliasDeclaration')
+]);
+// ------------------------------------------------------------------
+// ModuleProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModulePropertiesDelimiter = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Const(SemiColon), index_1.Runtime.Const(Newline)]),
+    index_1.Runtime.Tuple([index_1.Runtime.Const(SemiColon)]),
+    index_1.Runtime.Tuple([index_1.Runtime.Const(Newline)]),
+]);
+// prettier-ignore
+const ModulePropertiesMapping = (values) => {
+    return (values.length === 3 ? { ...values[0], ...values[2] } :
+        values.length === 1 ? values[0] :
+            {});
+};
+// prettier-ignore
+const ModuleProperties = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Ref('ModuleType'), ModulePropertiesDelimiter, index_1.Runtime.Ref('ModuleProperties')]),
+    index_1.Runtime.Tuple([index_1.Runtime.Ref('ModuleType')]),
+    index_1.Runtime.Tuple([]),
+], ModulePropertiesMapping);
+// ------------------------------------------------------------------
+// ModuleDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModuleIdentifier = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Ident()]),
+    index_1.Runtime.Tuple([])
+]);
+// prettier-ignore
+const ModuleDeclarationMapping = (_1, _2, _Ident, _3, Properties, _5) => {
+    return Types.Module(Properties);
+};
+// prettier-ignore
+const ModuleDeclaration = index_1.Runtime.Tuple([
+    index_1.Runtime.Ref('ExportModifier'), index_1.Runtime.Const('module'), ModuleIdentifier, index_1.Runtime.Const(LBrace), index_1.Runtime.Ref('ModuleProperties'), index_1.Runtime.Const(RBrace)
+], values => ModuleDeclarationMapping(...values));
+// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
 // prettier-ignore
-const Reference = index_1.Runtime.Ident((value, context) => {
-    return value in context ? context[value] : Types.Ref(value);
-});
+const Reference = index_1.Runtime.Ident((value, context) => Deref(context, value));
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
@@ -224,24 +346,21 @@ const Type = index_1.Runtime.Ref('Expr');
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
-// prettier-ignore
 const PropertyKey = index_1.Runtime.Union([index_1.Runtime.Ident(), index_1.Runtime.String([SingleQuote, DoubleQuote])]);
+const Readonly = index_1.Runtime.Union([index_1.Runtime.Tuple([index_1.Runtime.Const('readonly')]), index_1.Runtime.Tuple([])], (value) => value.length > 0);
+const Optional = index_1.Runtime.Union([index_1.Runtime.Tuple([index_1.Runtime.Const(Question)]), index_1.Runtime.Tuple([])], (value) => value.length > 0);
 // prettier-ignore
-const PropertyReadonly = index_1.Runtime.Union([index_1.Runtime.Tuple([index_1.Runtime.Const('readonly')]), index_1.Runtime.Tuple([])], value => value.length > 0);
-// prettier-ignore
-const PropertyOptional = index_1.Runtime.Union([index_1.Runtime.Tuple([index_1.Runtime.Const(Question)]), index_1.Runtime.Tuple([])], value => value.length > 0);
-// prettier-ignore
-const PropertyMapping = (Readonly, Key, Optional, _, Type) => ({
-    [Key]: (Readonly && Optional ? Types.ReadonlyOptional(Type) :
-        Readonly && !Optional ? Types.Readonly(Type) :
-            !Readonly && Optional ? Types.Optional(Type) :
+const PropertyMapping = (IsReadonly, Key, IsOptional, _, Type) => ({
+    [Key]: (IsReadonly && IsOptional ? Types.ReadonlyOptional(Type) :
+        IsReadonly && !IsOptional ? Types.Readonly(Type) :
+            !IsReadonly && IsOptional ? Types.Optional(Type) :
                 Type)
 });
 // prettier-ignore
 const Property = index_1.Runtime.Tuple([
-    index_1.Runtime.Ref('PropertyReadonly'),
+    index_1.Runtime.Ref('Readonly'),
     index_1.Runtime.Ref('PropertyKey'),
-    index_1.Runtime.Ref('PropertyOptional'),
+    index_1.Runtime.Ref('Optional'),
     index_1.Runtime.Const(Colon),
     index_1.Runtime.Ref('Type'),
 ], value => PropertyMapping(...value));
@@ -259,23 +378,21 @@ const Properties = index_1.Runtime.Union([
     index_1.Runtime.Tuple([index_1.Runtime.Ref('Property'), index_1.Runtime.Ref('PropertyDelimiter')]),
     index_1.Runtime.Tuple([index_1.Runtime.Ref('Property')]),
     index_1.Runtime.Tuple([])
-], values => (values.length === 3 ? [values[0], ...values[2]] :
-    values.length === 2 ? [values[0]] :
-        values.length === 1 ? [values[0]] :
-            []));
+], values => (values.length === 3 ? { ...values[0], ...values[2] } :
+    values.length === 2 ? values[0] :
+        values.length === 1 ? values[0] :
+            {}));
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
-const ObjectMapping = (values) => Types.Object(values.reduce((properties, record) => {
-    return { ...properties, ...record };
-}, {}));
+const ObjectMapping = (_0, Properties, _2) => Types.Object(Properties);
 // prettier-ignore
 const _Object = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LBrace),
     index_1.Runtime.Ref('Properties'),
     index_1.Runtime.Const(RBrace)
-], values => ObjectMapping(values[1]));
+], values => ObjectMapping(...values));
 // ------------------------------------------------------------------
 // Tuple
 // ------------------------------------------------------------------
@@ -344,7 +461,15 @@ const MappedMapping = (values) => {
 };
 // prettier-ignore
 const Mapped = index_1.Runtime.Tuple([
-    index_1.Runtime.Const(LBrace), index_1.Runtime.Const(LBracket), index_1.Runtime.Ident(), index_1.Runtime.Const('in'), index_1.Runtime.Ref('Type'), index_1.Runtime.Const(RBracket), index_1.Runtime.Const(Colon), index_1.Runtime.Ref('Type'), index_1.Runtime.Const(RBrace)
+    index_1.Runtime.Const(LBrace),
+    index_1.Runtime.Const(LBracket),
+    index_1.Runtime.Ident(),
+    index_1.Runtime.Const('in'),
+    index_1.Runtime.Ref('Type'),
+    index_1.Runtime.Const(RBracket),
+    index_1.Runtime.Const(Colon),
+    index_1.Runtime.Ref('Type'),
+    index_1.Runtime.Const(RBrace)
 ], MappedMapping);
 // ------------------------------------------------------------------
 // AsyncIterator
@@ -565,10 +690,34 @@ const Date = index_1.Runtime.Const('Date', index_1.Runtime.As(Types.Date()));
 // ------------------------------------------------------------------
 const Uint8Array = index_1.Runtime.Const('Uint8Array', index_1.Runtime.As(Types.Uint8Array()));
 // ------------------------------------------------------------------
+// Main
+// ------------------------------------------------------------------
+// prettier-ignore
+const Main = index_1.Runtime.Union([
+    ModuleDeclaration,
+    TypeAliasDeclaration,
+    InterfaceDeclaration,
+    Type
+]);
+// ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
 // prettier-ignore
 exports.Module = new index_1.Runtime.Module({
+    // ----------------------------------------------------------------
+    // Modules, Interfaces and Type Aliases
+    // ----------------------------------------------------------------
+    ExportModifier,
+    HeritageList,
+    Heritage,
+    InterfaceDeclaration,
+    TypeAliasDeclaration,
+    ModuleType,
+    ModuleProperties,
+    ModuleDeclaration,
+    // ----------------------------------------------------------------
+    // Type Expressions
+    // ----------------------------------------------------------------
     Literal,
     Keyword,
     KeyOf,
@@ -580,10 +729,10 @@ exports.Module = new index_1.Runtime.Module({
     ExprTerm,
     ExprTail,
     Expr,
-    Type,
+    Type, // Alias for Expr
     PropertyKey,
-    PropertyReadonly,
-    PropertyOptional,
+    Readonly,
+    Optional,
     Property,
     PropertyDelimiter,
     Properties,
@@ -617,5 +766,9 @@ exports.Module = new index_1.Runtime.Module({
     Uncapitalize,
     Date,
     Uint8Array,
-    Reference
+    Reference,
+    // ----------------------------------------------------------------
+    // Main
+    // ----------------------------------------------------------------
+    Main
 });