@sinclair/typebox 0.34.14 → 0.34.16

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

@@ -1 +1 @@
-export * from './parse';
+export * from './syntax';

package/build/cjs/syntax/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("./parse"), exports);
+__exportStar(require("./syntax"), exports);

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

@@ -1,71 +1,55 @@
-import { Runtime } from './parsebox/index';
-import * as Types from '../type/index';
+import { Runtime } from '../parser/index';
+import * as t 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, {
-        [x: string]: Types.TSchema;
-        [x: number]: Types.TSchema;
-    }>>;
-    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>;
+    Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
+    Keyword: Runtime.IUnion<t.TAny | t.TNever | t.TString | t.TBoolean | t.TNumber | t.TInteger | t.TBigInt | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;
     IndexArray: Runtime.IUnion<unknown[]>;
     Extends: Runtime.IUnion<unknown[]>;
     Base: Runtime.IUnion<unknown>;
-    Factor: Runtime.ITuple<Types.TSchema>;
+    Factor: Runtime.ITuple<t.TSchema>;
     ExprTermTail: Runtime.IUnion<[] | ["&", unknown, unknown]>;
-    ExprTerm: Runtime.ITuple<Types.TSchema>;
+    ExprTerm: Runtime.ITuple<t.TSchema>;
     ExprTail: Runtime.IUnion<[] | ["|", unknown, unknown]>;
-    Expr: Runtime.ITuple<Types.TSchema>;
+    Expr: Runtime.ITuple<t.TSchema>;
     Type: Runtime.IRef<unknown>;
     PropertyKey: Runtime.IUnion<string>;
     Readonly: Runtime.IUnion<boolean>;
     Optional: Runtime.IUnion<boolean>;
     Property: Runtime.ITuple<{
-        [x: string]: Types.TSchema;
+        [x: string]: t.TSchema;
     }>;
     PropertyDelimiter: Runtime.IUnion<[","] | [",", "\n"] | [";"] | [";", "\n"] | ["\n"]>;
-    Properties: Runtime.IUnion<Types.TProperties>;
-    Object: Runtime.ITuple<Types.TObject<Types.TProperties>>;
+    Properties: Runtime.IUnion<t.TProperties>;
+    Object: Runtime.ITuple<t.TObject<t.TProperties>>;
     Elements: Runtime.IUnion<unknown[]>;
-    Tuple: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
-    Parameter: Runtime.ITuple<Types.TSchema>;
-    Function: Runtime.ITuple<Types.TFunction<Types.TSchema[], Types.TSchema>>;
+    Tuple: Runtime.ITuple<t.TTuple<t.TSchema[]>>;
+    Parameter: Runtime.ITuple<t.TSchema>;
+    Function: Runtime.ITuple<t.TFunction<t.TSchema[], t.TSchema>>;
     Parameters: Runtime.IUnion<unknown[]>;
