@sinclair/typebox 0.34.15 → 0.34.17

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

@@ -1,5 +1,5 @@
-import { Static } from './parsebox/index';
-import * as Types from '../type/index';
+import { Static } from '../parser/index';
+import * as t from '../type/index';
 type Newline = '\n';
 type LBracket = '[';
 type RBracket = ']';
@@ -16,7 +16,6 @@ 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 [_] ? [] : [
     ]);
@@ -42,98 +41,28 @@ 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 Dereference<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
+interface GenericReferenceMapping extends Static.IMapping {
+    output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Parameters extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, [...Parameters]> : never : never;
 }
-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'>,
+type GenericReference = Static.Tuple<[
     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>;
+    Static.Const<LAngle>,
+    Elements,
+    Static.Const<RAngle>
+], GenericReferenceMapping>;
 interface ReferenceMapping extends Static.IMapping {
-    output: this['context'] extends Types.TProperties ? this['input'] extends string ? Deref<this['context'], this['input']> : never : never;
+    output: this['context'] extends t.TProperties ? this['input'] extends string ? Dereference<this['context'], this['input']> : never : never;
 }
 type Reference = Static.Ident<ReferenceMapping>;
 interface LiteralBooleanMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends boolean}` ? Types.TLiteral<S> : never;
+    output: this['input'] extends `${infer S extends boolean}` ? t.TLiteral<S> : never;
 }
 interface LiteralNumberMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends number}` ? Types.TLiteral<S> : never;
