@elaraai/e3-ui 1.0.83 → 1.0.85

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

@@ -0,0 +1,3257 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `<Query.Builder>` (#935) — the query builder as one component: the open
+ * query's steps, or its jq, in a pane beside its results, under one toolbar.
+ *
+ * The builder is an interface — the saved queries record bound with its
+ * patch, the data sources it may read, and its name — which the
+ * `QueryBuilder` renderer draws. Its only data sources are the bindings it is
+ * handed: a query over the page reads exactly those, by the page's names.
+ * `<Query.Library>` opens queries in it, shared by `id`.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, 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 names a query builder shares, by its `id`: the UI store key of the
+ * query open in it — which the query library writes when it opens a query —
+ * the key of this viewer's recent runs, and the drag-source id of the query
+ * library's cards.
+ *
+ * @remarks
+ * A builder and a query library with the same `id` open one query together,
+ * as Studio's builder and page library open one page (`builderKeys`).
+ *
+ * @param id - The builder's name, when a surface holds more than one; omitted, the one builder
+ * @returns The keys and the id
+ */
+export declare function queryKeys(id: string | undefined): {
+    /** The open query's UI store key. */
+    query: string;
+    /** This viewer's recent runs' storage key. */
+    recent: string;
+    /** The query library's drag-source id — what the builder takes cards from. */
+    library: string;
+};
+/**
+ * The `QueryBuilder` renderer's payload — the builder's interface.
+ *
+ * @property queries - The saved queries record, bound with its patch — what the builder reads, and saves through
+ * @property datasets - The data sources a query may read, by the names it reads them
+ * @property query - The saved query the builder opens first, by name; none, a new query on the first data source
+ * @property id - Names the builder, when a surface holds two — and the query library that opens queries in it
+ */
+export declare const QueryBuilderPayloadType: StructType<{
+    readonly queries: StructType<{
+        readonly read: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly description: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: StructType<{
+                                    before: OptionType<StringType>;
+                                    after: OptionType<StringType>;
+                                }>;
+                                patch: import("@elaraai/east").VariantType<{
+                                    none: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    some: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly program: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").NullType;
+                                                    replace: StructType<{
+                                                        before: StringType;
+                                                        after: StringType;
+                                                    }>;
+                                                }>;
+                                                readonly path: import("@elaraai/east").VariantType<{
+                                                    unchanged: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").NullType;
+                                                                        replace: StructType<{
+                                                                            before: StringType;
+                                                                            after: StringType;
+                                                                        }>;
+                                                                    }>;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly saved_at: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").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: import("@elaraai/east").NullType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").NullType;
+            readonly Integer: import("@elaraai/east").NullType;
+            readonly Float: import("@elaraai/east").NullType;
+            readonly String: import("@elaraai/east").NullType;
+            readonly DateTime: import("@elaraai/east").NullType;
+            readonly Blob: import("@elaraai/east").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 query: OptionType<StringType>;
+    readonly id: OptionType<StringType>;
+}>;
+/** Type representing the `QueryBuilder` renderer's payload. */
+export type QueryBuilderPayloadType = typeof QueryBuilderPayloadType;
+/**
+ * Internal {@link EastUI.component} carrier. The React renderer registers
+ * against this in `@elaraai/e3-ui-components` via `implementUIComponent`.
+ */
+export declare const QueryBuilderComponent: import("@elaraai/east-ui/internal").UIComponentDef<StructType<{
+    readonly queries: StructType<{
+        readonly read: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly description: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: StructType<{
+                                    before: OptionType<StringType>;
+                                    after: OptionType<StringType>;
+                                }>;
+                                patch: import("@elaraai/east").VariantType<{
+                                    none: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    some: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly program: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").NullType;
+                                                    replace: StructType<{
+                                                        before: StringType;
+                                                        after: StringType;
+                                                    }>;
+                                                }>;
+                                                readonly path: import("@elaraai/east").VariantType<{
+                                                    unchanged: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").NullType;
+                                                                        replace: StructType<{
+                                                                            before: StringType;
+                                                                            after: StringType;
+                                                                        }>;
+                                                                    }>;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly saved_at: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").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: import("@elaraai/east").NullType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").NullType;
+            readonly Integer: import("@elaraai/east").NullType;
+            readonly Float: import("@elaraai/east").NullType;
+            readonly String: import("@elaraai/east").NullType;
+            readonly DateTime: import("@elaraai/east").NullType;
+            readonly Blob: import("@elaraai/east").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 query: OptionType<StringType>;
+    readonly id: OptionType<StringType>;
+}>>;
+/**
+ * `<Query.Builder>` 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 query - The saved query the builder opens first, by name
+ * @property id - Names the builder, when a surface holds two — and the query library that opens queries in it
+ */
+export interface QueryBuilderOptions {
+    /** 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.
+     */
+    datasets: Readonly<Record<string, BoundSource>>;
+    /**
+     * The saved query the builder opens first, by name — and runs, as opening a
+     * saved query does. Omitted, the builder opens a new query on the first data
+     * source. A query opened later, from the query library or the builder's
+     * own tabs, takes its place.
+     */
+    query?: SubtypeExprOrValue<StringType>;
+    /** Names the builder — needed only when one surface holds two builders, and then given to the query library that opens queries in it. */
+    id?: string;
+}
+/**
+ * The query builder: the open query's steps in plain words, or its jq, checked
+ * as they are edited, and run to read the result.
+ *
+ * @remarks
+ * - **The data sources** are the bindings it is handed, by their names: a
+ *   query over `datasets={{ orders, customers }}` reads `.orders` and
+ *   `.customers`, and nothing else. They are in the surface's manifest
+ *   already, so the builder declares nothing of its own. A large dataset bound
+ *   with `Data.bindPaged` is never downloaded whole: a query runs on e3.
+ * - **The pane**, before the results, has the tabs Query — the steps or the
+ *   jq — Datasets and Library.
+ * - **Every edit is a draft** of the shared editing session, one per open
+ *   query, which the history item in the one toolbar undoes, redoes and
+ *   discards; Apply saves the open query as one patch commit on the record. A
+ *   query saves only once it checks.
+ *
+ * The builder fills its parent's height and draws no border around itself.
+ * It opens `query`, a saved query, when one is named, else a new query on the
+ * first data source. The query open in it is shared by `id` with a
+ * `<Query.Library>`, which opens queries in it.
+ *
+ * @param options - The bound record, the data sources, the query it opens first and the builder's name ({@link QueryBuilderOptions})
+ * @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 builder, for operators: it queries the data sources it is handed, and saves through the record.
+ * export const builder = ui("query_builder", [], 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.Builder queries={saved} datasets={{ orders, customers }} query="Top shipped orders, 2026" />;
+ *     }}</Reactive>
+ * )));
+ * ```
+ */
+declare function createBuilder(options: QueryBuilderOptions): ExprType<UIComponentType>;
+/**
+ * `<Query.Builder>` — the query builder: the open query's steps or its jq,
+ * checked as they are edited, beside its results. See {@link createBuilder}.
+ */
+export declare const QueryBuilder: JsxTag<OptionsProps<typeof createBuilder>>;
+export {};
+//# sourceMappingURL=builder.d.ts.map