@elaraai/e3-ui 1.0.83 → 1.0.85

package/dist/src/query/library.d.ts

@@ -0,0 +1,3241 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `<Query.Library>` (#1063) — every saved query, and where new queries start,
+ * set out as Studio's page library is.
+ *
+ * The query library is a component of its own, apart from the builder: an
+ * interface — the saved queries record bound with its patch, the data sources
+ * a query may read, the builder it opens queries in, and who to tell — which
+ * the `QueryLibrary` renderer draws, headerless with one toolbar: the search,
+ * Sort, Grid · List and the primary "+ New query on <data source>"; beside it
+ * the data sources with their counts of saved queries, and this viewer's
+ * recent runs; under it the saved queries, each card a wireframe of its steps.
+ * It reads no dataset: a card draws a query, never its data.
+ *
+ * "Open in builder →" opens a query in the builder: it writes the builder's
+ * open query ({@link queryKeys}) and tells the host.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, FunctionType, NullType, OptionType, StringType, StructType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
+import { type JsxTag, type OptionsProps, type UIComponentType } from "@elaraai/east-ui/internal";
+import { type BoundSource } from "../bind/sources.js";
+import { type QueriesHandle } from "./queries.js";
+/**
+ * The `QueryLibrary` renderer's payload — the query library's interface.
+ *
+ * @property queries - The saved queries record, bound with its patch — what it reads
+ * @property datasets - The data sources a query may read, by the names it reads them
+ * @property id - Names the builder whose open query it writes; `none` for the one builder
+ * @property onOpen - Told a query's name when it opens one in the builder — the host shows the builder
+ */
+export declare const QueryLibraryPayloadType: StructType<{
+    readonly queries: StructType<{
+        readonly read: FunctionType<[], import("@elaraai/east").DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly description: OptionType<StringType>;
+            readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                readonly alternative: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly binary: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly op: StringType;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly bind: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                        readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly object: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>>;
+                    readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly break: StringType;
+                readonly call: StructType<{
+                    readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly name: StringType;
+                }>;
+                readonly comma: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly def: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly name: StringType;
+                    readonly params: ArrayType<StringType>;
+                    readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly descend: NullType;
+                readonly field: StructType<{
+                    readonly name: StringType;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly foreach: StructType<{
+                    readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                        readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly object: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>;
+                    readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly format: StructType<{
+                    readonly name: StringType;
+                    readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly identity: NullType;
+                readonly if: StructType<{
+                    readonly branches: ArrayType<StructType<{
+                        readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly index: StructType<{
+                    readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly iterate: StructType<{
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly label: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly name: StringType;
+                }>;
+                readonly literal: import("@elaraai/east").VariantType<{
+                    readonly boolean: import("@elaraai/east").BooleanType;
+                    readonly float: import("@elaraai/east").FloatType;
+                    readonly integer: import("@elaraai/east").IntegerType;
+                    readonly null: NullType;
+                    readonly string: StringType;
+                }>;
+                readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                readonly object: ArrayType<StructType<{
+                    readonly key: import("@elaraai/east").VariantType<{
+                        readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly name: StringType;
+                        readonly variable: StringType;
+                    }>;
+                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>>;
+                readonly pipe: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly reduce: StructType<{
+                    readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                        readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly object: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>;
+                    readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly slice: StructType<{
+                    readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly text: StringType;
+                }>>;
+                readonly try: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly update: StructType<{
+                    readonly op: StringType;
+                    readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly variable: StringType;
+            }>>;
+            readonly root: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly field: StringType;
+                }>>;
+            }>>;
+            readonly saved_at: import("@elaraai/east").DateTimeType;
+        }>>>;
+        readonly history: FunctionType<[], OptionType<ArrayType<StructType<{
+            readonly hash: StringType;
+            readonly parent: OptionType<StringType>;
+            readonly state: StringType;
+            readonly mutation: StringType;
+            readonly actor: StringType;
+            readonly at: import("@elaraai/east").DateTimeType;
+            readonly delta: OptionType<StringType>;
+        }>>>>;
+        readonly commit: StructType<{
+            readonly patch: import("@elaraai/east").AsyncFunctionType<[StringType, import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: import("@elaraai/east").DictType<StringType, StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>>;
+                    after: import("@elaraai/east").DictType<StringType, StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>>;
+                }>;
+                patch: import("@elaraai/east").DictType<StringType, import("@elaraai/east").VariantType<{
+                    delete: StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>;
+                    insert: StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>;
+                    update: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StructType<{
+                                readonly name: StringType;
+                                readonly description: OptionType<StringType>;
+                                readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly alternative: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly binary: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly op: StringType;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly bind: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly break: StringType;
+                                    readonly call: StructType<{
+                                        readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly comma: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly def: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                        readonly params: ArrayType<StringType>;
+                                        readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly descend: NullType;
+                                    readonly field: StructType<{
+                                        readonly name: StringType;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly foreach: StructType<{
+                                        readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly format: StructType<{
+                                        readonly name: StringType;
+                                        readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly identity: NullType;
+                                    readonly if: StructType<{
+                                        readonly branches: ArrayType<StructType<{
+                                            readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>>;
+                                        readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly index: StructType<{
+                                        readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly iterate: StructType<{
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly label: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly literal: import("@elaraai/east").VariantType<{
+                                        readonly boolean: import("@elaraai/east").BooleanType;
+                                        readonly float: import("@elaraai/east").FloatType;
+                                        readonly integer: import("@elaraai/east").IntegerType;
+                                        readonly null: NullType;
+                                        readonly string: StringType;
+                                    }>;
+                                    readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: import("@elaraai/east").VariantType<{
+                                            readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly variable: StringType;
+                                        }>;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly pipe: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly reduce: StructType<{
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly slice: StructType<{
+                                        readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly text: StringType;
+                                    }>>;
+                                    readonly try: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly update: StructType<{
+                                        readonly op: StringType;
+                                        readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly root: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly field: StringType;
+                                    }>>;
+                                }>>;
+                                readonly saved_at: import("@elaraai/east").DateTimeType;
+                            }>;
+                            after: StructType<{
+                                readonly name: StringType;
+                                readonly description: OptionType<StringType>;
+                                readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly alternative: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly binary: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly op: StringType;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly bind: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly break: StringType;
+                                    readonly call: StructType<{
+                                        readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly comma: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly def: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                        readonly params: ArrayType<StringType>;
+                                        readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly descend: NullType;
+                                    readonly field: StructType<{
+                                        readonly name: StringType;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly foreach: StructType<{
+                                        readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly format: StructType<{
+                                        readonly name: StringType;
+                                        readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly identity: NullType;
+                                    readonly if: StructType<{
+                                        readonly branches: ArrayType<StructType<{
+                                            readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>>;
+                                        readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly index: StructType<{
+                                        readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly iterate: StructType<{
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly label: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly literal: import("@elaraai/east").VariantType<{
+                                        readonly boolean: import("@elaraai/east").BooleanType;
+                                        readonly float: import("@elaraai/east").FloatType;
+                                        readonly integer: import("@elaraai/east").IntegerType;
+                                        readonly null: NullType;
+                                        readonly string: StringType;
+                                    }>;
+                                    readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: import("@elaraai/east").VariantType<{
+                                            readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly variable: StringType;
+                                        }>;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly pipe: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly reduce: StructType<{
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly slice: StructType<{
+                                        readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly text: StringType;
+                                    }>>;
+                                    readonly try: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly update: StructType<{
+                                        readonly op: StringType;
+                                        readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly root: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly field: StringType;
+                                    }>>;
+                                }>>;
+                                readonly saved_at: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>;
+                        patch: StructType<{
+                            readonly name: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly description: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: OptionType<StringType>;
+                                    after: OptionType<StringType>;
+                                }>;
+                                patch: import("@elaraai/east").VariantType<{
+                                    none: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    some: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly program: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                        readonly alternative: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly binary: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly op: StringType;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly bind: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly break: StringType;
+                                        readonly call: StructType<{
+                                            readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly comma: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly def: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly params: ArrayType<StringType>;
+                                            readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly descend: NullType;
+                                        readonly field: StructType<{
+                                            readonly name: StringType;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly foreach: StructType<{
+                                            readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly format: StructType<{
+                                            readonly name: StringType;
+                                            readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly identity: NullType;
+                                        readonly if: StructType<{
+                                            readonly branches: ArrayType<StructType<{
+                                                readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                            }>>;
+                                            readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly index: StructType<{
+                                            readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly iterate: StructType<{
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly label: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly literal: import("@elaraai/east").VariantType<{
+                                            readonly boolean: import("@elaraai/east").BooleanType;
+                                            readonly float: import("@elaraai/east").FloatType;
+                                            readonly integer: import("@elaraai/east").IntegerType;
+                                            readonly null: NullType;
+                                            readonly string: StringType;
+                                        }>;
+                                        readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly object: ArrayType<StructType<{
+                                            readonly key: import("@elaraai/east").VariantType<{
+                                                readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly name: StringType;
+                                                readonly variable: StringType;
+                                            }>;
+                                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>>;
+                                        readonly pipe: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly reduce: StructType<{
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly slice: StructType<{
+                                            readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly text: StringType;
+                                        }>>;
+                                        readonly try: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly update: StructType<{
+                                            readonly op: StringType;
+                                            readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly variable: StringType;
+                                    }>>;
+                                    after: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                        readonly alternative: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly binary: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly op: StringType;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly bind: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly break: StringType;
+                                        readonly call: StructType<{
+                                            readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly comma: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly def: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly params: ArrayType<StringType>;
+                                            readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly descend: NullType;
+                                        readonly field: StructType<{
+                                            readonly name: StringType;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly foreach: StructType<{
+                                            readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly format: StructType<{
+                                            readonly name: StringType;
+                                            readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly identity: NullType;
+                                        readonly if: StructType<{
+                                            readonly branches: ArrayType<StructType<{
+                                                readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                            }>>;
+                                            readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly index: StructType<{
+                                            readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly iterate: StructType<{
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly label: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly literal: import("@elaraai/east").VariantType<{
+                                            readonly boolean: import("@elaraai/east").BooleanType;
+                                            readonly float: import("@elaraai/east").FloatType;
+                                            readonly integer: import("@elaraai/east").IntegerType;
+                                            readonly null: NullType;
+                                            readonly string: StringType;
+                                        }>;
+                                        readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly object: ArrayType<StructType<{
+                                            readonly key: import("@elaraai/east").VariantType<{
+                                                readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly name: StringType;
+                                                readonly variable: StringType;
+                                            }>;
+                                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>>;
+                                        readonly pipe: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly reduce: StructType<{
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly slice: StructType<{
+                                            readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly text: StringType;
+                                        }>>;
+                                        readonly try: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly update: StructType<{
+                                            readonly op: StringType;
+                                            readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly variable: StringType;
+                                    }>>;
+                                }>;
+                            }>;
+                            readonly root: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: ArrayType<StructType<{
+                                        readonly name: StringType;
+                                        readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly field: StringType;
+                                        }>>;
+                                    }>>;
+                                    after: ArrayType<StructType<{
+                                        readonly name: StringType;
+                                        readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly field: StringType;
+                                        }>>;
+                                    }>>;
+                                }>;
+                                patch: ArrayType<StructType<{
+                                    key: import("@elaraai/east").IntegerType;
+                                    offset: import("@elaraai/east").IntegerType;
+                                    operation: import("@elaraai/east").VariantType<{
+                                        delete: StructType<{
+                                            readonly name: StringType;
+                                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                readonly field: StringType;
+                                            }>>;
+                                        }>;
+                                        insert: StructType<{
+                                            readonly name: StringType;
+                                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                readonly field: StringType;
+                                            }>>;
+                                        }>;
+                                        update: import("@elaraai/east").VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: StructType<{
+                                                    readonly name: StringType;
+                                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                        readonly field: StringType;
+                                                    }>>;
+                                                }>;
+                                                after: StructType<{
+                                                    readonly name: StringType;
+                                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                        readonly field: StringType;
+                                                    }>>;
+                                                }>;
+                                            }>;
+                                            patch: StructType<{
+                                                readonly name: import("@elaraai/east").VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: StringType;
+                                                        after: StringType;
+                                                    }>;
+                                                }>;
+                                                readonly path: import("@elaraai/east").VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: ArrayType<import("@elaraai/east").VariantType<{
+                                                            readonly field: StringType;
+                                                        }>>;
+                                                        after: ArrayType<import("@elaraai/east").VariantType<{
+                                                            readonly field: StringType;
+                                                        }>>;
+                                                    }>;
+                                                    patch: ArrayType<StructType<{
+                                                        key: import("@elaraai/east").IntegerType;
+                                                        offset: import("@elaraai/east").IntegerType;
+                                                        operation: import("@elaraai/east").VariantType<{
+                                                            delete: import("@elaraai/east").VariantType<{
+                                                                readonly field: StringType;
+                                                            }>;
+                                                            insert: import("@elaraai/east").VariantType<{
+                                                                readonly field: StringType;
+                                                            }>;
+                                                            update: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: import("@elaraai/east").VariantType<{
+                                                                        readonly field: StringType;
+                                                                    }>;
+                                                                    after: import("@elaraai/east").VariantType<{
+                                                                        readonly field: StringType;
+                                                                    }>;
+                                                                }>;
+                                                                patch: import("@elaraai/east").VariantType<{
+                                                                    readonly field: import("@elaraai/east").VariantType<{
+                                                                        unchanged: NullType;
+                                                                        replace: StructType<{
+                                                                            before: StringType;
+                                                                            after: StringType;
+                                                                        }>;
+                                                                    }>;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly saved_at: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: import("@elaraai/east").DateTimeType;
+                                    after: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>>;
+            }>], import("@elaraai/east").VariantType<{
+                readonly transport: StructType<{
+                    readonly message: StringType;
+                }>;
+                readonly committed: StructType<{
+                    readonly commitHash: StringType;
+                    readonly stateHash: StringType;
+                }>;
+                readonly invalid: StructType<{
+                    readonly message: StringType;
+                }>;
+                readonly failed: StructType<{
+                    readonly exitCode: import("@elaraai/east").IntegerType;
+                    readonly stderr: StringType;
+                }>;
+                readonly timed_out: StructType<{
+                    readonly ms: import("@elaraai/east").IntegerType;
+                    readonly stderr: StringType;
+                }>;
+                readonly conflict: StructType<{
+                    readonly attempts: import("@elaraai/east").IntegerType;
+                    readonly detail: OptionType<StringType>;
+                }>;
+            }>>;
+        }>;
+    }>;
+    readonly datasets: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly source: import("@elaraai/east").VariantType<{
+            readonly paged: StringType;
+            readonly record: StringType;
+            readonly value: ArrayType<import("@elaraai/east").VariantType<{
+                readonly field: StringType;
+            }>>;
+        }>;
+        readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").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("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>>;
+    readonly id: OptionType<StringType>;
+    readonly onOpen: OptionType<FunctionType<[StringType], NullType>>;
+}>;
+/** Type representing the `QueryLibrary` renderer's payload. */
+export type QueryLibraryPayloadType = typeof QueryLibraryPayloadType;
+/**
+ * Internal {@link EastUI.component} carrier. The React renderer registers
+ * against this in `@elaraai/e3-ui-components` via `implementUIComponent`.
+ */
+export declare const QueryLibraryComponent: import("@elaraai/east-ui/internal").UIComponentDef<StructType<{
+    readonly queries: StructType<{
+        readonly read: FunctionType<[], import("@elaraai/east").DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly description: OptionType<StringType>;
+            readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                readonly alternative: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly binary: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly op: StringType;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly bind: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                        readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly object: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>>;
+                    readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly break: StringType;
+                readonly call: StructType<{
+                    readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly name: StringType;
+                }>;
+                readonly comma: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly def: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly name: StringType;
+                    readonly params: ArrayType<StringType>;
+                    readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly descend: NullType;
+                readonly field: StructType<{
+                    readonly name: StringType;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly foreach: StructType<{
+                    readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                        readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly object: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>;
+                    readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly format: StructType<{
+                    readonly name: StringType;
+                    readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly identity: NullType;
+                readonly if: StructType<{
+                    readonly branches: ArrayType<StructType<{
+                        readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly index: StructType<{
+                    readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly iterate: StructType<{
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly label: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly name: StringType;
+                }>;
+                readonly literal: import("@elaraai/east").VariantType<{
+                    readonly boolean: import("@elaraai/east").BooleanType;
+                    readonly float: import("@elaraai/east").FloatType;
+                    readonly integer: import("@elaraai/east").IntegerType;
+                    readonly null: NullType;
+                    readonly string: StringType;
+                }>;
+                readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                readonly object: ArrayType<StructType<{
+                    readonly key: import("@elaraai/east").VariantType<{
+                        readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly name: StringType;
+                        readonly variable: StringType;
+                    }>;
+                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>>;
+                readonly pipe: StructType<{
+                    readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly reduce: StructType<{
+                    readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                        readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly object: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>;
+                    readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly slice: StructType<{
+                    readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly text: StringType;
+                }>>;
+                readonly try: StructType<{
+                    readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly update: StructType<{
+                    readonly op: StringType;
+                    readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly variable: StringType;
+            }>>;
+            readonly root: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly field: StringType;
+                }>>;
+            }>>;
+            readonly saved_at: import("@elaraai/east").DateTimeType;
+        }>>>;
+        readonly history: FunctionType<[], OptionType<ArrayType<StructType<{
+            readonly hash: StringType;
+            readonly parent: OptionType<StringType>;
+            readonly state: StringType;
+            readonly mutation: StringType;
+            readonly actor: StringType;
+            readonly at: import("@elaraai/east").DateTimeType;
+            readonly delta: OptionType<StringType>;
+        }>>>>;
+        readonly commit: StructType<{
+            readonly patch: import("@elaraai/east").AsyncFunctionType<[StringType, import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: import("@elaraai/east").DictType<StringType, StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>>;
+                    after: import("@elaraai/east").DictType<StringType, StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>>;
+                }>;
+                patch: import("@elaraai/east").DictType<StringType, import("@elaraai/east").VariantType<{
+                    delete: StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>;
+                    insert: StructType<{
+                        readonly name: StringType;
+                        readonly description: OptionType<StringType>;
+                        readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                            readonly alternative: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly binary: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly op: StringType;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly bind: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly break: StringType;
+                            readonly call: StructType<{
+                                readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly name: StringType;
+                            }>;
+                            readonly comma: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly def: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                                readonly params: ArrayType<StringType>;
+                                readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly descend: NullType;
+                            readonly field: StructType<{
+                                readonly name: StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly foreach: StructType<{
+                                readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly format: StructType<{
+                                readonly name: StringType;
+                                readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly identity: NullType;
+                            readonly if: StructType<{
+                                readonly branches: ArrayType<StructType<{
+                                    readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly index: StructType<{
+                                readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly iterate: StructType<{
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly label: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly name: StringType;
+                            }>;
+                            readonly literal: import("@elaraai/east").VariantType<{
+                                readonly boolean: import("@elaraai/east").BooleanType;
+                                readonly float: import("@elaraai/east").FloatType;
+                                readonly integer: import("@elaraai/east").IntegerType;
+                                readonly null: NullType;
+                                readonly string: StringType;
+                            }>;
+                            readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly object: ArrayType<StructType<{
+                                readonly key: import("@elaraai/east").VariantType<{
+                                    readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly name: StringType;
+                                    readonly variable: StringType;
+                                }>;
+                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            readonly pipe: StructType<{
+                                readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly reduce: StructType<{
+                                readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: StringType;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly slice: StructType<{
+                                readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly text: StringType;
+                            }>>;
+                            readonly try: StructType<{
+                                readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                            }>;
+                            readonly update: StructType<{
+                                readonly op: StringType;
+                                readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly variable: StringType;
+                        }>>;
+                        readonly root: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly field: StringType;
+                            }>>;
+                        }>>;
+                        readonly saved_at: import("@elaraai/east").DateTimeType;
+                    }>;
+                    update: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StructType<{
+                                readonly name: StringType;
+                                readonly description: OptionType<StringType>;
+                                readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly alternative: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly binary: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly op: StringType;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly bind: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly break: StringType;
+                                    readonly call: StructType<{
+                                        readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly comma: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly def: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                        readonly params: ArrayType<StringType>;
+                                        readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly descend: NullType;
+                                    readonly field: StructType<{
+                                        readonly name: StringType;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly foreach: StructType<{
+                                        readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly format: StructType<{
+                                        readonly name: StringType;
+                                        readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly identity: NullType;
+                                    readonly if: StructType<{
+                                        readonly branches: ArrayType<StructType<{
+                                            readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>>;
+                                        readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly index: StructType<{
+                                        readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly iterate: StructType<{
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly label: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly literal: import("@elaraai/east").VariantType<{
+                                        readonly boolean: import("@elaraai/east").BooleanType;
+                                        readonly float: import("@elaraai/east").FloatType;
+                                        readonly integer: import("@elaraai/east").IntegerType;
+                                        readonly null: NullType;
+                                        readonly string: StringType;
+                                    }>;
+                                    readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: import("@elaraai/east").VariantType<{
+                                            readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly variable: StringType;
+                                        }>;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly pipe: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly reduce: StructType<{
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly slice: StructType<{
+                                        readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly text: StringType;
+                                    }>>;
+                                    readonly try: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly update: StructType<{
+                                        readonly op: StringType;
+                                        readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly root: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly field: StringType;
+                                    }>>;
+                                }>>;
+                                readonly saved_at: import("@elaraai/east").DateTimeType;
+                            }>;
+                            after: StructType<{
+                                readonly name: StringType;
+                                readonly description: OptionType<StringType>;
+                                readonly program: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                    readonly alternative: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly binary: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly op: StringType;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly bind: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly break: StringType;
+                                    readonly call: StructType<{
+                                        readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly comma: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly def: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                        readonly params: ArrayType<StringType>;
+                                        readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly descend: NullType;
+                                    readonly field: StructType<{
+                                        readonly name: StringType;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly foreach: StructType<{
+                                        readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly format: StructType<{
+                                        readonly name: StringType;
+                                        readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly identity: NullType;
+                                    readonly if: StructType<{
+                                        readonly branches: ArrayType<StructType<{
+                                            readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>>;
+                                        readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly index: StructType<{
+                                        readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly iterate: StructType<{
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly label: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly name: StringType;
+                                    }>;
+                                    readonly literal: import("@elaraai/east").VariantType<{
+                                        readonly boolean: import("@elaraai/east").BooleanType;
+                                        readonly float: import("@elaraai/east").FloatType;
+                                        readonly integer: import("@elaraai/east").IntegerType;
+                                        readonly null: NullType;
+                                        readonly string: StringType;
+                                    }>;
+                                    readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly object: ArrayType<StructType<{
+                                        readonly key: import("@elaraai/east").VariantType<{
+                                            readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly variable: StringType;
+                                        }>;
+                                        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    readonly pipe: StructType<{
+                                        readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly reduce: StructType<{
+                                        readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                            readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly object: ArrayType<StructType<{
+                                                readonly key: StringType;
+                                                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            }>>;
+                                            readonly variable: StringType;
+                                        }>>;
+                                        readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly slice: StructType<{
+                                        readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly optional: import("@elaraai/east").BooleanType;
+                                        readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly text: StringType;
+                                    }>>;
+                                    readonly try: StructType<{
+                                        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>;
+                                    readonly update: StructType<{
+                                        readonly op: StringType;
+                                        readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                    readonly variable: StringType;
+                                }>>;
+                                readonly root: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly field: StringType;
+                                    }>>;
+                                }>>;
+                                readonly saved_at: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>;
+                        patch: StructType<{
+                            readonly name: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly description: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: OptionType<StringType>;
+                                    after: OptionType<StringType>;
+                                }>;
+                                patch: import("@elaraai/east").VariantType<{
+                                    none: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    some: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly program: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                        readonly alternative: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly binary: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly op: StringType;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly bind: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly break: StringType;
+                                        readonly call: StructType<{
+                                            readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly comma: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly def: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly params: ArrayType<StringType>;
+                                            readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly descend: NullType;
+                                        readonly field: StructType<{
+                                            readonly name: StringType;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly foreach: StructType<{
+                                            readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly format: StructType<{
+                                            readonly name: StringType;
+                                            readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly identity: NullType;
+                                        readonly if: StructType<{
+                                            readonly branches: ArrayType<StructType<{
+                                                readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                            }>>;
+                                            readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly index: StructType<{
+                                            readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly iterate: StructType<{
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly label: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly literal: import("@elaraai/east").VariantType<{
+                                            readonly boolean: import("@elaraai/east").BooleanType;
+                                            readonly float: import("@elaraai/east").FloatType;
+                                            readonly integer: import("@elaraai/east").IntegerType;
+                                            readonly null: NullType;
+                                            readonly string: StringType;
+                                        }>;
+                                        readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly object: ArrayType<StructType<{
+                                            readonly key: import("@elaraai/east").VariantType<{
+                                                readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly name: StringType;
+                                                readonly variable: StringType;
+                                            }>;
+                                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>>;
+                                        readonly pipe: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly reduce: StructType<{
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly slice: StructType<{
+                                            readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly text: StringType;
+                                        }>>;
+                                        readonly try: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly update: StructType<{
+                                            readonly op: StringType;
+                                            readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly variable: StringType;
+                                    }>>;
+                                    after: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                        readonly alternative: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly array: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        readonly binary: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly op: StringType;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly bind: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly patterns: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly break: StringType;
+                                        readonly call: StructType<{
+                                            readonly args: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly comma: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly def: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                            readonly params: ArrayType<StringType>;
+                                            readonly rest: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly descend: NullType;
+                                        readonly field: StructType<{
+                                            readonly name: StringType;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly foreach: StructType<{
+                                            readonly extract: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly format: StructType<{
+                                            readonly name: StringType;
+                                            readonly string: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly identity: NullType;
+                                        readonly if: StructType<{
+                                            readonly branches: ArrayType<StructType<{
+                                                readonly condition: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly then: import("@elaraai/east").RecursiveTypeMarker;
+                                            }>>;
+                                            readonly otherwise: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly index: StructType<{
+                                            readonly index: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly iterate: StructType<{
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly label: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly name: StringType;
+                                        }>;
+                                        readonly literal: import("@elaraai/east").VariantType<{
+                                            readonly boolean: import("@elaraai/east").BooleanType;
+                                            readonly float: import("@elaraai/east").FloatType;
+                                            readonly integer: import("@elaraai/east").IntegerType;
+                                            readonly null: NullType;
+                                            readonly string: StringType;
+                                        }>;
+                                        readonly negate: import("@elaraai/east").RecursiveTypeMarker;
+                                        readonly object: ArrayType<StructType<{
+                                            readonly key: import("@elaraai/east").VariantType<{
+                                                readonly computed: import("@elaraai/east").RecursiveTypeMarker;
+                                                readonly name: StringType;
+                                                readonly variable: StringType;
+                                            }>;
+                                            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>>;
+                                        readonly pipe: StructType<{
+                                            readonly left: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly right: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly reduce: StructType<{
+                                            readonly init: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly pattern: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                                                readonly array: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                readonly object: ArrayType<StructType<{
+                                                    readonly key: StringType;
+                                                    readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                                }>>;
+                                                readonly variable: StringType;
+                                            }>>;
+                                            readonly source: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly update: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly slice: StructType<{
+                                            readonly from: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                            readonly optional: import("@elaraai/east").BooleanType;
+                                            readonly target: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly to: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly string: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly interpolate: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly text: StringType;
+                                        }>>;
+                                        readonly try: StructType<{
+                                            readonly body: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly catch: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                                        }>;
+                                        readonly update: StructType<{
+                                            readonly op: StringType;
+                                            readonly path: import("@elaraai/east").RecursiveTypeMarker;
+                                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                        }>;
+                                        readonly variable: StringType;
+                                    }>>;
+                                }>;
+                            }>;
+                            readonly root: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: ArrayType<StructType<{
+                                        readonly name: StringType;
+                                        readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly field: StringType;
+                                        }>>;
+                                    }>>;
+                                    after: ArrayType<StructType<{
+                                        readonly name: StringType;
+                                        readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                            readonly field: StringType;
+                                        }>>;
+                                    }>>;
+                                }>;
+                                patch: ArrayType<StructType<{
+                                    key: import("@elaraai/east").IntegerType;
+                                    offset: import("@elaraai/east").IntegerType;
+                                    operation: import("@elaraai/east").VariantType<{
+                                        delete: StructType<{
+                                            readonly name: StringType;
+                                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                readonly field: StringType;
+                                            }>>;
+                                        }>;
+                                        insert: StructType<{
+                                            readonly name: StringType;
+                                            readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                readonly field: StringType;
+                                            }>>;
+                                        }>;
+                                        update: import("@elaraai/east").VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: StructType<{
+                                                    readonly name: StringType;
+                                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                        readonly field: StringType;
+                                                    }>>;
+                                                }>;
+                                                after: StructType<{
+                                                    readonly name: StringType;
+                                                    readonly path: ArrayType<import("@elaraai/east").VariantType<{
+                                                        readonly field: StringType;
+                                                    }>>;
+                                                }>;
+                                            }>;
+                                            patch: StructType<{
+                                                readonly name: import("@elaraai/east").VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: StringType;
+                                                        after: StringType;
+                                                    }>;
+                                                }>;
+                                                readonly path: import("@elaraai/east").VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: ArrayType<import("@elaraai/east").VariantType<{
+                                                            readonly field: StringType;
+                                                        }>>;
+                                                        after: ArrayType<import("@elaraai/east").VariantType<{
+                                                            readonly field: StringType;
+                                                        }>>;
+                                                    }>;
+                                                    patch: ArrayType<StructType<{
+                                                        key: import("@elaraai/east").IntegerType;
+                                                        offset: import("@elaraai/east").IntegerType;
+                                                        operation: import("@elaraai/east").VariantType<{
+                                                            delete: import("@elaraai/east").VariantType<{
+                                                                readonly field: StringType;
+                                                            }>;
+                                                            insert: import("@elaraai/east").VariantType<{
+                                                                readonly field: StringType;
+                                                            }>;
+                                                            update: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: import("@elaraai/east").VariantType<{
+                                                                        readonly field: StringType;
+                                                                    }>;
+                                                                    after: import("@elaraai/east").VariantType<{
+                                                                        readonly field: StringType;
+                                                                    }>;
+                                                                }>;
+                                                                patch: import("@elaraai/east").VariantType<{
+                                                                    readonly field: import("@elaraai/east").VariantType<{
+                                                                        unchanged: NullType;
+                                                                        replace: StructType<{
+                                                                            before: StringType;
+                                                                            after: StringType;
+                                                                        }>;
+                                                                    }>;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly saved_at: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: import("@elaraai/east").DateTimeType;
+                                    after: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>>;
+            }>], import("@elaraai/east").VariantType<{
+                readonly transport: StructType<{
+                    readonly message: StringType;
+                }>;
+                readonly committed: StructType<{
+                    readonly commitHash: StringType;
+                    readonly stateHash: StringType;
+                }>;
+                readonly invalid: StructType<{
+                    readonly message: StringType;
+                }>;
+                readonly failed: StructType<{
+                    readonly exitCode: import("@elaraai/east").IntegerType;
+                    readonly stderr: StringType;
+                }>;
+                readonly timed_out: StructType<{
+                    readonly ms: import("@elaraai/east").IntegerType;
+                    readonly stderr: StringType;
+                }>;
+                readonly conflict: StructType<{
+                    readonly attempts: import("@elaraai/east").IntegerType;
+                    readonly detail: OptionType<StringType>;
+                }>;
+            }>>;
+        }>;
+    }>;
+    readonly datasets: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly source: import("@elaraai/east").VariantType<{
+            readonly paged: StringType;
+            readonly record: StringType;
+            readonly value: ArrayType<import("@elaraai/east").VariantType<{
+                readonly field: StringType;
+            }>>;
+        }>;
+        readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").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("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>>;
+    readonly id: OptionType<StringType>;
+    readonly onOpen: OptionType<FunctionType<[StringType], NullType>>;
+}>>;
+/**
+ * `<Query.Library>` options.
+ *
+ * @property queries - The saved queries record, bound with its patch mutation — `Record.bind(queries, [queriesPatch])`
+ * @property datasets - The data sources a query may read: each name, as a query reads it, to its binding
+ * @property id - Names the builder whose open query it writes, when a surface holds two
+ * @property onOpen - Told a query's name when it opens one in the builder — the host shows the builder
+ */
+export interface QueryLibraryOptions {
+    /** The saved queries record, bound with its patch mutation — `Record.bind(queries, [queriesPatch])`. */
+    queries: QueriesHandle;
+    /**
+     * The data sources a query may read: each name, as a query reads it
+     * (`orders` for `.orders`), to its `Data.bind`, `Data.bindPaged` or
+     * `Record.bind` handle — the builder's own, so a query opens where its data
+     * sources are bound.
+     */
+    datasets: Readonly<Record<string, BoundSource>>;
+    /** Names the builder whose open query it writes — needed only when one surface holds two builders. */
+    id?: string;
+    /** Told a query's name when it opens one in the builder — the host shows the builder. */
+    onOpen?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
+}
+/**
+ * Every saved query, and where new queries start.
+ *
+ * @remarks
+ * - **The toolbar**, one row: the search "Search N queries…", over names,
+ *   descriptions and data sources; Sort · Recent or Name; Grid · List; and
+ *   "+ New query on <data source>" — the data source the pane shows, else the
+ *   first bound — which opens a new query on it in the builder.
+ * - **The pane**: All queries, then each bound data source with its count of
+ *   the saved queries that start from it, the one shown in the brand; and, at
+ *   its foot, Recent — this viewer's runs.
+ * - **The gallery**: three across, or a row each, every card a wireframe of
+ *   the query — its source and a bar per step — with its name, its
+ *   description (the author's, else the sentence generated from its steps),
+ *   what it starts from and gives, and "Open in builder →". A card drags onto
+ *   the builder that shares `id`. A query whose data sources aren't bound
+ *   here says why, and doesn't open.
+ *
+ * The data source shown, the search, the order and the layout are the query
+ * library's own; the query it opens is the builder's, shared by `id` with a
+ * `<Query.Builder>`. The query library reads no dataset, and draws no border
+ * around itself. Its data sources are the surface's bindings, which the host
+ * loads with the surface as it loads any: bind a large one with
+ * `Data.bindPaged`, which is declared and never loaded whole.
+ *
+ * @param options - The bound record, the data sources, the builder's name and who to tell ({@link QueryLibraryOptions})
+ * @returns An East expression of type `UIComponentType`
+ * @throws {Error} When `datasets` is empty, or a name is not a jq identifier
+ *
+ * @example
+ * ```tsx
+ * import { East } from "@elaraai/east";
+ * import { Reactive, UIComponentType } from "@elaraai/east-ui";
+ * import { Data, Query, Record, ui } from "@elaraai/e3-ui";
+ *
+ * // The query library: every saved query, and where new queries start — over the builder's data sources.
+ * export const library = ui("query_library", [], East.function([], UIComponentType, _$ => (
+ *     <Reactive>{$ => {
+ *         const orders    = $.let(Data.bindPaged(d.orders));
+ *         const customers = $.let(Data.bind(d.customers));
+ *         const saved     = $.let(Record.bind(d.queries, [d.queriesPatch]));
+ *         return <Query.Library queries={saved} datasets={{ orders, customers }} />;
+ *     }}</Reactive>
+ * )));
+ * ```
+ */
+declare function createLibrary(options: QueryLibraryOptions): ExprType<UIComponentType>;
+/**
+ * `<Query.Library>` — every saved query, and where new queries start. See
+ * {@link createLibrary}.
+ */
+export declare const QueryLibrary: JsxTag<OptionsProps<typeof createLibrary>>;
+export {};
+//# sourceMappingURL=library.d.ts.map