@elaraai/east 0.0.1-beta.8 → 1.0.0

package/dist/src/ir.d.ts

@@ -5,21 +5,26 @@
 import type { BuiltinName } from "./builtins.js";
 import type { variant } from "./containers/variant.js";
 import type { EastTypeValue, LiteralValue } from "./type_of_type.js";
+import type { Location } from "./location.js";
 import { ArrayType, BooleanType, IntegerType, RecursiveType, StringType, StructType, VariantType } from "./types.js";
-export type LocationValue = {
-    filename: string;
-    line: bigint;
-    column: bigint;
-};
-export declare function printLocationValue(location: LocationValue): string;
+/** @deprecated Use Location from location.ts directly */
+export type LocationValue = Location;
+/**
+ * Formats a single location as a human-readable string.
+ */
+export declare function printSingleLocationValue(location: LocationValue): string;
+/**
+ * Formats an array of locations as a stack trace string.
+ */
+export declare function printLocationValue(locations: LocationValue[]): string;
 export type ErrorIR = variant<"Error", {
     type: variant<"Never", null>;
-    location: LocationValue;
+    loc_id: bigint;
     message: any;
 }>;
 export type TryCatchIR = variant<"TryCatch", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     try_body: any;
     catch_body: any;
     message: VariableIR;