-    Constructor: Runtime.ITuple<Types.TConstructor<Types.TSchema[], Types.TSchema>>;
-    Mapped: Runtime.ITuple<Types.TLiteral<"Mapped types not supported">>;
-    AsyncIterator: Runtime.ITuple<Types.TAsyncIterator<Types.TSchema>>;
-    Iterator: Runtime.ITuple<Types.TIterator<Types.TSchema>>;
-    Awaited: Runtime.ITuple<Types.TSchema>;
-    Array: Runtime.ITuple<Types.TArray<Types.TSchema>>;
-    Record: Runtime.ITuple<Types.TNever>;
-    Promise: Runtime.ITuple<Types.TPromise<Types.TSchema>>;
-    ConstructorParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
-    FunctionParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
-    InstanceType: Runtime.ITuple<Types.TSchema>;
-    ReturnType: Runtime.ITuple<Types.TSchema>;
-    Partial: Runtime.ITuple<Types.TObject<{}>>;
-    Required: Runtime.ITuple<Types.TObject<{}>>;
-    Pick: Runtime.ITuple<Types.TObject<{}>>;
-    Omit: Runtime.ITuple<Types.TObject<{}>>;
-    Exclude: Runtime.ITuple<Types.TNever>;
-    Extract: Runtime.ITuple<Types.TSchema>;
-    Uppercase: Runtime.ITuple<Types.TSchema>;
-    Lowercase: Runtime.ITuple<Types.TSchema>;
-    Capitalize: Runtime.ITuple<Types.TSchema>;
-    Uncapitalize: Runtime.ITuple<Types.TSchema>;
-    Date: Runtime.IConst<Types.TDate>;
-    Uint8Array: Runtime.IConst<Types.TUint8Array>;
-    Reference: Runtime.IIdent<Types.TSchema>;
-    Main: Runtime.IUnion<unknown>;
+    Constructor: Runtime.ITuple<t.TConstructor<t.TSchema[], t.TSchema>>;
+    Mapped: Runtime.ITuple<t.TLiteral<"Mapped types not supported">>;
+    AsyncIterator: Runtime.ITuple<t.TAsyncIterator<t.TSchema>>;
+    Iterator: Runtime.ITuple<t.TIterator<t.TSchema>>;
+    Awaited: Runtime.ITuple<t.TSchema>;
+    Array: Runtime.ITuple<t.TArray<t.TSchema>>;
+    Record: Runtime.ITuple<t.TNever>;
+    Promise: Runtime.ITuple<t.TPromise<t.TSchema>>;
+    ConstructorParameters: Runtime.ITuple<t.TTuple<t.TSchema[]>>;
+    FunctionParameters: Runtime.ITuple<t.TTuple<t.TSchema[]>>;
+    InstanceType: Runtime.ITuple<t.TSchema>;
+    ReturnType: Runtime.ITuple<t.TSchema>;
+    Partial: Runtime.ITuple<t.TObject<{}>>;
+    Required: Runtime.ITuple<t.TObject<{}>>;
+    Pick: Runtime.ITuple<t.TObject<{}>>;
+    Omit: Runtime.ITuple<t.TObject<{}>>;
+    Exclude: Runtime.ITuple<t.TNever>;
+    Extract: Runtime.ITuple<t.TSchema>;
+    Uppercase: Runtime.ITuple<t.TSchema>;
+    Lowercase: Runtime.ITuple<t.TSchema>;
+    Capitalize: Runtime.ITuple<t.TSchema>;
+    Uncapitalize: Runtime.ITuple<t.TSchema>;
+    Date: Runtime.IConst<t.TDate>;
+    Uint8Array: Runtime.IConst<t.TUint8Array>;
+    Reference: Runtime.IIdent<t.TSchema>;
 }>;

package/build/cjs/syntax/runtime.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Module = void 0;
-const index_1 = require("./parsebox/index");
-const Types = require("../type/index");
+const index_1 = require("../parser/index");
+const t = require("../type/index");
 // ------------------------------------------------------------------
 // Tokens
 // ------------------------------------------------------------------
