@elaraai/e3-ui 1.0.97 → 1.0.99

package/dist/src/plan/nested-read.d.ts

@@ -0,0 +1,3250 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * What a Plan over paged rows reads of their nested series index (#1438): the
+ * seam between the Plan's build and the reader that reads the index a cell at
+ * a time.
+ *
+ * The build says which index, its tiles, the binding it is read through, and
+ * what each series reads of it: each collection's place, the levels its items
+ * are filed at, how its rows shade past the cap, and how its parents read. The
+ * reader hands back, a window at a time, the cells it read, the drafted rows
+ * and the shading; the seam draws the window's rows from them with the same
+ * series and the same East as over inline rows (#1436) — each lean row, or a
+ * drafted row whole in its place, filled with the items read of it (e3's own
+ * fill, which the binding carries), the series run over them, in the index's
+ * order — and a series past the cap shades.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, DictType, FloatType, NullType, OptionType, SetType, StringType, StructType, VariantType, type ValueTypeOf, BlobType, FunctionType, IntegerType } from "@elaraai/east";
+import type { PlanNestedIndex, PlanNestedRead } from "./nested-checks.js";
+/**
+ * One series' read of one collection of its rows' nested series index (#1438).
+ *
+ * @property series - The series' key
+ * @property place - The collection's place in the index: its field names from the row down (`["jobs"]`, `["members", "load"]`)
+ * @property levels - The levels its items are filed at (#1433): every level from the index's tile for items timed
+ *   `{ from, to }`; the tile alone for values and items timed `{ at }`, which are instants
+ * @property shade - How its rows draw past the cap: `booked`, the share of each bucket its items cover (runs, chips);
+ *   `count`, how many touch it (tiles, marks, decisions, a value's element); `fold`, its values folded as the series
+ *   folds them (heat, weight, table, chart)
+ * @property parents - How the series' parent rows read: `subtotals`, by the rollup its fold and aggregate make (a
+ *   table's subtotals, a heat parent's aggregate, a group's strip); `bands`, its subtree's items (a span's rollup);
+ *   none where its parents derive nothing
+ */
+export declare const PlanNestedUseType: StructType<{
+    readonly series: StringType;
+    readonly place: ArrayType<StringType>;
+    readonly levels: ArrayType<VariantType<{
+        readonly day: NullType;
+        readonly week: NullType;
+        readonly month: NullType;
+        readonly quarter: NullType;
+        readonly year: NullType;
+    }>>;
+    readonly shade: VariantType<{
+        readonly booked: NullType;
+        readonly count: NullType;
+        readonly fold: VariantType<{
+            readonly sum: NullType;
+            readonly mean: NullType;
+            readonly min: NullType;
+            readonly max: NullType;
+            readonly last: NullType;
+            readonly count: NullType;
+        }>;
+    }>;
+    readonly parents: OptionType<VariantType<{
+        readonly subtotals: StructType<{
+            readonly fold: VariantType<{
+                readonly sum: NullType;
+                readonly mean: NullType;
+                readonly min: NullType;
+                readonly max: NullType;
+                readonly last: NullType;
+                readonly count: NullType;
+            }>;
+            readonly aggregate: VariantType<{
+                readonly sum: NullType;
+                readonly mean: NullType;
+                readonly min: NullType;
+                readonly max: NullType;
+                readonly count: NullType;
+            }>;
+        }>;
+        readonly bands: NullType;
+    }>>;
+}>;
+/** Type representing {@link PlanNestedUseType}. */
+export type PlanNestedUseType = typeof PlanNestedUseType;
+/**
+ * The rows' shading past the cap (#1438): by the key of the series whose rows
+ * it stands in for, then by the row's path — its entry's key and the keys down
+ * to its node — as East prints the path, its buckets.
+ */
+export declare const PlanNestedShadingType: DictType<StringType, DictType<StringType, ArrayType<StructType<{
+    readonly at: import("@elaraai/east").DateTimeType;
+    readonly value: OptionType<FloatType>;
+}>>>>;
+/** Type representing {@link PlanNestedShadingType}. */
+export type PlanNestedShadingType = typeof PlanNestedShadingType;
+/**
+ * What a Plan over paged rows reads of their nested series index (#1438): the
+ * index, the binding it is read through, its tiles, what each series reads of
+ * it, and the function that draws a window of lean rows with what was read.
+ *
+ * @property index - The nested series index the cells are read through, by name
+ * @property source - The binding they are read through, by its id: the record's, whatever a Slice narrows of it — what
+ *   a reader reads the cells, the drafts' preview (#1437) and the rows by key through
+ * @property tile - The index's finest level
+ * @property summary - The tile it keeps its totals by; none for none
+ * @property uses - What each series reads of it
+ * @property rows - A window's blocks: `(offset, limit, the cells read, the drafted rows by id, the shading)` → the
+ *   window's rows, each lean row — or a drafted row whole in its place — filled with the items the cells hold of it,
+ *   the series run over them, in the index's order, and each row of a series past the cap shaded; `none` while the
+ *   window is in flight. The cells are a beast2 Array of the index's `{ ik, value }` entries, each drafted row a
+ *   beast2 of the record's row.
+ */
+export declare const PlanNestedType: StructType<{
+    readonly index: StringType;
+    readonly source: StringType;
+    readonly tile: VariantType<{
+        readonly day: NullType;
+        readonly week: NullType;
+        readonly month: NullType;
+        readonly quarter: NullType;
+        readonly year: NullType;
+    }>;
+    readonly summary: OptionType<VariantType<{
+        readonly day: NullType;
+        readonly week: NullType;
+        readonly month: NullType;
+        readonly quarter: NullType;
+        readonly year: NullType;
+    }>>;
+    readonly uses: ArrayType<StructType<{
+        readonly series: StringType;
+        readonly place: ArrayType<StringType>;
+        readonly levels: ArrayType<VariantType<{
+            readonly day: NullType;
+            readonly week: NullType;
+            readonly month: NullType;
+            readonly quarter: NullType;
+            readonly year: NullType;
+        }>>;
+        readonly shade: VariantType<{
+            readonly booked: NullType;
+            readonly count: NullType;
+            readonly fold: VariantType<{
+                readonly sum: NullType;
+                readonly mean: NullType;
+                readonly min: NullType;
+                readonly max: NullType;
+                readonly last: NullType;
+                readonly count: NullType;
+            }>;
+        }>;
+        readonly parents: OptionType<VariantType<{
+            readonly subtotals: StructType<{
+                readonly fold: VariantType<{
+                    readonly sum: NullType;
+                    readonly mean: NullType;
+                    readonly min: NullType;
+                    readonly max: NullType;
+                    readonly last: NullType;
+                    readonly count: NullType;
+                }>;
+                readonly aggregate: VariantType<{
+                    readonly sum: NullType;
+                    readonly mean: NullType;
+                    readonly min: NullType;
+                    readonly max: NullType;
+                    readonly count: NullType;
+                }>;
+            }>;
+            readonly bands: NullType;
+        }>>;
+    }>>;
+    readonly rows: FunctionType<[IntegerType, IntegerType, BlobType, DictType<StringType, BlobType>, DictType<StringType, DictType<StringType, ArrayType<StructType<{
+        readonly at: import("@elaraai/east").DateTimeType;
+        readonly value: OptionType<FloatType>;
+    }>>>>], OptionType<ArrayType<StructType<{
+        readonly fixed: import("@elaraai/east").BooleanType;
+        readonly parent: OptionType<VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>>;
+        readonly charts: OptionType<IntegerType>;
+        readonly rows: ArrayType<StructType<{
+            readonly id: VariantType<{
+                readonly entry: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+                readonly section: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+            }>;
+            readonly parent: OptionType<VariantType<{
+                readonly entry: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+                readonly section: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+            }>>;
+            readonly gutter: StructType<{
+                readonly label: StringType;
+                readonly id: import("@elaraai/east").BooleanType;
+                readonly sub: OptionType<StringType>;
+                readonly value: OptionType<StringType>;
+                readonly meta: OptionType<StringType>;
+                readonly stacked: import("@elaraai/east").BooleanType;
+                readonly swatches: ArrayType<StructType<{
+                    readonly color: StringType;
+                    readonly label: StringType;
+                }>>;
+            }>;
+            readonly kind: VariantType<{
+                readonly group: StructType<{
+                    readonly summary: VariantType<{
+                        readonly none: NullType;
+                        readonly cells: VariantType<{
+                            readonly heat: StructType<{
+                                readonly cells: ArrayType<StructType<{
+                                    readonly at: VariantType<{
+                                        readonly time: import("@elaraai/east").DateTimeType;
+                                        readonly number: FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly value: OptionType<FloatType>;
+                                    readonly label: OptionType<StringType>;
+                                }>>;
+                                readonly scale: StructType<{
+                                    readonly min: OptionType<FloatType>;
+                                    readonly max: OptionType<FloatType>;
+                                    readonly warnAt: OptionType<FloatType>;
+                                }>;
+                                readonly fold: VariantType<{
+                                    readonly sum: NullType;
+                                    readonly mean: NullType;
+                                    readonly min: NullType;
+                                    readonly max: NullType;
+                                    readonly last: NullType;
+                                    readonly count: NullType;
+                                }>;
+                                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                            }>;
+                            readonly weight: StructType<{
+                                readonly cells: ArrayType<StructType<{
+                                    readonly at: VariantType<{
+                                        readonly time: import("@elaraai/east").DateTimeType;
+                                        readonly number: FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly fraction: FloatType;
+                                    readonly planned: import("@elaraai/east").BooleanType;
+                                }>>;
+                                readonly fold: VariantType<{
+                                    readonly sum: NullType;
+                                    readonly mean: NullType;
+                                    readonly min: NullType;
+                                    readonly max: NullType;
+                                    readonly last: NullType;
+                                    readonly count: NullType;
+                                }>;
+                                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                            }>;
+                            readonly segments: StructType<{
+                                readonly cells: ArrayType<StructType<{
+                                    readonly at: VariantType<{
+                                        readonly time: import("@elaraai/east").DateTimeType;
+                                        readonly number: FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly segments: ArrayType<StructType<{
+                                        readonly fill: VariantType<{
+                                            readonly brand: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                            readonly slack: NullType;
+                                            readonly free: NullType;
+                                        }>;
+                                        readonly weight: FloatType;
+                                        readonly label: OptionType<StringType>;
+                                    }>>;
+                                }>>;
+                                readonly fold: VariantType<{
+                                    readonly sum: NullType;
+                                    readonly mean: NullType;
+                                    readonly min: NullType;
+                                    readonly max: NullType;
+                                    readonly last: NullType;
+                                    readonly count: NullType;
+                                }>;
+                                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                            }>;
+                        }>;
+                        readonly aggregate: VariantType<{
+                            readonly mean: NullType;
+                            readonly max: NullType;
+                            readonly sum: NullType;
+                        }>;
+                    }>;
+                }>;
+                readonly span: StructType<{
+                    readonly runs: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly start: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly end: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: StringType;
+                        readonly quantity: OptionType<StructType<{
+                            readonly value: FloatType;
+                            readonly unit: OptionType<StringType>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                            readonly text: OptionType<StringType>;
+                        }>>;
+                        readonly state: VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                        readonly status: OptionType<VariantType<{
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly moved: OptionType<IntegerType>;
+                        readonly icon: OptionType<StructType<{
+                            readonly name: StringType;
+                            readonly prefix: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly style: OptionType<StructType<{
+                                readonly size: OptionType<VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<VariantType<{
+                                    readonly brand: NullType;
+                                    readonly gray: NullType;
+                                    readonly red: NullType;
+                                    readonly orange: NullType;
+                                    readonly yellow: NullType;
+                                    readonly green: NullType;
+                                    readonly teal: NullType;
+                                    readonly blue: NullType;
+                                    readonly cyan: NullType;
+                                    readonly purple: NullType;
+                                    readonly pink: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly opacity: OptionType<FloatType>;
+                                readonly borderRadius: OptionType<StringType>;
+                                readonly overflow: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowX: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowY: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly width: OptionType<StringType>;
+                                readonly height: OptionType<StringType>;
+                                readonly minWidth: OptionType<StringType>;
+                                readonly minHeight: OptionType<StringType>;
+                                readonly maxWidth: OptionType<StringType>;
+                                readonly maxHeight: OptionType<StringType>;
+                                readonly padding: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                                readonly margin: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                            }>>;
+                        }>>;
+                    }>>;
+                    readonly decisions: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly at: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly applied: import("@elaraai/east").BooleanType;
+                    }>>;
+                    readonly ports: ArrayType<StructType<{
+                        readonly at: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly rollup: OptionType<VariantType<{
+                        readonly union: NullType;
+                        readonly byStatus: NullType;
+                        readonly sum: NullType;
+                    }>>;
+                }>;
+                readonly buckets: StructType<{
+                    readonly lanes: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly events: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly at: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly lane: OptionType<StringType>;
+                        readonly label: OptionType<StringType>;
+                        readonly icon: OptionType<StructType<{
+                            readonly name: StringType;
+                            readonly prefix: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly style: OptionType<StructType<{
+                                readonly size: OptionType<VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<VariantType<{
+                                    readonly brand: NullType;
+                                    readonly gray: NullType;
+                                    readonly red: NullType;
+                                    readonly orange: NullType;
+                                    readonly yellow: NullType;
+                                    readonly green: NullType;
+                                    readonly teal: NullType;
+                                    readonly blue: NullType;
+                                    readonly cyan: NullType;
+                                    readonly purple: NullType;
+                                    readonly pink: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly opacity: OptionType<FloatType>;
+                                readonly borderRadius: OptionType<StringType>;
+                                readonly overflow: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowX: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowY: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly width: OptionType<StringType>;
+                                readonly height: OptionType<StringType>;
+                                readonly minWidth: OptionType<StringType>;
+                                readonly minHeight: OptionType<StringType>;
+                                readonly maxWidth: OptionType<StringType>;
+                                readonly maxHeight: OptionType<StringType>;
+                                readonly padding: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                                readonly margin: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                            }>>;
+                        }>>;
+                        readonly state: VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                        readonly tone: OptionType<VariantType<{
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly color: OptionType<StringType>;
+                        readonly colorPalette: OptionType<VariantType<{
+                            readonly brand: NullType;
+                            readonly gray: NullType;
+                            readonly red: NullType;
+                            readonly orange: NullType;
+                            readonly yellow: NullType;
+                            readonly green: NullType;
+                            readonly teal: NullType;
+                            readonly blue: NullType;
+                            readonly cyan: NullType;
+                            readonly purple: NullType;
+                            readonly pink: NullType;
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly stretch: OptionType<VariantType<{
+                            readonly horizontal: NullType;
+                            readonly vertical: NullType;
+                            readonly both: NullType;
+                        }>>;
+                        readonly content: OptionType<StructType<{
+                            readonly horizontal: OptionType<VariantType<{
+                                readonly start: NullType;
+                                readonly center: NullType;
+                                readonly end: NullType;
+                            }>>;
+                            readonly vertical: OptionType<VariantType<{
+                                readonly start: NullType;
+                                readonly center: NullType;
+                                readonly end: NullType;
+                            }>>;
+                        }>>;
+                        readonly animation: OptionType<VariantType<{
+                            readonly none: NullType;
+                            readonly pulse: NullType;
+                        }>>;
+                    }>>;
+                    readonly markers: ArrayType<StructType<{
+                        readonly at: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly lane: OptionType<StringType>;
+                        readonly status: VariantType<{
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>;
+                        readonly message: StringType;
+                    }>>;
+                }>;
+                readonly chart: StructType<{
+                    readonly layers: ArrayType<VariantType<{
+                        readonly line: StructType<{
+                            readonly points: ArrayType<StructType<{
+                                readonly t: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: FloatType;
+                            }>>;
+                            readonly axis: VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly breach: OptionType<VariantType<{
+                                readonly above: FloatType;
+                                readonly below: FloatType;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                        }>;
+                        readonly area: StructType<{
+                            readonly points: ArrayType<StructType<{
+                                readonly t: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: FloatType;
+                            }>>;
+                            readonly axis: VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                        }>;
+                        readonly column: StructType<{
+                            readonly points: ArrayType<StructType<{
+                                readonly t: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: FloatType;
+                            }>>;
+                            readonly axis: VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly series: OptionType<StringType>;
+                            readonly breach: OptionType<VariantType<{
+                                readonly above: FloatType;
+                                readonly below: FloatType;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                        }>;
+                        readonly scatter: StructType<{
+                            readonly points: ArrayType<StructType<{
+                                readonly t: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: FloatType;
+                            }>>;
+                            readonly axis: VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                        }>;
+                        readonly band: StructType<{
+                            readonly points: ArrayType<StructType<{
+                                readonly t: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly lo: FloatType;
+                                readonly hi: FloatType;
+                            }>>;
+                            readonly axis: VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                        }>;
+                        readonly refLine: StructType<{
+                            readonly y: FloatType;
+                            readonly axis: VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly label: OptionType<StringType>;
+                        }>;
+                        readonly refBand: StructType<{
+                            readonly from: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly to: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly label: OptionType<StringType>;
+                        }>;
+                        readonly refDot: StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                            readonly axis: VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly label: OptionType<StringType>;
+                        }>;
+                    }>>;
+                    readonly left: OptionType<StructType<{
+                        readonly domain: OptionType<VariantType<{
+                            readonly number: StructType<{
+                                readonly min: FloatType;
+                                readonly max: FloatType;
+                            }>;
+                            readonly time: StructType<{
+                                readonly min: import("@elaraai/east").DateTimeType;
+                                readonly max: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>>;
+                        readonly tickValues: OptionType<VariantType<{
+                            readonly number: ArrayType<FloatType>;
+                            readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
+                        }>>;
+                        readonly format: OptionType<VariantType<{
+                            readonly number: NullType;
+                            readonly currency: StructType<{
+                                readonly code: StringType;
+                                readonly compact: import("@elaraai/east").BooleanType;
+                            }>;
+                            readonly percent: NullType;
+                            readonly compact: NullType;
+                            readonly date: StringType;
+                            readonly time: StringType;
+                            readonly datetime: StringType;
+                        }>>;
+                    }>>;
+                    readonly right: OptionType<StructType<{
+                        readonly domain: OptionType<VariantType<{
+                            readonly number: StructType<{
+                                readonly min: FloatType;
+                                readonly max: FloatType;
+                            }>;
+                            readonly time: StructType<{
+                                readonly min: import("@elaraai/east").DateTimeType;
+                                readonly max: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>>;
+                        readonly tickValues: OptionType<VariantType<{
+                            readonly number: ArrayType<FloatType>;
+                            readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
+                        }>>;
+                        readonly format: OptionType<VariantType<{
+                            readonly number: NullType;
+                            readonly currency: StructType<{
+                                readonly code: StringType;
+                                readonly compact: import("@elaraai/east").BooleanType;
+                            }>;
+                            readonly percent: NullType;
+                            readonly compact: NullType;
+                            readonly date: StringType;
+                            readonly time: StringType;
+                            readonly datetime: StringType;
+                        }>>;
+                    }>>;
+                    readonly height: VariantType<{
+                        readonly spark: NullType;
+                        readonly expanded: NullType;
+                        readonly fixed: StringType;
+                    }>;
+                    readonly expandedHeight: OptionType<StringType>;
+                    readonly expandable: import("@elaraai/east").BooleanType;
+                }>;
+                readonly heat: StructType<{
+                    readonly cells: VariantType<{
+                        readonly heat: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly value: OptionType<FloatType>;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                            readonly scale: StructType<{
+                                readonly min: OptionType<FloatType>;
+                                readonly max: OptionType<FloatType>;
+                                readonly warnAt: OptionType<FloatType>;
+                            }>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                        readonly weight: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly fraction: FloatType;
+                                readonly planned: import("@elaraai/east").BooleanType;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                        readonly segments: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly segments: ArrayType<StructType<{
+                                    readonly fill: VariantType<{
+                                        readonly brand: NullType;
+                                        readonly success: NullType;
+                                        readonly warning: NullType;
+                                        readonly danger: NullType;
+                                        readonly info: NullType;
+                                        readonly neutral: NullType;
+                                        readonly slack: NullType;
+                                        readonly free: NullType;
+                                    }>;
+                                    readonly weight: FloatType;
+                                    readonly label: OptionType<StringType>;
+                                }>>;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                    }>;
+                    readonly aggregate: OptionType<VariantType<{
+                        readonly mean: NullType;
+                        readonly max: NullType;
+                        readonly sum: NullType;
+                    }>>;
+                    readonly scale: OptionType<StructType<{
+                        readonly min: OptionType<FloatType>;
+                        readonly max: OptionType<FloatType>;
+                        readonly warnAt: OptionType<FloatType>;
+                    }>>;
+                }>;
+                readonly table: StructType<{
+                    readonly series: ArrayType<StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly value: OptionType<FloatType>;
+                            readonly text: OptionType<StringType>;
+                            readonly tone: OptionType<VariantType<{
+                                readonly neg: NullType;
+                                readonly muted: NullType;
+                            }>>;
+                        }>>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        readonly tone: OptionType<VariantType<{
+                            readonly neg: NullType;
+                            readonly muted: NullType;
+                        }>>;
+                        readonly strong: import("@elaraai/east").BooleanType;
+                        readonly rollup: import("@elaraai/east").BooleanType;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>>;
+                    readonly split: VariantType<{
+                        readonly horizontal: NullType;
+                        readonly vertical: NullType;
+                    }>;
+                    readonly aggregate: OptionType<VariantType<{
+                        readonly sum: NullType;
+                        readonly mean: NullType;
+                        readonly min: NullType;
+                        readonly max: NullType;
+                        readonly count: NullType;
+                    }>>;
+                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    readonly emphasis: VariantType<{
+                        readonly body: NullType;
+                        readonly header: NullType;
+                        readonly footer: NullType;
+                    }>;
+                }>;
+                readonly cards: StructType<{
+                    readonly chips: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly from: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly to: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: StringType;
+                        readonly state: VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                        readonly icon: OptionType<StructType<{
+                            readonly name: StringType;
+                            readonly prefix: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly style: OptionType<StructType<{
+                                readonly size: OptionType<VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<VariantType<{
+                                    readonly brand: NullType;
+                                    readonly gray: NullType;
+                                    readonly red: NullType;
+                                    readonly orange: NullType;
+                                    readonly yellow: NullType;
+                                    readonly green: NullType;
+                                    readonly teal: NullType;
+                                    readonly blue: NullType;
+                                    readonly cyan: NullType;
+                                    readonly purple: NullType;
+                                    readonly pink: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly opacity: OptionType<FloatType>;
+                                readonly borderRadius: OptionType<StringType>;
+                                readonly overflow: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowX: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowY: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly width: OptionType<StringType>;
+                                readonly height: OptionType<StringType>;
+                                readonly minWidth: OptionType<StringType>;
+                                readonly minHeight: OptionType<StringType>;
+                                readonly maxWidth: OptionType<StringType>;
+                                readonly maxHeight: OptionType<StringType>;
+                                readonly padding: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                                readonly margin: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                            }>>;
+                        }>>;
+                    }>>;
+                }>;
+                readonly events: StructType<{
+                    readonly marks: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly at: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly kind: VariantType<{
+                            readonly milestone: NullType;
+                            readonly decision: StructType<{
+                                readonly applied: import("@elaraai/east").BooleanType;
+                            }>;
+                            readonly exception: NullType;
+                        }>;
+                        readonly icon: OptionType<StructType<{
+                            readonly name: StringType;
+                            readonly prefix: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly style: OptionType<StructType<{
+                                readonly size: OptionType<VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<VariantType<{
+                                    readonly brand: NullType;
+                                    readonly gray: NullType;
+                                    readonly red: NullType;
+                                    readonly orange: NullType;
+                                    readonly yellow: NullType;
+                                    readonly green: NullType;
+                                    readonly teal: NullType;
+                                    readonly blue: NullType;
+                                    readonly cyan: NullType;
+                                    readonly purple: NullType;
+                                    readonly pink: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly opacity: OptionType<FloatType>;
+                                readonly borderRadius: OptionType<StringType>;
+                                readonly overflow: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowX: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly overflowY: OptionType<VariantType<{
+                                    readonly visible: NullType;
+                                    readonly hidden: NullType;
+                                    readonly scroll: NullType;
+                                    readonly auto: NullType;
+                                }>>;
+                                readonly width: OptionType<StringType>;
+                                readonly height: OptionType<StringType>;
+                                readonly minWidth: OptionType<StringType>;
+                                readonly minHeight: OptionType<StringType>;
+                                readonly maxWidth: OptionType<StringType>;
+                                readonly maxHeight: OptionType<StringType>;
+                                readonly padding: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                                readonly margin: OptionType<StructType<{
+                                    readonly top: OptionType<StringType>;
+                                    readonly right: OptionType<StringType>;
+                                    readonly bottom: OptionType<StringType>;
+                                    readonly left: OptionType<StringType>;
+                                }>>;
+                            }>>;
+                        }>>;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                }>;
+            }>;
+            readonly collapsed: import("@elaraai/east").BooleanType;
+            readonly pinned: import("@elaraai/east").BooleanType;
+            readonly height: OptionType<StringType>;
+            readonly status: OptionType<VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+            readonly expand: OptionType<StructType<{
+                readonly height: OptionType<StringType>;
+                readonly axis: VariantType<{
+                    readonly keep: NullType;
+                    readonly dim: NullType;
+                    readonly off: NullType;
+                }>;
+            }>>;
+            readonly edits: StructType<{
+                readonly drop: import("@elaraai/east").BooleanType;
+                readonly move: OptionType<StructType<{
+                    readonly items: StringType;
+                    readonly resize: import("@elaraai/east").BooleanType;
+                }>>;
+                readonly values: ArrayType<StructType<{
+                    readonly position: IntegerType;
+                    readonly whole: import("@elaraai/east").BooleanType;
+                }>>;
+            }>;
+        }>>;
+    }>>>>;
+}>;
+/** Type representing {@link PlanNestedType}. */
+export type PlanNestedType = typeof PlanNestedType;
+/**
+ * Each read by name of a Plan's series, as the seam carries it (#1438): its
+ * place, its levels, how it shades and how its parents read.
+ *
+ * @param reads - What the series read, as the build held them to the index (`checkPlanNested`)
+ * @param index - The index
+ * @returns Each read of items or values, in the series' order
+ */
+export declare function planNestedUses(reads: readonly PlanNestedRead[], index: PlanNestedIndex): ValueTypeOf<ArrayType<PlanNestedUseType>>;
+/**
+ * A window's blocks with the shading in place (#1438), `(blocks, shading, the
+ * keys of the series that draw bars or chips)`: every row of a series the
+ * shading names draws its heat in place of its elements — one whose row it
+ * holds no shading of yet draws none, at the height it will draw it at — the
+ * counts of one series on one scale, the largest it holds. Every other row
+ * stands.
+ */
+export declare const planNestedShaded: import("@elaraai/east").CallableFunctionExpr<[ArrayType<StructType<{
+    readonly fixed: import("@elaraai/east").BooleanType;
+    readonly parent: OptionType<VariantType<{
+        readonly entry: StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+        readonly section: StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+    }>>;
+    readonly charts: OptionType<IntegerType>;
+    readonly rows: ArrayType<StructType<{
+        readonly id: VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>;
+        readonly parent: OptionType<VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>>;
+        readonly gutter: StructType<{
+            readonly label: StringType;
+            readonly id: import("@elaraai/east").BooleanType;
+            readonly sub: OptionType<StringType>;
+            readonly value: OptionType<StringType>;
+            readonly meta: OptionType<StringType>;
+            readonly stacked: import("@elaraai/east").BooleanType;
+            readonly swatches: ArrayType<StructType<{
+                readonly color: StringType;
+                readonly label: StringType;
+            }>>;
+        }>;
+        readonly kind: VariantType<{
+            readonly group: StructType<{
+                readonly summary: VariantType<{
+                    readonly none: NullType;
+                    readonly cells: VariantType<{
+                        readonly heat: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly value: OptionType<FloatType>;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                            readonly scale: StructType<{
+                                readonly min: OptionType<FloatType>;
+                                readonly max: OptionType<FloatType>;
+                                readonly warnAt: OptionType<FloatType>;
+                            }>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                        readonly weight: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly fraction: FloatType;
+                                readonly planned: import("@elaraai/east").BooleanType;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                        readonly segments: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly segments: ArrayType<StructType<{
+                                    readonly fill: VariantType<{
+                                        readonly brand: NullType;
+                                        readonly success: NullType;
+                                        readonly warning: NullType;
+                                        readonly danger: NullType;
+                                        readonly info: NullType;
+                                        readonly neutral: NullType;
+                                        readonly slack: NullType;
+                                        readonly free: NullType;
+                                    }>;
+                                    readonly weight: FloatType;
+                                    readonly label: OptionType<StringType>;
+                                }>>;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                    }>;
+                    readonly aggregate: VariantType<{
+                        readonly mean: NullType;
+                        readonly max: NullType;
+                        readonly sum: NullType;
+                    }>;
+                }>;
+            }>;
+            readonly span: StructType<{
+                readonly runs: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly start: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly end: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: StringType;
+                    readonly quantity: OptionType<StructType<{
+                        readonly value: FloatType;
+                        readonly unit: OptionType<StringType>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        readonly text: OptionType<StringType>;
+                    }>>;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly status: OptionType<VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly moved: OptionType<IntegerType>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                }>>;
+                readonly decisions: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly applied: import("@elaraai/east").BooleanType;
+                }>>;
+                readonly ports: ArrayType<StructType<{
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: OptionType<StringType>;
+                }>>;
+                readonly rollup: OptionType<VariantType<{
+                    readonly union: NullType;
+                    readonly byStatus: NullType;
+                    readonly sum: NullType;
+                }>>;
+            }>;
+            readonly buckets: StructType<{
+                readonly lanes: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly label: OptionType<StringType>;
+                }>>;
+                readonly events: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly lane: OptionType<StringType>;
+                    readonly label: OptionType<StringType>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly tone: OptionType<VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly color: OptionType<StringType>;
+                    readonly colorPalette: OptionType<VariantType<{
+                        readonly brand: NullType;
+                        readonly gray: NullType;
+                        readonly red: NullType;
+                        readonly orange: NullType;
+                        readonly yellow: NullType;
+                        readonly green: NullType;
+                        readonly teal: NullType;
+                        readonly blue: NullType;
+                        readonly cyan: NullType;
+                        readonly purple: NullType;
+                        readonly pink: NullType;
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly stretch: OptionType<VariantType<{
+                        readonly horizontal: NullType;
+                        readonly vertical: NullType;
+                        readonly both: NullType;
+                    }>>;
+                    readonly content: OptionType<StructType<{
+                        readonly horizontal: OptionType<VariantType<{
+                            readonly start: NullType;
+                            readonly center: NullType;
+                            readonly end: NullType;
+                        }>>;
+                        readonly vertical: OptionType<VariantType<{
+                            readonly start: NullType;
+                            readonly center: NullType;
+                            readonly end: NullType;
+                        }>>;
+                    }>>;
+                    readonly animation: OptionType<VariantType<{
+                        readonly none: NullType;
+                        readonly pulse: NullType;
+                    }>>;
+                }>>;
+                readonly markers: ArrayType<StructType<{
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly lane: OptionType<StringType>;
+                    readonly status: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly message: StringType;
+                }>>;
+            }>;
+            readonly chart: StructType<{
+                readonly layers: ArrayType<VariantType<{
+                    readonly line: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly breach: OptionType<VariantType<{
+                            readonly above: FloatType;
+                            readonly below: FloatType;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>;
+                    readonly area: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>;
+                    readonly column: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly series: OptionType<StringType>;
+                        readonly breach: OptionType<VariantType<{
+                            readonly above: FloatType;
+                            readonly below: FloatType;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>;
+                    readonly scatter: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                    }>;
+                    readonly band: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly lo: FloatType;
+                            readonly hi: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                    }>;
+                    readonly refLine: StructType<{
+                        readonly y: FloatType;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                    readonly refBand: StructType<{
+                        readonly from: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly to: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                    readonly refDot: StructType<{
+                        readonly t: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly y: FloatType;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                }>>;
+                readonly left: OptionType<StructType<{
+                    readonly domain: OptionType<VariantType<{
+                        readonly number: StructType<{
+                            readonly min: FloatType;
+                            readonly max: FloatType;
+                        }>;
+                        readonly time: StructType<{
+                            readonly min: import("@elaraai/east").DateTimeType;
+                            readonly max: import("@elaraai/east").DateTimeType;
+                        }>;
+                    }>>;
+                    readonly tickValues: OptionType<VariantType<{
+                        readonly number: ArrayType<FloatType>;
+                        readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
+                    }>>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>>;
+                readonly right: OptionType<StructType<{
+                    readonly domain: OptionType<VariantType<{
+                        readonly number: StructType<{
+                            readonly min: FloatType;
+                            readonly max: FloatType;
+                        }>;
+                        readonly time: StructType<{
+                            readonly min: import("@elaraai/east").DateTimeType;
+                            readonly max: import("@elaraai/east").DateTimeType;
+                        }>;
+                    }>>;
+                    readonly tickValues: OptionType<VariantType<{
+                        readonly number: ArrayType<FloatType>;
+                        readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
+                    }>>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>>;
+                readonly height: VariantType<{
+                    readonly spark: NullType;
+                    readonly expanded: NullType;
+                    readonly fixed: StringType;
+                }>;
+                readonly expandedHeight: OptionType<StringType>;
+                readonly expandable: import("@elaraai/east").BooleanType;
+            }>;
+            readonly heat: StructType<{
+                readonly cells: VariantType<{
+                    readonly heat: StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly value: OptionType<FloatType>;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                        readonly scale: StructType<{
+                            readonly min: OptionType<FloatType>;
+                            readonly max: OptionType<FloatType>;
+                            readonly warnAt: OptionType<FloatType>;
+                        }>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    }>;
+                    readonly weight: StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly fraction: FloatType;
+                            readonly planned: import("@elaraai/east").BooleanType;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    }>;
+                    readonly segments: StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly segments: ArrayType<StructType<{
+                                readonly fill: VariantType<{
+                                    readonly brand: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                    readonly slack: NullType;
+                                    readonly free: NullType;
+                                }>;
+                                readonly weight: FloatType;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    }>;
+                }>;
+                readonly aggregate: OptionType<VariantType<{
+                    readonly mean: NullType;
+                    readonly max: NullType;
+                    readonly sum: NullType;
+                }>>;
+                readonly scale: OptionType<StructType<{
+                    readonly min: OptionType<FloatType>;
+                    readonly max: OptionType<FloatType>;
+                    readonly warnAt: OptionType<FloatType>;
+                }>>;
+            }>;
+            readonly table: StructType<{
+                readonly series: ArrayType<StructType<{
+                    readonly cells: ArrayType<StructType<{
+                        readonly at: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly value: OptionType<FloatType>;
+                        readonly text: OptionType<StringType>;
+                        readonly tone: OptionType<VariantType<{
+                            readonly neg: NullType;
+                            readonly muted: NullType;
+                        }>>;
+                    }>>;
+                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    readonly tone: OptionType<VariantType<{
+                        readonly neg: NullType;
+                        readonly muted: NullType;
+                    }>>;
+                    readonly strong: import("@elaraai/east").BooleanType;
+                    readonly rollup: import("@elaraai/east").BooleanType;
+                    readonly fold: VariantType<{
+                        readonly sum: NullType;
+                        readonly mean: NullType;
+                        readonly min: NullType;
+                        readonly max: NullType;
+                        readonly last: NullType;
+                        readonly count: NullType;
+                    }>;
+                }>>;
+                readonly split: VariantType<{
+                    readonly horizontal: NullType;
+                    readonly vertical: NullType;
+                }>;
+                readonly aggregate: OptionType<VariantType<{
+                    readonly sum: NullType;
+                    readonly mean: NullType;
+                    readonly min: NullType;
+                    readonly max: NullType;
+                    readonly count: NullType;
+                }>>;
+                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                readonly emphasis: VariantType<{
+                    readonly body: NullType;
+                    readonly header: NullType;
+                    readonly footer: NullType;
+                }>;
+            }>;
+            readonly cards: StructType<{
+                readonly chips: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly from: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly to: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: StringType;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                }>>;
+            }>;
+            readonly events: StructType<{
+                readonly marks: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly kind: VariantType<{
+                        readonly milestone: NullType;
+                        readonly decision: StructType<{
+                            readonly applied: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly exception: NullType;
+                    }>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                    readonly label: OptionType<StringType>;
+                }>>;
+            }>;
+        }>;
+        readonly collapsed: import("@elaraai/east").BooleanType;
+        readonly pinned: import("@elaraai/east").BooleanType;
+        readonly height: OptionType<StringType>;
+        readonly status: OptionType<VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>;
+        readonly expand: OptionType<StructType<{
+            readonly height: OptionType<StringType>;
+            readonly axis: VariantType<{
+                readonly keep: NullType;
+                readonly dim: NullType;
+                readonly off: NullType;
+            }>;
+        }>>;
+        readonly edits: StructType<{
+            readonly drop: import("@elaraai/east").BooleanType;
+            readonly move: OptionType<StructType<{
+                readonly items: StringType;
+                readonly resize: import("@elaraai/east").BooleanType;
+            }>>;
+            readonly values: ArrayType<StructType<{
+                readonly position: IntegerType;
+                readonly whole: import("@elaraai/east").BooleanType;
+            }>>;
+        }>;
+    }>>;
+}>>, DictType<StringType, DictType<StringType, ArrayType<StructType<{
+    readonly at: import("@elaraai/east").DateTimeType;
+    readonly value: OptionType<FloatType>;
+}>>>>, SetType<StringType>], ArrayType<StructType<{
+    readonly fixed: import("@elaraai/east").BooleanType;
+    readonly parent: OptionType<VariantType<{
+        readonly entry: StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+        readonly section: StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+    }>>;
+    readonly charts: OptionType<IntegerType>;
+    readonly rows: ArrayType<StructType<{
+        readonly id: VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>;
+        readonly parent: OptionType<VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>>;
+        readonly gutter: StructType<{
+            readonly label: StringType;
+            readonly id: import("@elaraai/east").BooleanType;
+            readonly sub: OptionType<StringType>;
+            readonly value: OptionType<StringType>;
+            readonly meta: OptionType<StringType>;
+            readonly stacked: import("@elaraai/east").BooleanType;
+            readonly swatches: ArrayType<StructType<{
+                readonly color: StringType;
+                readonly label: StringType;
+            }>>;
+        }>;
+        readonly kind: VariantType<{
+            readonly group: StructType<{
+                readonly summary: VariantType<{
+                    readonly none: NullType;
+                    readonly cells: VariantType<{
+                        readonly heat: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly value: OptionType<FloatType>;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                            readonly scale: StructType<{
+                                readonly min: OptionType<FloatType>;
+                                readonly max: OptionType<FloatType>;
+                                readonly warnAt: OptionType<FloatType>;
+                            }>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                        readonly weight: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly fraction: FloatType;
+                                readonly planned: import("@elaraai/east").BooleanType;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                        readonly segments: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly segments: ArrayType<StructType<{
+                                    readonly fill: VariantType<{
+                                        readonly brand: NullType;
+                                        readonly success: NullType;
+                                        readonly warning: NullType;
+                                        readonly danger: NullType;
+                                        readonly info: NullType;
+                                        readonly neutral: NullType;
+                                        readonly slack: NullType;
+                                        readonly free: NullType;
+                                    }>;
+                                    readonly weight: FloatType;
+                                    readonly label: OptionType<StringType>;
+                                }>>;
+                            }>>;
+                            readonly fold: VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly last: NullType;
+                                readonly count: NullType;
+                            }>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                    }>;
+                    readonly aggregate: VariantType<{
+                        readonly mean: NullType;
+                        readonly max: NullType;
+                        readonly sum: NullType;
+                    }>;
+                }>;
+            }>;
+            readonly span: StructType<{
+                readonly runs: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly start: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly end: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: StringType;
+                    readonly quantity: OptionType<StructType<{
+                        readonly value: FloatType;
+                        readonly unit: OptionType<StringType>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        readonly text: OptionType<StringType>;
+                    }>>;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly status: OptionType<VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly moved: OptionType<IntegerType>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                }>>;
+                readonly decisions: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly applied: import("@elaraai/east").BooleanType;
+                }>>;
+                readonly ports: ArrayType<StructType<{
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: OptionType<StringType>;
+                }>>;
+                readonly rollup: OptionType<VariantType<{
+                    readonly union: NullType;
+                    readonly byStatus: NullType;
+                    readonly sum: NullType;
+                }>>;
+            }>;
+            readonly buckets: StructType<{
+                readonly lanes: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly label: OptionType<StringType>;
+                }>>;
+                readonly events: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly lane: OptionType<StringType>;
+                    readonly label: OptionType<StringType>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly tone: OptionType<VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly color: OptionType<StringType>;
+                    readonly colorPalette: OptionType<VariantType<{
+                        readonly brand: NullType;
+                        readonly gray: NullType;
+                        readonly red: NullType;
+                        readonly orange: NullType;
+                        readonly yellow: NullType;
+                        readonly green: NullType;
+                        readonly teal: NullType;
+                        readonly blue: NullType;
+                        readonly cyan: NullType;
+                        readonly purple: NullType;
+                        readonly pink: NullType;
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly stretch: OptionType<VariantType<{
+                        readonly horizontal: NullType;
+                        readonly vertical: NullType;
+                        readonly both: NullType;
+                    }>>;
+                    readonly content: OptionType<StructType<{
+                        readonly horizontal: OptionType<VariantType<{
+                            readonly start: NullType;
+                            readonly center: NullType;
+                            readonly end: NullType;
+                        }>>;
+                        readonly vertical: OptionType<VariantType<{
+                            readonly start: NullType;
+                            readonly center: NullType;
+                            readonly end: NullType;
+                        }>>;
+                    }>>;
+                    readonly animation: OptionType<VariantType<{
+                        readonly none: NullType;
+                        readonly pulse: NullType;
+                    }>>;
+                }>>;
+                readonly markers: ArrayType<StructType<{
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly lane: OptionType<StringType>;
+                    readonly status: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly message: StringType;
+                }>>;
+            }>;
+            readonly chart: StructType<{
+                readonly layers: ArrayType<VariantType<{
+                    readonly line: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly breach: OptionType<VariantType<{
+                            readonly above: FloatType;
+                            readonly below: FloatType;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>;
+                    readonly area: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>;
+                    readonly column: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly series: OptionType<StringType>;
+                        readonly breach: OptionType<VariantType<{
+                            readonly above: FloatType;
+                            readonly below: FloatType;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>;
+                    readonly scatter: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                    }>;
+                    readonly band: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly lo: FloatType;
+                            readonly hi: FloatType;
+                        }>>;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                    }>;
+                    readonly refLine: StructType<{
+                        readonly y: FloatType;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                    readonly refBand: StructType<{
+                        readonly from: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly to: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                    readonly refDot: StructType<{
+                        readonly t: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly y: FloatType;
+                        readonly axis: VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                }>>;
+                readonly left: OptionType<StructType<{
+                    readonly domain: OptionType<VariantType<{
+                        readonly number: StructType<{
+                            readonly min: FloatType;
+                            readonly max: FloatType;
+                        }>;
+                        readonly time: StructType<{
+                            readonly min: import("@elaraai/east").DateTimeType;
+                            readonly max: import("@elaraai/east").DateTimeType;
+                        }>;
+                    }>>;
+                    readonly tickValues: OptionType<VariantType<{
+                        readonly number: ArrayType<FloatType>;
+                        readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
+                    }>>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>>;
+                readonly right: OptionType<StructType<{
+                    readonly domain: OptionType<VariantType<{
+                        readonly number: StructType<{
+                            readonly min: FloatType;
+                            readonly max: FloatType;
+                        }>;
+                        readonly time: StructType<{
+                            readonly min: import("@elaraai/east").DateTimeType;
+                            readonly max: import("@elaraai/east").DateTimeType;
+                        }>;
+                    }>>;
+                    readonly tickValues: OptionType<VariantType<{
+                        readonly number: ArrayType<FloatType>;
+                        readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
+                    }>>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>>;
+                readonly height: VariantType<{
+                    readonly spark: NullType;
+                    readonly expanded: NullType;
+                    readonly fixed: StringType;
+                }>;
+                readonly expandedHeight: OptionType<StringType>;
+                readonly expandable: import("@elaraai/east").BooleanType;
+            }>;
+            readonly heat: StructType<{
+                readonly cells: VariantType<{
+                    readonly heat: StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly value: OptionType<FloatType>;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                        readonly scale: StructType<{
+                            readonly min: OptionType<FloatType>;
+                            readonly max: OptionType<FloatType>;
+                            readonly warnAt: OptionType<FloatType>;
+                        }>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    }>;
+                    readonly weight: StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly fraction: FloatType;
+                            readonly planned: import("@elaraai/east").BooleanType;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    }>;
+                    readonly segments: StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly segments: ArrayType<StructType<{
+                                readonly fill: VariantType<{
+                                    readonly brand: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                    readonly slack: NullType;
+                                    readonly free: NullType;
+                                }>;
+                                readonly weight: FloatType;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    }>;
+                }>;
+                readonly aggregate: OptionType<VariantType<{
+                    readonly mean: NullType;
+                    readonly max: NullType;
+                    readonly sum: NullType;
+                }>>;
+                readonly scale: OptionType<StructType<{
+                    readonly min: OptionType<FloatType>;
+                    readonly max: OptionType<FloatType>;
+                    readonly warnAt: OptionType<FloatType>;
+                }>>;
+            }>;
+            readonly table: StructType<{
+                readonly series: ArrayType<StructType<{
+                    readonly cells: ArrayType<StructType<{
+                        readonly at: VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly value: OptionType<FloatType>;
+                        readonly text: OptionType<StringType>;
+                        readonly tone: OptionType<VariantType<{
+                            readonly neg: NullType;
+                            readonly muted: NullType;
+                        }>>;
+                    }>>;
+                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    readonly tone: OptionType<VariantType<{
+                        readonly neg: NullType;
+                        readonly muted: NullType;
+                    }>>;
+                    readonly strong: import("@elaraai/east").BooleanType;
+                    readonly rollup: import("@elaraai/east").BooleanType;
+                    readonly fold: VariantType<{
+                        readonly sum: NullType;
+                        readonly mean: NullType;
+                        readonly min: NullType;
+                        readonly max: NullType;
+                        readonly last: NullType;
+                        readonly count: NullType;
+                    }>;
+                }>>;
+                readonly split: VariantType<{
+                    readonly horizontal: NullType;
+                    readonly vertical: NullType;
+                }>;
+                readonly aggregate: OptionType<VariantType<{
+                    readonly sum: NullType;
+                    readonly mean: NullType;
+                    readonly min: NullType;
+                    readonly max: NullType;
+                    readonly count: NullType;
+                }>>;
+                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                readonly emphasis: VariantType<{
+                    readonly body: NullType;
+                    readonly header: NullType;
+                    readonly footer: NullType;
+                }>;
+            }>;
+            readonly cards: StructType<{
+                readonly chips: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly from: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly to: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: StringType;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                }>>;
+            }>;
+            readonly events: StructType<{
+                readonly marks: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: VariantType<{
+                        readonly time: import("@elaraai/east").DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly kind: VariantType<{
+                        readonly milestone: NullType;
+                        readonly decision: StructType<{
+                            readonly applied: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly exception: NullType;
+                    }>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: StringType;
+                        readonly prefix: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<FloatType>;
+                            readonly borderRadius: OptionType<StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<StringType>;
+                            readonly height: OptionType<StringType>;
+                            readonly minWidth: OptionType<StringType>;
+                            readonly minHeight: OptionType<StringType>;
+                            readonly maxWidth: OptionType<StringType>;
+                            readonly maxHeight: OptionType<StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<StringType>;
+                                readonly right: OptionType<StringType>;
+                                readonly bottom: OptionType<StringType>;
+                                readonly left: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                    readonly label: OptionType<StringType>;
+                }>>;
+            }>;
+        }>;
+        readonly collapsed: import("@elaraai/east").BooleanType;
+        readonly pinned: import("@elaraai/east").BooleanType;
+        readonly height: OptionType<StringType>;
+        readonly status: OptionType<VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>;
+        readonly expand: OptionType<StructType<{
+            readonly height: OptionType<StringType>;
+            readonly axis: VariantType<{
+                readonly keep: NullType;
+                readonly dim: NullType;
+                readonly off: NullType;
+            }>;
+        }>>;
+        readonly edits: StructType<{
+            readonly drop: import("@elaraai/east").BooleanType;
+            readonly move: OptionType<StructType<{
+                readonly items: StringType;
+                readonly resize: import("@elaraai/east").BooleanType;
+            }>>;
+            readonly values: ArrayType<StructType<{
+                readonly position: IntegerType;
+                readonly whole: import("@elaraai/east").BooleanType;
+            }>>;
+        }>;
+    }>>;
+}>>>;
+//# sourceMappingURL=nested-read.d.ts.map