@@ -28,77 +33,77 @@ export type TryCatchIR = variant<"TryCatch", {
 }>;
 export type ValueIR = variant<"Value", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     value: LiteralValue;
 }>;
 export type VariableIR = variant<"Variable", {
     type: EastTypeValue;
     name: string;
-    location: LocationValue;
+    loc_id: bigint;
     mutable: boolean;
     captured: boolean;
 }>;
 export type LetIR = variant<"Let", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     variable: VariableIR;
     value: any;
 }>;
 export type AssignIR = variant<"Assign", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     variable: VariableIR;
     value: any;
 }>;
 export type AsIR = variant<"As", {
     type: EastTypeValue;
     value: any;
-    location: LocationValue;
+    loc_id: bigint;
 }>;
 export type FunctionIR = variant<"Function", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     captures: VariableIR[];
     parameters: VariableIR[];
     body: any;
 }>;
 export type AsyncFunctionIR = variant<"AsyncFunction", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     captures: VariableIR[];
     parameters: VariableIR[];
     body: any;
 }>;
 export type CallIR = variant<"Call", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     function: any;
     arguments: any[];
 }>;
 export type CallAsyncIR = variant<"CallAsync", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     function: any;
     arguments: any[];
 }>;
 export type NewRefIR = variant<"NewRef", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     value: any;
 }>;
 export type NewArrayIR = variant<"NewArray", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     values: any[];
 }>;
 export type NewSetIR = variant<"NewSet", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     values: any[];
 }>;
 export type NewDictIR = variant<"NewDict", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     values: {
         key: any;
         value: any;
@@ -106,7 +111,7 @@ export type NewDictIR = variant<"NewDict", {
 }>;
 export type StructIR = variant<"Struct", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     fields: {
         name: string;
         value: any;
@@ -114,24 +119,24 @@ export type StructIR = variant<"Struct", {
 }>;
 export type GetFieldIR = variant<"GetField", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     field: string;
     struct: any;
 }>;
 export type VariantIR = variant<"Variant", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     case: string;
     value: any;
 }>;
 export type BlockIR = variant<"Block", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     statements: any[];
 }>;
 export type IfElseIR = variant<"IfElse", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     ifs: {
         predicate: any;
         body: any;
@@ -140,7 +145,7 @@ export type IfElseIR = variant<"IfElse", {
 }>;
 export type MatchIR = variant<"Match", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     variant: any;
     cases: {
         case: string;
@@ -150,28 +155,28 @@ export type MatchIR = variant<"Match", {
 }>;
 export type UnwrapRecursiveIR = variant<"UnwrapRecursive", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     value: any;
 }>;
 export type WrapRecursiveIR = variant<"WrapRecursive", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     value: any;
 }>;
 export type IRLabel = {
     name: string;
-    location: LocationValue;
+    loc_id: bigint;
 };
 export type WhileIR = variant<"While", {
     type: variant<"Null", null>;
-    location: LocationValue;
+    loc_id: bigint;
     predicate: any;
     label: IRLabel;
     body: any;
 }>;
 export type ForArrayIR = variant<"ForArray", {
     type: variant<"Null", null>;
-    location: LocationValue;
+    loc_id: bigint;
     array: any;
     label: IRLabel;
     key: VariableIR;
@@ -180,7 +185,7 @@ export type ForArrayIR = variant<"ForArray", {
 }>;
 export type ForSetIR = variant<"ForSet", {
     type: variant<"Null", null>;
-    location: LocationValue;
+    loc_id: bigint;
     set: any;
     label: IRLabel;
     key: VariableIR;
@@ -188,7 +193,7 @@ export type ForSetIR = variant<"ForSet", {
 }>;
 export type ForDictIR = variant<"ForDict", {
     type: variant<"Null", null>;
-    location: LocationValue;
+    loc_id: bigint;
     dict: any;
     label: IRLabel;
     key: VariableIR;
@@ -197,33 +202,37 @@ export type ForDictIR = variant<"ForDict", {
 }>;
 export type ReturnIR = variant<"Return", {
     type: variant<"Never", null>;
-    location: LocationValue;
+    loc_id: bigint;
     value: any;
 }>;
 export type ContinueIR = variant<"Continue", {
     type: variant<"Never", null>;
-    location: LocationValue;
+    loc_id: bigint;
     label: IRLabel;
 }>;
 export type BreakIR = variant<"Break", {
     type: variant<"Never", null>;
-    location: LocationValue;
+    loc_id: bigint;
     label: IRLabel;
 }>;
 /**@internal */
 export type BuiltinIR = variant<"Builtin", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     builtin: BuiltinName;
     type_parameters: EastTypeValue[];
     arguments: any[];
 }>;
 export type PlatformIR = variant<"Platform", {
     type: EastTypeValue;
-    location: LocationValue;
+    loc_id: bigint;
     name: string;
+    type_parameters: EastTypeValue[];
     arguments: any[];
     async: boolean;
+    /** When true, compilation succeeds even if the platform function is not provided.
+     * A runtime error will be thrown if the function is called without an implementation. */
+    optional: boolean;
 }>;
 /** The common intermediate representation (IR) for East code.
  *
@@ -231,1539 +240,1800 @@ export type PlatformIR = variant<"Platform", {
  * It has been processed from AST and checked for type safety and variable resolution.
  * The code is ready to be serialized, evaluated or compiled.
  */
-export type IR = ErrorIR | TryCatchIR | ValueIR | VariableIR | LetIR | AssignIR | AsIR | FunctionIR | AsyncFunctionIR | CallIR | CallAsyncIR | NewRefIR | NewArrayIR | NewSetIR | NewDictIR | StructIR | GetFieldIR | VariantIR | BlockIR | IfElseIR | MatchIR | UnwrapRecursiveIR | WrapRecursiveIR | WhileIR | ForArrayIR | ForSetIR | ForDictIR | ReturnIR | ContinueIR | BreakIR | BuiltinIR | PlatformIR;
+export type NewVectorIR = variant<"NewVector", {
+    type: EastTypeValue;
+    loc_id: bigint;
+    values: any[];
+}>;
+export type NewMatrixIR = variant<"NewMatrix", {
+    type: EastTypeValue;
+    loc_id: bigint;
+    values: any[];
+    rows: bigint;
+    cols: bigint;
+}>;
+export type IR = ErrorIR | TryCatchIR | ValueIR | VariableIR | LetIR | AssignIR | AsIR | FunctionIR | AsyncFunctionIR | CallIR | CallAsyncIR | NewRefIR | NewArrayIR | NewSetIR | NewDictIR | NewVectorIR | NewMatrixIR | StructIR | GetFieldIR | VariantIR | BlockIR | IfElseIR | MatchIR | UnwrapRecursiveIR | WrapRecursiveIR | WhileIR | ForArrayIR | ForSetIR | ForDictIR | ReturnIR | ContinueIR | BreakIR | BuiltinIR | PlatformIR;
 export declare const LocationType: StructType<{
-    filename: StringType;
-    line: IntegerType;
-    column: IntegerType;
+    readonly filename: StringType;
+    readonly line: IntegerType;
+    readonly column: IntegerType;
 }>;
 export declare const IRLabelType: StructType<{
-    name: StringType;
-    location: StructType<{
-        filename: StringType;
-        line: IntegerType;
-        column: IntegerType;
-    }>;
+    readonly name: StringType;
+    readonly loc_id: IntegerType;
 }>;
 export declare const VariableType: StructType<{
-    type: RecursiveType<VariantType<{
-        Never: import("./types.js").NullType;
-        Null: import("./types.js").NullType;
-        Boolean: import("./types.js").NullType;
-        Integer: import("./types.js").NullType;
-        Float: import("./types.js").NullType;
-        String: import("./types.js").NullType;
-        DateTime: import("./types.js").NullType;
-        Blob: import("./types.js").NullType;
-        Ref: import("./types.js").RecursiveTypeMarker;
-        Array: import("./types.js").RecursiveTypeMarker;
-        Set: import("./types.js").RecursiveTypeMarker;
-        Dict: StructType<{
-            key: import("./types.js").RecursiveTypeMarker;
-            value: import("./types.js").RecursiveTypeMarker;
+    readonly type: RecursiveType<VariantType<{
+        readonly Never: import("./types.js").NullType;
+        readonly Null: import("./types.js").NullType;
+        readonly Boolean: import("./types.js").NullType;
+        readonly Integer: import("./types.js").NullType;
+        readonly Float: import("./types.js").NullType;
+        readonly String: import("./types.js").NullType;
+        readonly DateTime: import("./types.js").NullType;
+        readonly Blob: import("./types.js").NullType;
+        readonly Ref: import("./types.js").RecursiveTypeMarker;
+        readonly Array: import("./types.js").RecursiveTypeMarker;
+        readonly Set: import("./types.js").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("./types.js").RecursiveTypeMarker;
+            readonly value: import("./types.js").RecursiveTypeMarker;
         }>;
-        Struct: ArrayType<StructType<{
-            name: StringType;
-            type: import("./types.js").RecursiveTypeMarker;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("./types.js").RecursiveTypeMarker;
         }>>;
-        Variant: ArrayType<StructType<{
-            name: StringType;
-            type: import("./types.js").RecursiveTypeMarker;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("./types.js").RecursiveTypeMarker;
         }>>;
-        Recursive: IntegerType;
-        Function: StructType<{
-            inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-            output: import("./types.js").RecursiveTypeMarker;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("./types.js").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            readonly output: import("./types.js").RecursiveTypeMarker;
         }>;
-        AsyncFunction: StructType<{
-            inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-            output: import("./types.js").RecursiveTypeMarker;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            readonly output: import("./types.js").RecursiveTypeMarker;
         }>;
+        readonly Vector: import("./types.js").RecursiveTypeMarker;
+        readonly Matrix: import("./types.js").RecursiveTypeMarker;
     }>>;
-    location: StructType<{
-        filename: StringType;
-        line: IntegerType;
-        column: IntegerType;
-    }>;
-    name: StringType;
-    mutable: BooleanType;
-    captured: BooleanType;
+    readonly loc_id: IntegerType;
+    readonly name: StringType;
+    readonly mutable: BooleanType;
+    readonly captured: BooleanType;
 }>;
 export declare const IRType: RecursiveType<VariantType<{
-    Error: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Error: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        message: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly message: import("./types.js").RecursiveTypeMarker;
     }>;
-    TryCatch: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly TryCatch: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        try_body: import("./types.js").RecursiveTypeMarker;
-        catch_body: import("./types.js").RecursiveTypeMarker;
-        message: import("./types.js").RecursiveTypeMarker;
-        stack: import("./types.js").RecursiveTypeMarker;
-        finally_body: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly try_body: import("./types.js").RecursiveTypeMarker;
+        readonly catch_body: import("./types.js").RecursiveTypeMarker;
+        readonly message: import("./types.js").RecursiveTypeMarker;
+        readonly stack: import("./types.js").RecursiveTypeMarker;
+        readonly finally_body: import("./types.js").RecursiveTypeMarker;
     }>;
-    Value: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Value: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        value: VariantType<{
-            Null: import("./types.js").NullType;
-            Boolean: BooleanType;
-            Integer: IntegerType;
-            Float: import("./types.js").FloatType;
-            String: StringType;
-            DateTime: import("./types.js").DateTimeType;
-            Blob: import("./types.js").BlobType;
+        readonly loc_id: IntegerType;
+        readonly value: VariantType<{
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: BooleanType;
+            readonly Integer: IntegerType;
+            readonly Float: import("./types.js").FloatType;
+            readonly String: StringType;
+            readonly DateTime: import("./types.js").DateTimeType;
+            readonly Blob: import("./types.js").BlobType;
         }>;
     }>;
-    Variable: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Variable: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        name: StringType;
-        mutable: BooleanType;
-        captured: BooleanType;
+        readonly loc_id: IntegerType;
+        readonly name: StringType;
+        readonly mutable: BooleanType;
+        readonly captured: BooleanType;
     }>;
-    Let: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Let: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        variable: import("./types.js").RecursiveTypeMarker;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly variable: import("./types.js").RecursiveTypeMarker;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    Assign: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Assign: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        variable: import("./types.js").RecursiveTypeMarker;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly variable: import("./types.js").RecursiveTypeMarker;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    As: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly As: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    Function: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Function: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
-        parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
-        body: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly body: import("./types.js").RecursiveTypeMarker;
     }>;