+    output: this['input'] extends `${infer S extends number}` ? t.TLiteral<S> : never;
 }
 interface LiteralStringMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends string}` ? Types.TLiteral<S> : never;
+    output: this['input'] extends `${infer S extends string}` ? t.TLiteral<S> : never;
 }
 type Literal = Static.Union<[
     Static.Union<[Static.Const<'true'>, Static.Const<'false'>], LiteralBooleanMapping>,
@@ -141,18 +70,18 @@ type Literal = Static.Union<[
     Static.String<[DoubleQuote, SingleQuote, Tilde], LiteralStringMapping>
 ]>;
 type Keyword = Static.Union<[
-    Static.Const<'any', Static.As<Types.TAny>>,
-    Static.Const<'bigint', Static.As<Types.TBigInt>>,
-    Static.Const<'boolean', Static.As<Types.TBoolean>>,
-    Static.Const<'integer', Static.As<Types.TInteger>>,
-    Static.Const<'never', Static.As<Types.TNever>>,
-    Static.Const<'null', Static.As<Types.TNull>>,
-    Static.Const<'number', Static.As<Types.TNumber>>,
-    Static.Const<'string', Static.As<Types.TString>>,
-    Static.Const<'symbol', Static.As<Types.TSymbol>>,
-    Static.Const<'undefined', Static.As<Types.TUndefined>>,
-    Static.Const<'unknown', Static.As<Types.TUnknown>>,
-    Static.Const<'void', Static.As<Types.TVoid>>
+    Static.Const<'any', Static.As<t.TAny>>,
+    Static.Const<'bigint', Static.As<t.TBigInt>>,
+    Static.Const<'boolean', Static.As<t.TBoolean>>,
+    Static.Const<'integer', Static.As<t.TInteger>>,
+    Static.Const<'never', Static.As<t.TNever>>,
+    Static.Const<'null', Static.As<t.TNull>>,
+    Static.Const<'number', Static.As<t.TNumber>>,
+    Static.Const<'string', Static.As<t.TString>>,
+    Static.Const<'symbol', Static.As<t.TSymbol>>,
+    Static.Const<'undefined', Static.As<t.TUndefined>>,
+    Static.Const<'unknown', Static.As<t.TUnknown>>,
+    Static.Const<'void', Static.As<t.TVoid>>
 ]>;
 interface KeyOfMapping extends Static.IMapping {
     output: this['input'] extends [] ? false : true;
@@ -162,7 +91,7 @@ type KeyOf = Static.Union<[
     Static.Tuple<[]>
 ], KeyOfMapping>;
 interface IndexArrayMapping extends Static.IMapping {
-    output: (this['input'] extends [LBracket, infer Type extends Types.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] : this['input'] extends [LBracket, RBracket, infer Rest extends unknown[]] ? [[], ...Rest] : [
+    output: (this['input'] extends [LBracket, infer Type extends t.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] : this['input'] extends [LBracket, RBracket, infer Rest extends unknown[]] ? [[], ...Rest] : [
     ]);
 }
 type IndexArray = Static.Union<[
@@ -171,14 +100,14 @@ type IndexArray = Static.Union<[
     Static.Tuple<[]>
 ], IndexArrayMapping>;
 interface ExtendsMapping extends Static.IMapping {
-    output: this['input'] extends ['extends', infer Type extends Types.TSchema, Question, infer True extends Types.TSchema, Colon, infer False extends Types.TSchema] ? [Type, True, False] : [];
+    output: this['input'] extends ['extends', infer Type extends t.TSchema, Question, infer True extends t.TSchema, Colon, infer False extends t.TSchema] ? [Type, True, False] : [];
 }
 type Extends = Static.Union<[
     Static.Tuple<[Static.Const<'extends'>, Type, Static.Const<Question>, Type, Static.Const<Colon>, Type]>,
     Static.Tuple<[]>
 ], ExtendsMapping>;
 interface BaseMapping extends Static.IMapping {
-    output: (this['input'] extends [LParen, infer Type extends Types.TSchema, RParen] ? Type : this['input'] extends [infer Type extends Types.TSchema] ? Type : never);
+    output: (this['input'] extends [LParen, infer Type extends t.TSchema, RParen] ? Type : this['input'] extends [infer Type extends t.TSchema] ? Type : never);
 }
 type Base = Static.Union<[
     Static.Tuple<[
@@ -199,6 +128,7 @@ type Base = Static.Union<[
             Iterator,
             ConstructorParameters,
             FunctionParameters,
+            Argument,
             InstanceType,
             ReturnType,
             Awaited,
@@ -217,14 +147,15 @@ type Base = Static.Union<[
             Uncapitalize,
             Date,
             Uint8Array,
+            GenericReference,
             Reference
         ]>
     ]>
 ], BaseMapping>;
-type FactorExtends<Type extends Types.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends Types.TSchema, infer True extends Types.TSchema, infer False extends Types.TSchema] ? Types.TExtends<Type, Right, True, False> : Type);
-type FactorIndexArray<Type extends Types.TSchema, IndexArray extends unknown[]> = (IndexArray extends [...infer Left extends unknown[], infer Right extends Types.TSchema[]] ? (Right extends [infer Indexer extends Types.TSchema] ? Types.TIndex<FactorIndexArray<Type, Left>, Types.TIndexPropertyKeys<Indexer>> : Right extends [] ? Types.TArray<FactorIndexArray<Type, Left>> : Types.TNever) : Type);
+type FactorExtends<Type extends t.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends t.TSchema, infer True extends t.TSchema, infer False extends t.TSchema] ? t.TExtends<Type, Right, True, False> : Type);
+type FactorIndexArray<Type extends t.TSchema, IndexArray extends unknown[]> = (IndexArray extends [...infer Left extends unknown[], infer Right extends t.TSchema[]] ? (Right extends [infer Indexer extends t.TSchema] ? t.TIndex<FactorIndexArray<Type, Left>, t.TIndexPropertyKeys<Indexer>> : Right extends [] ? t.TArray<FactorIndexArray<Type, Left>> : t.TNever) : Type);
 interface FactorMapping extends Static.IMapping {
-    output: this['input'] extends [infer KeyOf extends boolean, infer Type extends Types.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]] ? KeyOf extends true ? FactorExtends<Types.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends> : FactorExtends<FactorIndexArray<Type, IndexArray>, Extends> : never;
+    output: this['input'] extends [infer KeyOf extends boolean, infer Type extends t.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]] ? KeyOf extends true ? FactorExtends<t.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends> : FactorExtends<FactorIndexArray<Type, IndexArray>, Extends> : never;
 }
 type Factor = Static.Tuple<[
     KeyOf,
@@ -232,9 +163,9 @@ type Factor = Static.Tuple<[
     IndexArray,
     Extends
 ], FactorMapping>;
-type ExprBinaryReduce<Left extends Types.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends Types.TSchema, infer Next extends unknown[]] ? (ExprBinaryReduce<Right, Next> extends infer Schema extends Types.TSchema ? (Operator extends '&' ? (Schema extends Types.TIntersect<infer Types extends Types.TSchema[]> ? Types.TIntersect<[Left, ...Types]> : Types.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends Types.TUnion<infer Types extends Types.TSchema[]> ? Types.TUnion<[Left, ...Types]> : Types.TUnion<[Left, Schema]>) : never) : never) : Left);
+type ExprBinaryReduce<Left extends t.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends t.TSchema, infer Next extends unknown[]] ? (ExprBinaryReduce<Right, Next> extends infer Schema extends t.TSchema ? (Operator extends '&' ? (Schema extends t.TIntersect<infer Types extends t.TSchema[]> ? t.TIntersect<[Left, ...Types]> : t.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends t.TUnion<infer Types extends t.TSchema[]> ? t.TUnion<[Left, ...Types]> : t.TUnion<[Left, Schema]>) : never) : never) : Left);
 interface ExprBinaryMapping extends Static.IMapping {
-    output: (this['input'] extends [infer Left extends Types.TSchema, infer Rest extends unknown[]] ? ExprBinaryReduce<Left, Rest> : []);
+    output: (this['input'] extends [infer Left extends t.TSchema, infer Rest extends unknown[]] ? ExprBinaryReduce<Left, Rest> : []);
 }
 type ExprTermTail = Static.Union<[
     Static.Tuple<[Static.Const<'&'>, Factor, ExprTermTail]>,
@@ -252,7 +183,7 @@ type Expr = Static.Tuple<[
     ExprTerm,
     ExprTail
 ], ExprBinaryMapping>;
-type Type = Expr;
+export type Type = Expr;
 interface PropertyKeyStringMapping extends Static.IMapping {
     output: this['input'];
 }
@@ -267,17 +198,17 @@ interface OptionalMapping extends Static.IMapping {
 }
 type Optional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], OptionalMapping>;
 interface PropertyMapping extends Static.IMapping {
-    output: this['input'] extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional 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 t.TSchema] ? {
         [_ in Key]: ([
             IsReadonly,
             IsOptional
-        ] extends [true, true] ? Types.TReadonlyOptional<Type> : [
+        ] extends [true, true] ? t.TReadonlyOptional<Type> : [
             IsReadonly,
             IsOptional
-        ] extends [true, false] ? Types.TReadonly<Type> : [
+        ] extends [true, false] ? t.TReadonly<Type> : [
             IsReadonly,
             IsOptional
-        ] extends [false, true] ? Types.TOptional<Type> : Type);
+        ] extends [false, true] ? t.TOptional<Type> : Type);
     } : never;
 }
 type Property = Static.Tuple<[Readonly, PropertyKey, Optional, Static.Const<Colon>, Type], PropertyMapping>;
@@ -288,13 +219,13 @@ 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, Types.Evaluate<Result & Left>> : Result);
+type PropertiesReduce<PropertiesArray extends t.TProperties[], Result extends t.TProperties = {}> = (PropertiesArray extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]] ? PropertiesReduce<Right, t.Evaluate<Result & Left>> : Result);
 interface PropertiesMapping extends Static.IMapping {
-    output: this['input'] extends Types.TProperties[] ? PropertiesReduce<this['input']> : never;
+    output: this['input'] extends t.TProperties[] ? PropertiesReduce<this['input']> : never;
 }
 type Properties = Static.Union<[Delimit<Property, PropertyDelimiter>], PropertiesMapping>;
 interface ObjectMapping extends Static.IMapping {
-    output: this['input'] extends [unknown, infer Properties extends Types.TProperties, unknown] ? Types.TObject<Properties> : never;
+    output: this['input'] extends [unknown, infer Properties extends t.TProperties, unknown] ? t.TObject<Properties> : never;
 }
 type Object = Static.Tuple<[
     Static.Const<LBrace>,
@@ -303,7 +234,7 @@ type Object = Static.Tuple<[
 ], ObjectMapping>;
 type Elements = Delimit<Type, Static.Const<Comma>>;
 interface TupleMapping extends Static.IMapping {
-    output: this['input'] extends [unknown, infer Elements extends Types.TSchema[], unknown] ? Types.TTuple<Elements> : never;
+    output: this['input'] extends [unknown, infer Elements extends t.TSchema[], unknown] ? t.TTuple<Elements> : never;
 }
 type Tuple = Static.Tuple<[
     Static.Const<LBracket>,
@@ -311,7 +242,7 @@ type Tuple = Static.Tuple<[
     Static.Const<RBracket>
 ], TupleMapping>;
 interface ParameterMapping extends Static.IMapping {
-    output: this['input'] extends [string, Colon, infer Type extends Types.TSchema] ? Type : never;
+    output: this['input'] extends [string, Colon, infer Type extends t.TSchema] ? Type : never;
 }
 type Parameter = Static.Tuple<[
     Static.Ident,
@@ -320,7 +251,7 @@ type Parameter = Static.Tuple<[
 ], ParameterMapping>;
 type Parameters = Delimit<Parameter, Static.Const<Comma>>;
 interface FunctionMapping extends Static.IMapping {
-    output: this['input'] extends [LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer ReturnType extends Types.TSchema] ? Types.TFunction<Parameters, ReturnType> : never;
+    output: this['input'] extends [LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema] ? t.TFunction<Parameters, ReturnType> : never;
 }
 type Function = Static.Tuple<[
     Static.Const<LParen>,
@@ -330,7 +261,7 @@ type Function = Static.Tuple<[
     Type
 ], FunctionMapping>;
 interface ConstructorMapping extends Static.IMapping {
-    output: this['input'] extends ['new', LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer InstanceType extends Types.TSchema] ? Types.TConstructor<Parameters, InstanceType> : never;
+    output: this['input'] extends ['new', LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema] ? t.TConstructor<Parameters, InstanceType> : never;
 }
 type Constructor = Static.Tuple<[
     Static.Const<'new'>,
@@ -341,7 +272,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 t.TSchema, RBracket, Colon, infer Type extends t.TSchema, RBrace] ? t.TLiteral<'Mapped types not supported'> : this['input'];
 }
 type Mapped = Static.Tuple<[
     Static.Const<LBrace>,
@@ -355,7 +286,7 @@ type Mapped = Static.Tuple<[
     Static.Const<RBrace>
 ], MappedMapping>;
 interface ArrayMapping extends Static.IMapping {
-    output: this['input'] extends ['Array', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TArray<Type> : never;
+    output: this['input'] extends ['Array', LAngle, infer Type extends t.TSchema, RAngle] ? t.TArray<Type> : never;
 }
 type Array = Static.Tuple<[
     Static.Const<'Array'>,
@@ -364,7 +295,7 @@ type Array = Static.Tuple<[
     Static.Const<RAngle>
 ], ArrayMapping>;
 interface AsyncIteratorMapping extends Static.IMapping {
-    output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TAsyncIterator<Type> : never;
+    output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends t.TSchema, RAngle] ? t.TAsyncIterator<Type> : never;
 }
 type AsyncIterator = Static.Tuple<[
     Static.Const<'AsyncIterator'>,
@@ -373,7 +304,7 @@ type AsyncIterator = Static.Tuple<[
     Static.Const<RAngle>
 ], AsyncIteratorMapping>;
 interface IteratorMapping extends Static.IMapping {
-    output: this['input'] extends ['Iterator', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TIterator<Type> : never;
+    output: this['input'] extends ['Iterator', LAngle, infer Type extends t.TSchema, RAngle] ? t.TIterator<Type> : never;
 }
 type Iterator = Static.Tuple<[
     Static.Const<'Iterator'>,
@@ -382,7 +313,7 @@ type Iterator = Static.Tuple<[
     Static.Const<RAngle>
 ], IteratorMapping>;
 interface ConstructorParametersMapping extends Static.IMapping {
-    output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends Types.TConstructor, RAngle] ? Types.TConstructorParameters<Type> : never;
+    output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends t.TSchema, RAngle] ? t.TConstructorParameters<Type> : never;
 }
 type ConstructorParameters = Static.Tuple<[
     Static.Const<'ConstructorParameters'>,
@@ -391,7 +322,7 @@ type ConstructorParameters = Static.Tuple<[
     Static.Const<RAngle>
 ], ConstructorParametersMapping>;
 interface FunctionParametersMapping extends Static.IMapping {
-    output: this['input'] extends ['Parameters', LAngle, infer Type extends Types.TFunction, RAngle] ? Types.TParameters<Type> : never;
+    output: this['input'] extends ['Parameters', LAngle, infer Type extends t.TSchema, RAngle] ? t.TParameters<Type> : never;
 }
 type FunctionParameters = Static.Tuple<[
     Static.Const<'Parameters'>,
@@ -400,7 +331,7 @@ type FunctionParameters = Static.Tuple<[
     Static.Const<RAngle>
 ], FunctionParametersMapping>;
 interface InstanceTypeMapping extends Static.IMapping {
-    output: this['input'] extends ['InstanceType', LAngle, infer Type extends Types.TConstructor, RAngle] ? Types.TInstanceType<Type> : never;
+    output: this['input'] extends ['InstanceType', LAngle, infer Type extends t.TSchema, RAngle] ? t.TInstanceType<Type> : never;
 }
 type InstanceType = Static.Tuple<[
     Static.Const<'InstanceType'>,
@@ -409,7 +340,7 @@ type InstanceType = Static.Tuple<[
     Static.Const<RAngle>
 ], InstanceTypeMapping>;
 interface ReturnTypeMapping extends Static.IMapping {
-    output: this['input'] extends ['ReturnType', LAngle, infer Type extends Types.TFunction, RAngle] ? Types.TReturnType<Type> : never;
+    output: this['input'] extends ['ReturnType', LAngle, infer Type extends t.TSchema, RAngle] ? t.TReturnType<Type> : never;
 }
 type ReturnType = Static.Tuple<[
     Static.Const<'ReturnType'>,
@@ -417,8 +348,17 @@ type ReturnType = Static.Tuple<[
     Type,
     Static.Const<RAngle>
 ], ReturnTypeMapping>;
+interface ArgumentMapping extends Static.IMapping {
+    output: this['input'] extends ['Argument', LAngle, infer Type extends t.TSchema, RAngle] ? Type extends t.TLiteral<infer Index extends number> ? t.TArgument<Index> : t.TNever : never;
+}
+type Argument = Static.Tuple<[
+    Static.Const<'Argument'>,
+    Static.Const<LAngle>,
+    Type,
+    Static.Const<RAngle>
+], ArgumentMapping>;
 interface AwaitedMapping extends Static.IMapping {
-    output: this['input'] extends ['Awaited', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TAwaited<Type> : never;
+    output: this['input'] extends ['Awaited', LAngle, infer Type extends t.TSchema, RAngle] ? t.TAwaited<Type> : never;
 }
 type Awaited = Static.Tuple<[
     Static.Const<'Awaited'>,
@@ -427,7 +367,7 @@ type Awaited = Static.Tuple<[
     Static.Const<RAngle>
 ], AwaitedMapping>;
 interface PromiseMapping extends Static.IMapping {
-    output: this['input'] extends ['Promise', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TPromise<Type> : never;
+    output: this['input'] extends ['Promise', LAngle, infer Type extends t.TSchema, RAngle] ? t.TPromise<Type> : never;
 }
 type Promise = Static.Tuple<[
     Static.Const<'Promise'>,
@@ -436,7 +376,7 @@ type Promise = Static.Tuple<[
     Static.Const<RAngle>
 ], PromiseMapping>;
 interface RecordMapping extends Static.IMapping {
-    output: this['input'] extends ['Record', LAngle, infer Key extends Types.TSchema, Comma, infer Type extends Types.TSchema, RAngle] ? Types.TRecord<Key, Type> : never;
+    output: this['input'] extends ['Record', LAngle, infer Key extends t.TSchema, Comma, infer Type extends t.TSchema, RAngle] ? t.TRecord<Key, Type> : never;
 }
 type Record = Static.Tuple<[
     Static.Const<'Record'>,
@@ -447,7 +387,7 @@ type Record = Static.Tuple<[
     Static.Const<RAngle>
 ], RecordMapping>;
 interface PartialMapping extends Static.IMapping {
-    output: this['input'] extends ['Partial', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TPartial<Type> : never;
+    output: this['input'] extends ['Partial', LAngle, infer Type extends t.TSchema, RAngle] ? t.TPartial<Type> : never;
 }
 type Partial = Static.Tuple<[
     Static.Const<'Partial'>,
@@ -456,7 +396,7 @@ type Partial = Static.Tuple<[
     Static.Const<RAngle>
 ], PartialMapping>;
 interface RequiredMapping extends Static.IMapping {
-    output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TRequired<Type> : never;
+    output: this['input'] extends ['Required', LAngle, infer Type extends t.TSchema, RAngle] ? t.TRequired<Type> : never;
 }
 type Required = Static.Tuple<[
     Static.Const<'Required'>,
@@ -465,7 +405,7 @@ type Required = Static.Tuple<[
     Static.Const<RAngle>
 ], RequiredMapping>;
 interface PickMapping extends Static.IMapping {
-    output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TPick<Type, Key> : never;
+    output: this['input'] extends ['Pick', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle] ? t.TPick<Type, Key> : never;
 }
 type Pick = Static.Tuple<[
     Static.Const<'Pick'>,
@@ -476,7 +416,7 @@ type Pick = Static.Tuple<[
     Static.Const<RAngle>
 ], PickMapping>;
 interface OmitMapping extends Static.IMapping {
-    output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TOmit<Type, Key> : never;
+    output: this['input'] extends ['Omit', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle] ? t.TOmit<Type, Key> : never;
 }
 type Omit = Static.Tuple<[
     Static.Const<'Omit'>,
@@ -487,7 +427,7 @@ type Omit = Static.Tuple<[
     Static.Const<RAngle>
 ], OmitMapping>;
 interface ExcludeMapping extends Static.IMapping {
-    output: this['input'] extends ['Exclude', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TExclude<Type, PropertyKey> : never;
+    output: this['input'] extends ['Exclude', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle] ? t.TExclude<Type, PropertyKey> : never;
 }
 type Exclude = Static.Tuple<[
     Static.Const<'Exclude'>,
@@ -498,7 +438,7 @@ type Exclude = Static.Tuple<[
     Static.Const<RAngle>
 ], ExcludeMapping>;
 interface ExtractMapping extends Static.IMapping {
-    output: this['input'] extends ['Extract', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TExtract<Type, PropertyKey> : never;
+    output: this['input'] extends ['Extract', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle] ? t.TExtract<Type, PropertyKey> : never;
 }
 type Extract = Static.Tuple<[
     Static.Const<'Extract'>,
@@ -509,7 +449,7 @@ type Extract = Static.Tuple<[
     Static.Const<RAngle>
 ], ExtractMapping>;
 interface UppercaseMapping extends Static.IMapping {
-    output: this['input'] extends ['Uppercase', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TUppercase<Type> : never;
+    output: this['input'] extends ['Uppercase', LAngle, infer Type extends t.TSchema, RAngle] ? t.TUppercase<Type> : never;
 }
 type Uppercase = Static.Tuple<[
     Static.Const<'Uppercase'>,
@@ -518,7 +458,7 @@ type Uppercase = Static.Tuple<[
     Static.Const<RAngle>
 ], UppercaseMapping>;
 interface LowercaseMapping extends Static.IMapping {
-    output: this['input'] extends ['Lowercase', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TLowercase<Type> : never;
+    output: this['input'] extends ['Lowercase', LAngle, infer Type extends t.TSchema, RAngle] ? t.TLowercase<Type> : never;
 }
 type Lowercase = Static.Tuple<[
     Static.Const<'Lowercase'>,
@@ -527,7 +467,7 @@ type Lowercase = Static.Tuple<[
     Static.Const<RAngle>
 ], LowercaseMapping>;
 interface CapitalizeMapping extends Static.IMapping {
-    output: this['input'] extends ['Capitalize', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TCapitalize<Type> : never;
+    output: this['input'] extends ['Capitalize', LAngle, infer Type extends t.TSchema, RAngle] ? t.TCapitalize<Type> : never;
 }
 type Capitalize = Static.Tuple<[
     Static.Const<'Capitalize'>,
@@ -536,7 +476,7 @@ type Capitalize = Static.Tuple<[
     Static.Const<RAngle>
 ], CapitalizeMapping>;
 interface UncapitalizeMapping extends Static.IMapping {
-    output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TUncapitalize<Type> : never;
+    output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends t.TSchema, RAngle] ? t.TUncapitalize<Type> : never;
 }
 type Uncapitalize = Static.Tuple<[
     Static.Const<'Uncapitalize'>,
@@ -544,12 +484,6 @@ type Uncapitalize = Static.Tuple<[
     Type,
     Static.Const<RAngle>
 ], 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
-]>;
+type Date = Static.Const<'Date', Static.As<t.TDate>>;
+type Uint8Array = Static.Const<'Uint8Array', Static.As<t.TUint8Array>>;
 export {};

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

@@ -0,0 +1,33 @@
+import * as Types from '../type/index';
+import { Static } from '../parser/index';
+import { Type } from './static';
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+export declare function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+export declare function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/** Infers a TSchema type from TypeScript syntax. */
+export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] ? Type : Types.TNever);
+/** Parses a TSchema type from TypeScript syntax */
+export declare function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+/** Parses a TSchema type from TypeScript syntax */
+export declare function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;

package/build/cjs/syntax/syntax.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInfer = NoInfer;
+exports.Syntax = Syntax;
+exports.Parse = Parse;
+exports.ParseOnly = ParseOnly;
+const Types = require("../type/index");
+const runtime_1 = require("./runtime");
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+// prettier-ignore
+function NoInfer(...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 Types.KindGuard.IsSchema(type)
+        ? Types.CloneType(type, options)
+        : Types.Never(options);
+}
+/** Parses a TSchema type from TypeScript syntax */
+function Syntax(...args) {
+    return NoInfer.apply(null, args);
+}
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+function Parse(...args) {
+    return NoInfer.apply(null, args);
+}
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+function ParseOnly(...args) {
+    return NoInfer.apply(null, args);
+}

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TArgument<Index extends number = number> extends TSchema {
+    [Kind]: 'Argument';
+    static: unknown;
+    index: Index;
+}
+/** `[JavaScript]` Creates an Argument Type. */
+export declare function Argument<Index extends number>(index: Index): TArgument<Index>;

package/build/cjs/type/argument/argument.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Argument = Argument;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates an Argument Type. */
+function Argument(index) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Argument', index });
+}

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

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

package/build/cjs/type/argument/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./argument"), exports);