@@ -37,126 +37,9 @@ function DestructureRight(values) {
 // Deref
 // ------------------------------------------------------------------
 const Deref = (context, key) => {
-    return key in context ? context[key] : Types.Ref(key);
+    return key in context ? context[key] : t.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
@@ -166,27 +49,27 @@ const Reference = index_1.Runtime.Ident((value, context) => Deref(context, value
 // ------------------------------------------------------------------
 // prettier-ignore
 const Literal = index_1.Runtime.Union([
-    index_1.Runtime.Union([index_1.Runtime.Const('true'), index_1.Runtime.Const('false')], value => Types.Literal(value === 'true')),
-    index_1.Runtime.Number(value => Types.Literal(parseFloat(value))),
-    index_1.Runtime.String([SingleQuote, DoubleQuote, Tilde], value => Types.Literal(value))
+    index_1.Runtime.Union([index_1.Runtime.Const('true'), index_1.Runtime.Const('false')], value => t.Literal(value === 'true')),
+    index_1.Runtime.Number(value => t.Literal(parseFloat(value))),
+    index_1.Runtime.String([SingleQuote, DoubleQuote, Tilde], value => t.Literal(value))
 ]);
 // ------------------------------------------------------------------
 // Keyword
 // ------------------------------------------------------------------
 // prettier-ignore
 const Keyword = index_1.Runtime.Union([
-    index_1.Runtime.Const('any', index_1.Runtime.As(Types.Any())),
-    index_1.Runtime.Const('bigint', index_1.Runtime.As(Types.BigInt())),
-    index_1.Runtime.Const('boolean', index_1.Runtime.As(Types.Boolean())),
-    index_1.Runtime.Const('integer', index_1.Runtime.As(Types.Integer())),
-    index_1.Runtime.Const('never', index_1.Runtime.As(Types.Never())),
-    index_1.Runtime.Const('null', index_1.Runtime.As(Types.Null())),
-    index_1.Runtime.Const('number', index_1.Runtime.As(Types.Number())),
-    index_1.Runtime.Const('string', index_1.Runtime.As(Types.String())),
-    index_1.Runtime.Const('symbol', index_1.Runtime.As(Types.Symbol())),
-    index_1.Runtime.Const('undefined', index_1.Runtime.As(Types.Undefined())),
-    index_1.Runtime.Const('unknown', index_1.Runtime.As(Types.Unknown())),
-    index_1.Runtime.Const('void', index_1.Runtime.As(Types.Void())),
+    index_1.Runtime.Const('any', index_1.Runtime.As(t.Any())),
+    index_1.Runtime.Const('bigint', index_1.Runtime.As(t.BigInt())),
+    index_1.Runtime.Const('boolean', index_1.Runtime.As(t.Boolean())),
+    index_1.Runtime.Const('integer', index_1.Runtime.As(t.Integer())),
+    index_1.Runtime.Const('never', index_1.Runtime.As(t.Never())),
+    index_1.Runtime.Const('null', index_1.Runtime.As(t.Null())),
+    index_1.Runtime.Const('number', index_1.Runtime.As(t.Number())),
+    index_1.Runtime.Const('string', index_1.Runtime.As(t.String())),
+    index_1.Runtime.Const('symbol', index_1.Runtime.As(t.Symbol())),
+    index_1.Runtime.Const('undefined', index_1.Runtime.As(t.Undefined())),
+    index_1.Runtime.Const('unknown', index_1.Runtime.As(t.Unknown())),
+    index_1.Runtime.Const('void', index_1.Runtime.As(t.Void())),
 ]);
 // ------------------------------------------------------------------
 // KeyOf
@@ -277,22 +160,22 @@ const Base = index_1.Runtime.Union([
 // prettier-ignore
 const FactorExtends = (Type, Extends) => {
     return Extends.length === 3
-        ? Types.Extends(Type, Extends[0], Extends[1], Extends[2])
+        ? t.Extends(Type, Extends[0], Extends[1], Extends[2])
         : Type;
 };
 // prettier-ignore
 const FactorIndexArray = (Type, IndexArray) => {
     const [Left, Right] = DestructureRight(IndexArray);
-    return (!Types.ValueGuard.IsUndefined(Right) ? (
+    return (!t.ValueGuard.IsUndefined(Right) ? (
     // note: Indexed types require reimplementation to replace `[number]` indexers
-    Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
-        Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
-            Types.Never()) : Type);
+    Right.length === 1 ? t.Index(FactorIndexArray(Type, Left), Right[0]) :
+        Right.length === 0 ? t.Array(FactorIndexArray(Type, Left)) :
+            t.Never()) : Type);
 };
 // prettier-ignore
 const FactorMapping = (KeyOf, Type, IndexArray, Extends) => {
     return KeyOf
-        ? FactorExtends(Types.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
+        ? FactorExtends(t.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
         : FactorExtends(FactorIndexArray(Type, IndexArray), Extends);
 };
 // prettier-ignore
@@ -311,14 +194,14 @@ function ExprBinaryMapping(Left, Rest) {
         const [Operator, Right, Next] = Rest;
         const Schema = ExprBinaryMapping(Right, Next);
         if (Operator === '&') {
-            return Types.TypeGuard.IsIntersect(Schema)
-                ? Types.Intersect([Left, ...Schema.allOf])
-                : Types.Intersect([Left, Schema]);
+            return t.TypeGuard.IsIntersect(Schema)
+                ? t.Intersect([Left, ...Schema.allOf])
+                : t.Intersect([Left, Schema]);
         }
         if (Operator === '|') {
-            return Types.TypeGuard.IsUnion(Schema)
-                ? Types.Union([Left, ...Schema.anyOf])
-                : Types.Union([Left, Schema]);
+            return t.TypeGuard.IsUnion(Schema)
+                ? t.Union([Left, ...Schema.anyOf])
+                : t.Union([Left, Schema]);
         }
         throw 1;
     })() : Left);
@@ -353,9 +236,9 @@ const Readonly = index_1.Runtime.Union([index_1.Runtime.Tuple([index_1.Runtime.C
 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 PropertyMapping = (IsReadonly, Key, IsOptional, _, Type) => ({
-    [Key]: (IsReadonly && IsOptional ? Types.ReadonlyOptional(Type) :
-        IsReadonly && !IsOptional ? Types.Readonly(Type) :
-            !IsReadonly && IsOptional ? Types.Optional(Type) :
+    [Key]: (IsReadonly && IsOptional ? t.ReadonlyOptional(Type) :
+        IsReadonly && !IsOptional ? t.Readonly(Type) :
+            !IsReadonly && IsOptional ? t.Optional(Type) :
                 Type)
 });
 // prettier-ignore
@@ -388,7 +271,7 @@ const Properties = index_1.Runtime.Union([
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
-const ObjectMapping = (_0, Properties, _2) => Types.Object(Properties);
+const ObjectMapping = (_0, Properties, _2) => t.Object(Properties);
 // prettier-ignore
 const _Object = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LBrace),
@@ -413,7 +296,7 @@ const Tuple = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LBracket),
     index_1.Runtime.Ref('Elements'),
     index_1.Runtime.Const(RBracket)
-], value => Types.Tuple(value[1]));
+], value => t.Tuple(value[1]));
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
@@ -442,7 +325,7 @@ const Constructor = index_1.Runtime.Tuple([
     index_1.Runtime.Const(RParen),
     index_1.Runtime.Const('=>'),
     index_1.Runtime.Ref('Type')
-], value => Types.Constructor(value[2], value[5]));
+], value => t.Constructor(value[2], value[5]));
 // ------------------------------------------------------------------
 // Function
 // ------------------------------------------------------------------
@@ -453,13 +336,13 @@ const Function = index_1.Runtime.Tuple([
     index_1.Runtime.Const(RParen),
     index_1.Runtime.Const('=>'),
     index_1.Runtime.Ref('Type')
-], value => Types.Function(value[1], value[4]));
+], value => t.Function(value[1], value[4]));
 // ------------------------------------------------------------------
 // Mapped (requires deferred types)
 // ------------------------------------------------------------------
 // prettier-ignore
 const MappedMapping = (values) => {
-    return Types.Literal('Mapped types not supported');
+    return t.Literal('Mapped types not supported');
 };
 // prettier-ignore
 const Mapped = index_1.Runtime.Tuple([
@@ -482,7 +365,7 @@ const AsyncIterator = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.AsyncIterator(value[2]));
+], value => t.AsyncIterator(value[2]));
 // ------------------------------------------------------------------
 // Iterator
 // ------------------------------------------------------------------
@@ -492,7 +375,7 @@ const Iterator = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Iterator(value[2]));
+], value => t.Iterator(value[2]));
 // ------------------------------------------------------------------
 // ConstructorParameters
 // ------------------------------------------------------------------