-    AsyncFunction: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly AsyncFunction: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
-        parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
-        body: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly body: import("./types.js").RecursiveTypeMarker;
     }>;
-    Call: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Call: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        function: import("./types.js").RecursiveTypeMarker;
-        arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly loc_id: IntegerType;
+        readonly function: import("./types.js").RecursiveTypeMarker;
+        readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
     }>;
-    CallAsync: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly CallAsync: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        function: import("./types.js").RecursiveTypeMarker;
-        arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly loc_id: IntegerType;
+        readonly function: import("./types.js").RecursiveTypeMarker;
+        readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
     }>;
-    NewRef: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly NewRef: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    NewArray: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly NewArray: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly loc_id: IntegerType;
+        readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
     }>;
-    NewSet: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly NewSet: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly loc_id: IntegerType;
+        readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
     }>;
-    NewDict: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly NewDict: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        values: ArrayType<StructType<{
-            key: import("./types.js").RecursiveTypeMarker;
-            value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly values: ArrayType<StructType<{
+            readonly key: import("./types.js").RecursiveTypeMarker;
+            readonly value: import("./types.js").RecursiveTypeMarker;
         }>>;
     }>;
-    Struct: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly NewVector: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        fields: ArrayType<StructType<{
-            name: StringType;
-            value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+    readonly NewMatrix: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
+        readonly loc_id: IntegerType;
+        readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly rows: IntegerType;
+        readonly cols: IntegerType;
     }>;
