@elaraai/east 1.0.68 → 1.0.69

package/dist/src/functions.d.ts

@@ -0,0 +1,4103 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Cross-language East functions (#628): export, import, link.
+ *
+ * A function authored in one host language is exported as pure IR — its
+ * `Function` node, the declared `FunctionType`, and the platform functions
+ * it calls — in a **function manifest** (`FunctionManifestType`, one beast2
+ * value per package). Code in the other language refers to it with
+ * `East.importFunction(package, name, type)`: a typed, callable function
+ * expression whose IR is a `Platform` node named {@link IMPORT_PLATFORM}
+ * carrying the package and function names — no new IR node kind, and loud
+ * if it ever reaches a compiler unresolved. `linkImports` resolves every
+ * such node against the manifests: the declared type must equal the
+ * exported type exactly, and the exported IR is embedded as a `Let`-bound
+ * constant at the top of the importing function's body (nested uses
+ * capture it), so the linked program is self-contained IR that runs on any
+ * runner. The python twin is `east.functions` (`East.export_functions`,
+ * `East.import_function`, `East.link_imports`).
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BooleanType, NullType, OptionType, StringType, StructType, type EastType, type FunctionType, type AsyncFunctionType, type ValueTypeOf } from "./types.js";
+import { type EastTypeValue } from "./type_of_type.js";
+import { type IR } from "./ir.js";
+import type { CallableFunctionExpr } from "./expr/function.js";
+import type { CallableAsyncFunctionExpr } from "./expr/asyncfunction.js";
+/** The platform name an unresolved `East.importFunction` carries in IR. */
+export declare const IMPORT_PLATFORM = "east.importFunction";
+/**
+ * One platform function an exported function calls: its name and
+ * signature as the IR emits them, and — when the exporter could tell —
+ * the platform package that implements it (`provider`).
+ *
+ * Fields are declared alphabetically in both languages so the wire layout
+ * cannot depend on declaration order.
+ */
+export declare const PlatformDependencyType: StructType<{
+    readonly async: BooleanType;
+    readonly inputs: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: 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: import("./types.js").VariantType<{
+            readonly ref: import("./types.js").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("./types.js").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 name: StringType;
+    readonly optional: BooleanType;
+    readonly output: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: 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: import("./types.js").VariantType<{
+            readonly ref: import("./types.js").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("./types.js").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 provider: OptionType<StringType>;
+    readonly type_parameters: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: 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: import("./types.js").VariantType<{
+            readonly ref: import("./types.js").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("./types.js").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;
+    }>>>;
+}>;
+/** One exported function: its IR, declared type, and platform dependencies. */
+export declare const FunctionExportType: StructType<{
+    readonly ir: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+        readonly Error: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly message: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly TryCatch: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").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;
+        }>;
+        readonly Value: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly value: import("./types.js").VariantType<{
+                readonly Null: NullType;
+                readonly Boolean: BooleanType;
+                readonly Integer: import("./types.js").IntegerType;
+                readonly Float: import("./types.js").FloatType;
+                readonly String: StringType;
+                readonly DateTime: import("./types.js").DateTimeType;
+                readonly Blob: import("./types.js").BlobType;
+            }>;
+        }>;
+        readonly Variable: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly name: StringType;
+            readonly mutable: BooleanType;
+            readonly captured: BooleanType;
+        }>;
+        readonly Let: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly variable: import("./types.js").RecursiveTypeMarker;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Assign: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly variable: import("./types.js").RecursiveTypeMarker;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly As: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Function: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            readonly body: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            readonly body: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Call: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly function: import("./types.js").RecursiveTypeMarker;
+            readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        }>;
+        readonly CallAsync: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly function: import("./types.js").RecursiveTypeMarker;
+            readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        }>;
+        readonly NewRef: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly NewArray: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        }>;
+        readonly NewSet: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        }>;
+        readonly NewDict: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly values: ArrayType<StructType<{
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly NewVector: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        }>;
+        readonly NewMatrix: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            readonly rows: import("./types.js").IntegerType;
+            readonly cols: import("./types.js").IntegerType;
+        }>;
+        readonly Struct: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly fields: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly GetField: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly field: StringType;
+            readonly struct: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Variant: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly case: StringType;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Block: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly statements: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        }>;
+        readonly IfElse: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly ifs: ArrayType<StructType<{
+                readonly predicate: import("./types.js").RecursiveTypeMarker;
+                readonly body: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            readonly else_body: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Match: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").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;
+            }>>;
+        }>;
+        readonly UnwrapRecursive: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly WrapRecursive: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly While: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly predicate: import("./types.js").RecursiveTypeMarker;
+            readonly label: StructType<{
+                readonly name: StringType;
+                readonly loc_id: import("./types.js").IntegerType;
+            }>;
+            readonly body: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly ForArray: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly array: import("./types.js").RecursiveTypeMarker;
+            readonly label: StructType<{
+                readonly name: StringType;
+                readonly loc_id: import("./types.js").IntegerType;
+            }>;
+            readonly key: import("./types.js").RecursiveTypeMarker;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+            readonly body: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly ForSet: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly set: import("./types.js").RecursiveTypeMarker;
+            readonly label: StructType<{
+                readonly name: StringType;
+                readonly loc_id: import("./types.js").IntegerType;
+            }>;
+            readonly key: import("./types.js").RecursiveTypeMarker;
+            readonly body: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly ForDict: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly dict: import("./types.js").RecursiveTypeMarker;
+            readonly label: StructType<{
+                readonly name: StringType;
+                readonly loc_id: import("./types.js").IntegerType;
+            }>;
+            readonly key: import("./types.js").RecursiveTypeMarker;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+            readonly body: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Return: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        readonly Continue: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly label: StructType<{
+                readonly name: StringType;
+                readonly loc_id: import("./types.js").IntegerType;
+            }>;
+        }>;
+        readonly Break: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly label: StructType<{
+                readonly name: StringType;
+                readonly loc_id: import("./types.js").IntegerType;
+            }>;
+        }>;
+        readonly Builtin: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly builtin: StringType;
+            readonly type_parameters: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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 Platform: StructType<{
+            readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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: import("./types.js").IntegerType;
+            readonly name: StringType;
+            readonly type_parameters: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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;
+        }>;
+    }>>;
+    readonly name: StringType;
+    readonly platforms: ArrayType<StructType<{
+        readonly async: BooleanType;
+        readonly inputs: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: 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: import("./types.js").VariantType<{
+                readonly ref: import("./types.js").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("./types.js").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 name: StringType;
+        readonly optional: BooleanType;
+        readonly output: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: 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: import("./types.js").VariantType<{
+                readonly ref: import("./types.js").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("./types.js").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 provider: OptionType<StringType>;
+        readonly type_parameters: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: 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: import("./types.js").VariantType<{
+                readonly ref: import("./types.js").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("./types.js").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 type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: 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: import("./types.js").VariantType<{
+            readonly ref: import("./types.js").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("./types.js").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;
+    }>>;
+}>;
+/** A package's exported functions — what `east-py export-functions` / `East.exportFunctions` write. */
+export declare const FunctionManifestType: StructType<{
+    readonly functions: ArrayType<StructType<{
+        readonly ir: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+            readonly Error: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly message: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly TryCatch: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").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;
+            }>;
+            readonly Value: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly value: import("./types.js").VariantType<{
+                    readonly Null: NullType;
+                    readonly Boolean: BooleanType;
+                    readonly Integer: import("./types.js").IntegerType;
+                    readonly Float: import("./types.js").FloatType;
+                    readonly String: StringType;
+                    readonly DateTime: import("./types.js").DateTimeType;
+                    readonly Blob: import("./types.js").BlobType;
+                }>;
+            }>;
+            readonly Variable: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly name: StringType;
+                readonly mutable: BooleanType;
+                readonly captured: BooleanType;
+            }>;
+            readonly Let: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly variable: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Assign: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly variable: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly As: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Function: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly body: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly body: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Call: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly function: import("./types.js").RecursiveTypeMarker;
+                readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            }>;
+            readonly CallAsync: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly function: import("./types.js").RecursiveTypeMarker;
+                readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            }>;
+            readonly NewRef: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly NewArray: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            }>;
+            readonly NewSet: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            }>;
+            readonly NewDict: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly values: ArrayType<StructType<{
+                    readonly key: import("./types.js").RecursiveTypeMarker;
+                    readonly value: import("./types.js").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly NewVector: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            }>;
+            readonly NewMatrix: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                readonly rows: import("./types.js").IntegerType;
+                readonly cols: import("./types.js").IntegerType;
+            }>;
+            readonly Struct: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly fields: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly value: import("./types.js").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly GetField: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly field: StringType;
+                readonly struct: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Variant: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly case: StringType;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Block: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly statements: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            }>;
+            readonly IfElse: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly ifs: ArrayType<StructType<{
+                    readonly predicate: import("./types.js").RecursiveTypeMarker;
+                    readonly body: import("./types.js").RecursiveTypeMarker;
+                }>>;
+                readonly else_body: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Match: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").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;
+                }>>;
+            }>;
+            readonly UnwrapRecursive: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly WrapRecursive: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly While: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly predicate: import("./types.js").RecursiveTypeMarker;
+                readonly label: StructType<{
+                    readonly name: StringType;
+                    readonly loc_id: import("./types.js").IntegerType;
+                }>;
+                readonly body: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly ForArray: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly array: import("./types.js").RecursiveTypeMarker;
+                readonly label: StructType<{
+                    readonly name: StringType;
+                    readonly loc_id: import("./types.js").IntegerType;
+                }>;
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+                readonly body: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly ForSet: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly set: import("./types.js").RecursiveTypeMarker;
+                readonly label: StructType<{
+                    readonly name: StringType;
+                    readonly loc_id: import("./types.js").IntegerType;
+                }>;
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly body: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly ForDict: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly dict: import("./types.js").RecursiveTypeMarker;
+                readonly label: StructType<{
+                    readonly name: StringType;
+                    readonly loc_id: import("./types.js").IntegerType;
+                }>;
+                readonly key: import("./types.js").RecursiveTypeMarker;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+                readonly body: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Return: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            readonly Continue: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly label: StructType<{
+                    readonly name: StringType;
+                    readonly loc_id: import("./types.js").IntegerType;
+                }>;
+            }>;
+            readonly Break: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly label: StructType<{
+                    readonly name: StringType;
+                    readonly loc_id: import("./types.js").IntegerType;
+                }>;
+            }>;
+            readonly Builtin: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly builtin: StringType;
+                readonly type_parameters: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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 Platform: StructType<{
+                readonly type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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: import("./types.js").IntegerType;
+                readonly name: StringType;
+                readonly type_parameters: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: 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: import("./types.js").VariantType<{
+                        readonly ref: import("./types.js").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("./types.js").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;
+            }>;
+        }>>;
+        readonly name: StringType;
+        readonly platforms: ArrayType<StructType<{
+            readonly async: BooleanType;
+            readonly inputs: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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 name: StringType;
+            readonly optional: BooleanType;
+            readonly output: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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 provider: OptionType<StringType>;
+            readonly type_parameters: ArrayType<import("./types.js").RecursiveType<import("./types.js").VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: 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: import("./types.js").VariantType<{
+                    readonly ref: import("./types.js").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("./types.js").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 type: import("./types.js").RecursiveType<import("./types.js").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: 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: import("./types.js").VariantType<{
+                readonly ref: import("./types.js").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("./types.js").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 package: StringType;
+    readonly version: StringType;
+}>;
+export type PlatformDependency = ValueTypeOf<typeof PlatformDependencyType>;
+export type FunctionExport = ValueTypeOf<typeof FunctionExportType>;
+export type FunctionManifest = ValueTypeOf<typeof FunctionManifestType>;
+/** An import `linkImports` resolved: where it came from and what it needs. */
+export interface LinkedImport {
+    /** The exporting package (the manifest's `package`). */
+    package: string;
+    /** The function's name in that package. */
+    name: string;
+    /** Its type (the declared type, equal to the exported one). */
+    type: EastTypeValue;
+    /** The platform functions the embedded IR calls. */
+    platforms: PlatformDependency[];
+}
+/** The result of {@link linkImports}. */
+export interface Linked {
+    /** The IR with every import embedded. */
+    ir: IR;
+    /** The imports that were resolved, in first-use order. */
+    imports: LinkedImport[];
+}
+/**
+ * The IR value behind an `East.function` result, an `EastIR` bundle, or an
+ * IR value: what every function-level API here takes.
+ *
+ * @param fnOrIr - A built function expression, its `toIR()`, or an IR node
+ * @returns The IR node
+ * @throws {TypeError} For anything else
+ */
+export declare function functionIR(fnOrIr: unknown): IR;
+/**
+ * The platform functions an IR calls, in first-use order — the name,
+ * signature and asyncness each `Platform` node carries. Unresolved imports
+ * ({@link IMPORT_PLATFORM}) are not dependencies and are skipped.
+ *
+ * @param fnOrIr - A function expression, its `toIR()`, or an IR value
+ * @param providers - Platform name → the package that implements it, when known
+ * @returns The dependencies
+ */
+export declare function platformDependencies(fnOrIr: unknown, providers?: Record<string, string>): PlatformDependency[];
+/** Options for {@link exportFunctions}. */
+export interface ExportFunctionsOptions {
+    /** Platform name → the package that implements it (recorded per dependency). */
+    providers?: Record<string, string>;
+}
+/**
+ * Builds a package's function manifest from its named functions.
+ *
+ * Every function exports as a closed value: a function with captures (a
+ * closure over the enclosing body) is rejected, as is one that itself holds
+ * an unresolved import — link before exporting; v1 does not chain. The
+ * exported IR carries no location ids (a manifest has no source map).
+ *
+ * @param pkg - The exporting package's name (what importers name)
+ * @param version - Its version
+ * @param functions - Name → `East.function` result, `EastIR`, or IR value
+ * @param options - Platform providers to record
+ * @returns The manifest value (encode it with {@link encodeFunctionManifest})
+ * @throws {Error} For a function that is not a closed value
+ *
+ * @example
+ * ```ts
+ * const double = East.function([IntegerType], IntegerType, ($, x) => x.multiply(2n));
+ * const manifest = East.exportFunctions("maths", "1.0.0", { double });
+ * writeFileSync("maths.functions.beast2", East.encodeFunctionManifest(manifest));
+ * ```
+ */
+export declare function exportFunctions(pkg: string, version: string, functions: Record<string, unknown>, options?: ExportFunctionsOptions): FunctionManifest;
+/**
+ * Encodes a function manifest as beast2 — the file `east-node
+ * export-functions` / `east-py export-functions` write and `e3 export` /
+ * `linkImports` read, in either language.
+ */
+export declare function encodeFunctionManifest(manifest: FunctionManifest): Uint8Array;
+/** Decodes a function manifest written by either language. */
+export declare function decodeFunctionManifest(data: Uint8Array): FunctionManifest;
+/**
+ * Refers to a function exported by another package (in either language) as a
+ * typed, callable function expression.
+ *
+ * Unresolved, the reference is a `Platform` node named
+ * {@link IMPORT_PLATFORM} whose arguments are the package and function
+ * names: compiling it without linking fails naming that platform.
+ * `linkImports` — which `e3 export` runs on every task — replaces it with
+ * the exported IR, checked for exact type equality with `type`.
+ *
+ * @param pkg - The exporting package's name (the manifest's `package`)
+ * @param name - The function's name in that package
+ * @param type - The function's declared type, checked exactly at link
+ * @returns A callable function expression of `type`
+ * @throws {TypeError} When `type` is not a function type
+ *
+ * @example
+ * ```ts
+ * const score = East.importFunction("pricing", "score", FunctionType([RowType], FloatType));
+ * const total = East.function([ArrayType(RowType)], FloatType, ($, rows) =>
+ *   rows.map(($, r) => score(r)).sum());
+ * ```
+ */
+export declare function importFunction<I extends EastType[], O extends EastType>(pkg: string, name: string, type: FunctionType<I, O>): CallableFunctionExpr<I, O>;
+export declare function importFunction<I extends EastType[], O extends EastType>(pkg: string, name: string, type: AsyncFunctionType<I, O>): CallableAsyncFunctionExpr<I, O>;
+/**
+ * Resolves every `East.importFunction` reference in a function's IR against
+ * the given manifests and embeds the exported IR.
+ *
+ * For each distinct (package, function): the manifest for the package must
+ * be present, the function must be in it, and the reference's declared type
+ * must equal the exported type exactly — each failure is an error naming the
+ * import (and, for a type mismatch, both types). The exported IR becomes a
+ * `Let`-bound constant at the top of the importing function's body; a use
+ * inside a nested function captures it, so the nested functions' `captures`
+ * are extended. The result is self-contained IR with no import left.
+ *
+ * @param fnOrIr - A function expression, its `toIR()`, or an IR value
+ * @param manifests - The exporting packages' manifests
+ * @returns The linked IR and the imports it resolved (with their platform dependencies)
+ * @throws {Error} For an unresolvable import or a type mismatch
+ */
+export declare function linkImports(fnOrIr: unknown, manifests: FunctionManifest[]): Linked;
+//# sourceMappingURL=functions.d.ts.map