@@ -502,7 +385,7 @@ const ConstructorParameters = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.ConstructorParameters(value[2]));
+], value => t.ConstructorParameters(value[2]));
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
@@ -512,7 +395,7 @@ const FunctionParameters = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Parameters(value[2]));
+], value => t.Parameters(value[2]));
 // ------------------------------------------------------------------
 // InstanceType
 // ------------------------------------------------------------------
@@ -522,7 +405,7 @@ const InstanceType = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.InstanceType(value[2]));
+], value => t.InstanceType(value[2]));
 // ------------------------------------------------------------------
 // ReturnType
 // ------------------------------------------------------------------
@@ -532,7 +415,7 @@ const ReturnType = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.ReturnType(value[2]));
+], value => t.ReturnType(value[2]));
 // ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
@@ -542,7 +425,7 @@ const Awaited = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Awaited(value[2]));
+], value => t.Awaited(value[2]));
 // ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
@@ -552,7 +435,7 @@ const Array = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Array(value[2]));
+], value => t.Array(value[2]));
 // ------------------------------------------------------------------
 // Record
 // ------------------------------------------------------------------
@@ -564,7 +447,7 @@ const Record = index_1.Runtime.Tuple([
     index_1.Runtime.Const(Comma),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Record(value[2], value[4]));
+], value => t.Record(value[2], value[4]));
 // ------------------------------------------------------------------
 // Promise
 // ------------------------------------------------------------------