-    GetField: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Struct: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
+        }>>;
+        readonly loc_id: IntegerType;
+        readonly fields: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly value: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        field: StringType;
-        struct: import("./types.js").RecursiveTypeMarker;
     }>;
-    Variant: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly GetField: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        case: StringType;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly field: StringType;
+        readonly struct: import("./types.js").RecursiveTypeMarker;
     }>;
-    Block: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Variant: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        statements: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly loc_id: IntegerType;
+        readonly case: StringType;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    IfElse: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Block: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        ifs: ArrayType<StructType<{
-            predicate: import("./types.js").RecursiveTypeMarker;
-            body: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly statements: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+    readonly IfElse: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
+        }>>;
+        readonly loc_id: IntegerType;
+        readonly ifs: ArrayType<StructType<{
+            readonly predicate: import("./types.js").RecursiveTypeMarker;
+            readonly body: import("./types.js").RecursiveTypeMarker;
         }>>;
-        else_body: import("./types.js").RecursiveTypeMarker;
+        readonly else_body: import("./types.js").RecursiveTypeMarker;
     }>;
-    Match: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Match: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        variant: import("./types.js").RecursiveTypeMarker;
-        cases: ArrayType<StructType<{
-            case: StringType;
-            variable: import("./types.js").RecursiveTypeMarker;
-            body: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly variant: import("./types.js").RecursiveTypeMarker;
+        readonly cases: ArrayType<StructType<{
+            readonly case: StringType;
+            readonly variable: import("./types.js").RecursiveTypeMarker;
+            readonly body: import("./types.js").RecursiveTypeMarker;
         }>>;
     }>;
-    UnwrapRecursive: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly UnwrapRecursive: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    WrapRecursive: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly WrapRecursive: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    While: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly While: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        predicate: import("./types.js").RecursiveTypeMarker;
-        label: StructType<{
-            name: StringType;
-            location: StructType<{
-                filename: StringType;
-                line: IntegerType;
-                column: IntegerType;
-            }>;
+        readonly loc_id: IntegerType;
+        readonly predicate: import("./types.js").RecursiveTypeMarker;
+        readonly label: StructType<{
+            readonly name: StringType;
+            readonly loc_id: IntegerType;
         }>;
-        body: import("./types.js").RecursiveTypeMarker;
+        readonly body: import("./types.js").RecursiveTypeMarker;
     }>;
-    ForArray: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly ForArray: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        array: import("./types.js").RecursiveTypeMarker;
-        label: StructType<{
-            name: StringType;
-            location: StructType<{
-                filename: StringType;
-                line: IntegerType;
-                column: IntegerType;
-            }>;
+        readonly loc_id: IntegerType;
+        readonly array: import("./types.js").RecursiveTypeMarker;
+        readonly label: StructType<{
+            readonly name: StringType;
+            readonly loc_id: IntegerType;
         }>;
-        key: import("./types.js").RecursiveTypeMarker;
-        value: import("./types.js").RecursiveTypeMarker;
-        body: import("./types.js").RecursiveTypeMarker;
+        readonly key: import("./types.js").RecursiveTypeMarker;
+        readonly value: import("./types.js").RecursiveTypeMarker;
+        readonly body: import("./types.js").RecursiveTypeMarker;
     }>;
-    ForSet: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly ForSet: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        set: import("./types.js").RecursiveTypeMarker;
-        label: StructType<{
-            name: StringType;
-            location: StructType<{
-                filename: StringType;
-                line: IntegerType;
-                column: IntegerType;
-            }>;
+        readonly loc_id: IntegerType;
+        readonly set: import("./types.js").RecursiveTypeMarker;
+        readonly label: StructType<{
+            readonly name: StringType;
+            readonly loc_id: IntegerType;
         }>;
-        key: import("./types.js").RecursiveTypeMarker;
-        body: import("./types.js").RecursiveTypeMarker;
+        readonly key: import("./types.js").RecursiveTypeMarker;
+        readonly body: import("./types.js").RecursiveTypeMarker;
     }>;
-    ForDict: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly ForDict: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        dict: import("./types.js").RecursiveTypeMarker;
-        label: StructType<{
-            name: StringType;
-            location: StructType<{
-                filename: StringType;
-                line: IntegerType;
-                column: IntegerType;
-            }>;
+        readonly loc_id: IntegerType;
+        readonly dict: import("./types.js").RecursiveTypeMarker;
+        readonly label: StructType<{
+            readonly name: StringType;
+            readonly loc_id: IntegerType;
         }>;
-        key: import("./types.js").RecursiveTypeMarker;
-        value: import("./types.js").RecursiveTypeMarker;
-        body: import("./types.js").RecursiveTypeMarker;
+        readonly key: import("./types.js").RecursiveTypeMarker;
+        readonly value: import("./types.js").RecursiveTypeMarker;
+        readonly body: import("./types.js").RecursiveTypeMarker;
     }>;