@@ -574,7 +457,7 @@ const Promise = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Promise(value[2]));
+], value => t.Promise(value[2]));
 // ------------------------------------------------------------------
 // Partial
 // ------------------------------------------------------------------
@@ -584,7 +467,7 @@ const Partial = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Partial(value[2]));
+], value => t.Partial(value[2]));
 // ------------------------------------------------------------------
 // Required
 // ------------------------------------------------------------------
@@ -594,7 +477,7 @@ const Required = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Required(value[2]));
+], value => t.Required(value[2]));
 // ------------------------------------------------------------------
 // Pick
 // ------------------------------------------------------------------
@@ -606,7 +489,7 @@ const Pick = index_1.Runtime.Tuple([
     index_1.Runtime.Const(Comma),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Pick(value[2], value[4]));
+], value => t.Pick(value[2], value[4]));
 // ------------------------------------------------------------------
 // Omit
 // ------------------------------------------------------------------
@@ -618,7 +501,7 @@ const Omit = index_1.Runtime.Tuple([
     index_1.Runtime.Const(Comma),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Omit(value[2], value[4]));
+], value => t.Omit(value[2], value[4]));
 // ------------------------------------------------------------------
 // Exclude
 // ------------------------------------------------------------------
@@ -630,7 +513,7 @@ const Exclude = index_1.Runtime.Tuple([
     index_1.Runtime.Const(Comma),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Exclude(value[2], value[4]));
+], value => t.Exclude(value[2], value[4]));
 // ------------------------------------------------------------------
 // Extract
 // ------------------------------------------------------------------
@@ -642,7 +525,7 @@ const Extract = index_1.Runtime.Tuple([
     index_1.Runtime.Const(Comma),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Extract(value[2], value[4]));
+], value => t.Extract(value[2], value[4]));
 // ------------------------------------------------------------------
 // Uppercase
 // ------------------------------------------------------------------
@@ -652,7 +535,7 @@ const Uppercase = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Uppercase(value[2]));
+], value => t.Uppercase(value[2]));
 // ------------------------------------------------------------------
 // Lowercase
 // ------------------------------------------------------------------
@@ -662,7 +545,7 @@ const Lowercase = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Lowercase(value[2]));
+], value => t.Lowercase(value[2]));
 // ------------------------------------------------------------------
 // Capitalize
 // ------------------------------------------------------------------
@@ -672,7 +555,7 @@ const Capitalize = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Capitalize(value[2]));
+], value => t.Capitalize(value[2]));
 // ------------------------------------------------------------------
 // Uncapitalize
 // ------------------------------------------------------------------
@@ -682,41 +565,20 @@ const Uncapitalize = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('Type'),
     index_1.Runtime.Const(RAngle),
-], value => Types.Uncapitalize(value[2]));
+], value => t.Uncapitalize(value[2]));
 // ------------------------------------------------------------------
 // Date
 // ------------------------------------------------------------------
-const Date = index_1.Runtime.Const('Date', index_1.Runtime.As(Types.Date()));
+const Date = index_1.Runtime.Const('Date', index_1.Runtime.As(t.Date()));
 // ------------------------------------------------------------------
 // Uint8Array
 // ------------------------------------------------------------------
-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
-]);
+const Uint8Array = index_1.Runtime.Const('Uint8Array', index_1.Runtime.As(t.Uint8Array()));
 // ------------------------------------------------------------------
 // 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
     // ----------------------------------------------------------------
@@ -769,8 +631,4 @@ exports.Module = new index_1.Runtime.Module({
     Date,
     Uint8Array,
     Reference,
-    // ----------------------------------------------------------------
-    // Main
-    // ----------------------------------------------------------------
-    Main
 });