-    Return: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Return: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        value: import("./types.js").RecursiveTypeMarker;
+        readonly loc_id: IntegerType;
+        readonly value: import("./types.js").RecursiveTypeMarker;
     }>;
-    Continue: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Continue: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        label: StructType<{
-            name: StringType;
-            location: StructType<{
-                filename: StringType;
-                line: IntegerType;
-                column: IntegerType;
-            }>;
+        readonly loc_id: IntegerType;
+        readonly label: StructType<{
+            readonly name: StringType;
+            readonly loc_id: IntegerType;
         }>;
     }>;
-    Break: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Break: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        label: StructType<{
-            name: StringType;
-            location: StructType<{
-                filename: StringType;
-                line: IntegerType;
-                column: IntegerType;
-            }>;
+        readonly loc_id: IntegerType;
+        readonly label: StructType<{
+            readonly name: StringType;
+            readonly loc_id: IntegerType;
         }>;
     }>;
-    Builtin: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Builtin: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        builtin: StringType;
-        type_parameters: ArrayType<RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+        readonly loc_id: IntegerType;
+        readonly builtin: StringType;
+        readonly type_parameters: ArrayType<RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>>;
-        arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
     }>;
-    Platform: StructType<{
-        type: RecursiveType<VariantType<{
-            Never: import("./types.js").NullType;
-            Null: import("./types.js").NullType;
-            Boolean: import("./types.js").NullType;
-            Integer: import("./types.js").NullType;
-            Float: import("./types.js").NullType;
-            String: import("./types.js").NullType;
-            DateTime: import("./types.js").NullType;
-            Blob: import("./types.js").NullType;
-            Ref: import("./types.js").RecursiveTypeMarker;
-            Array: import("./types.js").RecursiveTypeMarker;
-            Set: import("./types.js").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("./types.js").RecursiveTypeMarker;
-                value: import("./types.js").RecursiveTypeMarker;
-            }>;
-            Struct: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Variant: ArrayType<StructType<{
-                name: StringType;
-                type: import("./types.js").RecursiveTypeMarker;
-            }>>;
-            Recursive: IntegerType;
-            Function: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
-                output: import("./types.js").RecursiveTypeMarker;
-            }>;
+    readonly Platform: StructType<{
+        readonly type: RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
         }>>;
-        location: StructType<{
-            filename: StringType;
-            line: IntegerType;
-            column: IntegerType;
-        }>;
-        name: StringType;
-        arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
-        async: BooleanType;
+        readonly loc_id: IntegerType;
+        readonly name: StringType;
+        readonly type_parameters: ArrayType<RecursiveType<VariantType<{
+            readonly Never: import("./types.js").NullType;
+            readonly Null: import("./types.js").NullType;
+            readonly Boolean: import("./types.js").NullType;
+            readonly Integer: import("./types.js").NullType;
+            readonly Float: import("./types.js").NullType;
+            readonly String: import("./types.js").NullType;
+            readonly DateTime: import("./types.js").NullType;
+            readonly Blob: import("./types.js").NullType;
+            readonly Ref: import("./types.js").RecursiveTypeMarker;
+            readonly Array: import("./types.js").RecursiveTypeMarker;
+            readonly Set: import("./types.js").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("./types.js").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly output: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("./types.js").RecursiveTypeMarker;
+            readonly Matrix: import("./types.js").RecursiveTypeMarker;
+        }>>>;
+        readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        readonly async: BooleanType;
+        readonly optional: BooleanType;
     }>;
 }>>;
 //# sourceMappingURL=ir.d.ts.map