@elaraai/east-ui 1.0.80 → 1.0.82

package/dist/src/collections/plan/assemble.d.ts

@@ -3,26 +3,112 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /**
- * Row assembly — the shared row envelope (gutter / `makeRow`),
- * subtree normalization and re-parenting, the `.of` accessor override
- * channel, and the group-parent constructor every grouped form shares.
+ * Row assembly (#822) — the ONE row envelope every canvas row is built by
+ * ({@link planRow}), the gutter and expand values, the row streams the kind
+ * factories return, and the re-basing that places a hand-built stream under a
+ * series.
  *
- * Subtrees are KEYED collections (`Dict<String, PlanRow>`), so composition is
- * `union` with an explicit conflict policy rather than `concat`: every step
- * states what happens on a collision instead of one resolver at the end
- * absorbing all of them, and a row can no longer appear twice (#568).
+ * Rows are an ordered stream (`Array<PlanRow>`) with typed ids
+ * ({@link PlanRowIdType}). A kind factory's rows carry PROVISIONAL ids — an
+ * `entry` with no series yet (`series: ""`) whose path is the factory `key`s
+ * that lead to the row — and `Plan.series.rows` names the series and places
+ * them ({@link REBASE_ROWS}).
  *
  * @packageDocumentation
  */
-import { type ExprType, type SubtypeExprOrValue, BooleanType, FunctionType, OptionType, StringType } from "@elaraai/east";
+import { type ExprType, type SubtypeExprOrValue, ArrayType, BooleanType, OptionType, StringType } from "@elaraai/east";
 import { StatusValueType, type StatusValueLiteral } from "../../feedback/status/types.js";
 import { ApprovalStateType, type ApprovalStateLiteral } from "../../contracts/approval.js";
-import { PlanExpandAxisType, type PlanExpandAxisLiteral, PlanExpandType, PlanRowKindType, PlanRowsCollectionType, type PlanRowsValue, type PlanAxisKindLiteral } from "./types.js";
+import { PlanGutterType, PlanExpandAxisType, type PlanExpandAxisLiteral, PlanExpandType, PlanRowIdType, PlanRowKindType, PlanRowType, type PlanRowEditsType, PlanRowsCollectionType, type PlanRowsValue, type PlanAxisKindLiteral } from "./types.js";
+/**
+ * Every field of a row, each given ONCE — the input of {@link planRow}.
+ *
+ * @remarks
+ * The optional `Option` fields are the row's `Option`s themselves (an
+ * accessor's result is a per-row data fact, so presence is too); omitted ⇒
+ * `none`. The two flags default to `false` (#824).
+ */
+export interface PlanRowFields {
+    /** The row's id. */
+    id: SubtypeExprOrValue<PlanRowIdType>;
+    /** The id of the row it nests under (`none` at the top of a stream). */
+    parent: SubtypeExprOrValue<OptionType<PlanRowIdType>>;
+    /** The gutter identity. */
+    gutter: SubtypeExprOrValue<PlanGutterType>;
+    /** The row kind. */
+    kind: SubtypeExprOrValue<PlanRowKindType>;
+    /** Initial collapse of a row with children (default `false`). */
+    collapsed?: SubtypeExprOrValue<BooleanType>;
+    /** Pin above the virtualised body (default `false`). */
+    pinned?: SubtypeExprOrValue<BooleanType>;
+    /** Fixed row-height override (CSS px). */
+    height?: SubtypeExprOrValue<OptionType<StringType>>;
+    /** The gutter status dot. */
+    status?: SubtypeExprOrValue<OptionType<StatusValueType>>;
+    /** The review verdict. */
+    approval?: SubtypeExprOrValue<OptionType<ApprovalStateType>>;
+    /** The expand-in-place declaration. */
+    expand?: SubtypeExprOrValue<OptionType<PlanExpandType>>;
+    /** The gestures the row takes (#880) — none by default. */
+    edits?: SubtypeExprOrValue<PlanRowEditsType>;
+}
+/**
+ * THE row envelope (#822) — an entry's row, a derived parent, a section header,
+ * a hand-built row and a re-based one are all built by this one constructor, so
+ * the row's fields are spelled in exactly one place.
+ *
+ * @remarks
+ * Each field expression appears once in the value it builds. A caller that
+ * needs a value in two fields (an id that is also a child's parent) binds it
+ * first — East has no common-subexpression elimination, so a spliced
+ * expression is evaluated at every use.
+ *
+ * @param f - The row's fields ({@link PlanRowFields})
+ * @returns The row
+ */
+export declare function planRow(f: PlanRowFields): ExprType<PlanRowType>;
+/**
+ * The gutter's fields — the label, and the `Option`s a series reads per entry.
+ *
+ * @property label - The row name
+ * @property id - Render the label as a mono row id
+ * @property sub - The muted sub line
+ * @property value - The right-aligned value slot
+ * @property meta - The group meta line
+ * @property stacked - Two-line layout
+ * @property swatches - Chart legend chips
+ */
+export interface PlanGutterFields {
+    /** The row name. */
+    label: SubtypeExprOrValue<StringType>;
+    /** Render the label as a mono row id. */
+    id?: SubtypeExprOrValue<BooleanType> | boolean;
+    /** The muted sub line — the field's `Option`. */
+    sub?: SubtypeExprOrValue<OptionType<StringType>>;
+    /** The right-aligned value slot — the field's `Option`. */
+    value?: SubtypeExprOrValue<OptionType<StringType>>;
+    /** The group meta line — the field's `Option`. */
+    meta?: SubtypeExprOrValue<OptionType<StringType>>;
+    /** Two-line layout (label over sub). */
+    stacked?: SubtypeExprOrValue<BooleanType> | boolean;
+    /** Chart legend chips. */
+    swatches?: {
+        color: SubtypeExprOrValue<StringType>;
+        label: SubtypeExprOrValue<StringType>;
+    }[];
+}
+/**
+ * Build a gutter value.
+ *
+ * @param f - The gutter's fields ({@link PlanGutterFields})
+ * @returns The gutter
+ */
+export declare function planGutter(f: PlanGutterFields): ExprType<PlanGutterType>;
 /**
  * The gutter + row fields shared by every kind factory (flattened into each
  * factory's input bag).
  *
- * @property key - The row key (stable identity; parent keys reference it)
+ * @property key - The row's key — its path segment (a nested row's path is its parents' keys, then its own)
  * @property label - The gutter name
  * @property id - `true` ⇒ the label renders as a mono row id
  * @property sub - The muted mono sub line
@@ -30,13 +116,15 @@ import { PlanExpandAxisType, type PlanExpandAxisLiteral, PlanExpandType, PlanRow
  * @property meta - The group meta line
  * @property stacked - Two-line gutter layout
  * @property swatches - Chart-series legend chips
+ * @property collapsed - Initial collapse of a row with nested `rows`
  * @property pinned - Pin the row above the virtualised body, under the ruler
  * @property height - Fixed row-height override (px)
  * @property status - The quiet gutter status dot
  * @property approval - The review verdict (review chrome only)
+ * @property expand - The expand-in-place declaration
  */
 export interface PlanRowBaseInput {
-    /** The row key (stable identity; parent keys reference it). */
+    /** The row's key — its path segment. Keys must be unique among a row's siblings. */
     key: SubtypeExprOrValue<StringType>;
     /** The gutter name. */
     label: SubtypeExprOrValue<StringType>;
@@ -55,6 +143,8 @@ export interface PlanRowBaseInput {
         color: SubtypeExprOrValue<StringType>;
         label: SubtypeExprOrValue<StringType>;
     }[];
+    /** Initial collapse of a row with nested `rows` (renderer state thereafter). */
+    collapsed?: SubtypeExprOrValue<BooleanType> | boolean;
     /** Pin the row above the virtualised body, under the ruler. */
     pinned?: SubtypeExprOrValue<BooleanType> | boolean;
     /** Fixed row-height override — a CSS px size (`"48px"`, the shared component-height type). */
@@ -69,7 +159,7 @@ export interface PlanRowBaseInput {
 /**
  * The expand-in-place input (R2) — a pure-data declaration: presence marks
  * the row expandable; the mounted body is the ROOT's `expandRender`
- * resolver, called with the row ref when the control fires.
+ * resolver, called with the row's id when the control fires.
  *
  * @property height - The developer region's minimum height, a CSS px size (renderer default when omitted)
  * @property axis - How the shared grid + now-line run through the focused row's plot (`"keep"` default / `"dim"` / `"off"`)
@@ -80,1276 +170,169 @@ export interface PlanExpandInput {
     /** How the shared grid + now-line run through the focused row's plot (default `"keep"`). */
     axis?: PlanExpandAxisLiteral | SubtypeExprOrValue<PlanExpandAxisType>;
 }
+/** An empty row stream. */
+export declare function emptyRows(): PlanRowsValue;
+/**
+ * One hand-built row as a one-row stream.
+ *
+ * @param base - The row's base input
+ * @param kind - The row's kind
+ * @returns The stream
+ */
+export declare function makeRow(base: PlanRowBaseInput, kind: ExprType<PlanRowKindType>): PlanRowsValue;
+/**
+ * A nested-rows input — a factory result (one row stream) or a TS array of
+ * them, in order. Kinded factory results ({@link PlanRowsValue}) carry their
+ * axis kind through, so a parent takes the union of its children's kinds.
+ *
+ * @typeParam K - The kind inferred from the kinded streams in the input
+ */
+export type PlanRowsInput<K extends PlanAxisKindLiteral = never> = ExprType<PlanRowsCollectionType> | PlanRowsValue<K> | (ExprType<PlanRowsCollectionType> | PlanRowsValue<K>)[];
+/**
+ * Normalize a nested-rows input into ONE stream — the authored siblings
+ * concatenated in order. Accepts any kind (the caller re-brands its result).
+ *
+ * @param input - The nested rows, or none
+ * @returns The stream
+ */
+export declare function normalizeRows(input: PlanRowsInput<PlanAxisKindLiteral> | undefined): PlanRowsValue;
 /**
- * Row composition is LAST WINS — a later copy of a synthesized row (a group
- * parent a second paged window re-emits) replaces the earlier one. Declared
- * once and passed to every `union`, so the policy is stated at each step
- * rather than assumed.
+ * Re-base a row stream — every id and parent id given the `series` and the
+ * `prefix` path, and every row at the top of the stream (`parent: none`)
+ * nested under `parent`.
+ *
+ * @remarks
+ * How a hand-built stream lands on a canvas: `Plan.series.rows` names its
+ * series (the ids were provisional, `series: ""`), a factory's nested `rows:`
+ * are placed under their parent's key, and a stream under an entry is placed
+ * at that entry's path. Reified once and CALLED, so each argument is evaluated
+ * once, and each row is rebuilt by the one envelope ({@link planRow}).
  */
-export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[import("@elaraai/east").StructType<{
-    readonly key: StringType;
-    readonly parent: OptionType<StringType>;
+export declare const REBASE_ROWS: import("@elaraai/east").CallableFunctionExpr<[ArrayType<import("@elaraai/east").StructType<{
+    readonly id: import("@elaraai/east").VariantType<{
+        readonly entry: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+        readonly section: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+    }>;
+    readonly parent: OptionType<import("@elaraai/east").VariantType<{
+        readonly entry: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+        readonly section: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+    }>>;
     readonly gutter: import("@elaraai/east").StructType<{
         readonly label: StringType;
-        readonly id: OptionType<BooleanType>;
+        readonly id: BooleanType;
         readonly sub: OptionType<StringType>;
         readonly value: OptionType<StringType>;
         readonly meta: OptionType<StringType>;
-        readonly stacked: OptionType<BooleanType>;
-        readonly swatches: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+        readonly stacked: BooleanType;
+        readonly swatches: ArrayType<import("@elaraai/east").StructType<{
             readonly color: StringType;
             readonly label: StringType;
         }>>;
     }>;
     readonly kind: import("@elaraai/east").VariantType<{
         readonly group: import("@elaraai/east").StructType<{
-            readonly summary: OptionType<import("@elaraai/east").VariantType<{
-                readonly heat: import("@elaraai/east").StructType<{
-                    readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
+            readonly summary: import("@elaraai/east").VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly cells: import("@elaraai/east").VariantType<{
+                    readonly heat: import("@elaraai/east").StructType<{
+                        readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                            readonly at: import("@elaraai/east").VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly value: OptionType<import("@elaraai/east").FloatType>;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                        readonly scale: import("@elaraai/east").StructType<{
+                            readonly min: OptionType<import("@elaraai/east").FloatType>;
+                            readonly max: OptionType<import("@elaraai/east").FloatType>;
+                            readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
                         }>;
-                        readonly value: OptionType<import("@elaraai/east").FloatType>;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                    readonly min: OptionType<import("@elaraai/east").FloatType>;
-                    readonly max: OptionType<import("@elaraai/east").FloatType>;
-                    readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                }>;
-                readonly weight: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly fraction: import("@elaraai/east").FloatType;
-                    readonly planned: BooleanType;
-                }>>;
-                readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly fill: import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                            readonly slack: import("@elaraai/east").NullType;
-                            readonly free: import("@elaraai/east").NullType;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: import("@elaraai/east").NullType;
+                            readonly mean: import("@elaraai/east").NullType;
+                            readonly min: import("@elaraai/east").NullType;
+                            readonly max: import("@elaraai/east").NullType;
+                            readonly last: import("@elaraai/east").NullType;
+                            readonly count: import("@elaraai/east").NullType;
                         }>;
-                        readonly weight: import("@elaraai/east").FloatType;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                }>>;
-            }>>;
-            readonly summaryAggregate: OptionType<import("@elaraai/east").VariantType<{
-                readonly mean: import("@elaraai/east").NullType;
-                readonly max: import("@elaraai/east").NullType;
-                readonly sum: import("@elaraai/east").NullType;
-            }>>;
-            readonly collapsed: OptionType<BooleanType>;
-        }>;
-        readonly span: import("@elaraai/east").StructType<{
-            readonly runs: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly key: StringType;
-                readonly start: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly end: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly label: StringType;
-                readonly quantity: OptionType<StringType>;
-                readonly qty: OptionType<import("@elaraai/east").FloatType>;
-                readonly state: import("@elaraai/east").VariantType<{
-                    readonly estimated: import("@elaraai/east").NullType;
-                    readonly proposed: import("@elaraai/east").VariantType<{
-                        readonly added: import("@elaraai/east").NullType;
-                        readonly recommended: import("@elaraai/east").NullType;
-                        readonly removed: import("@elaraai/east").NullType;
-                    }>;
-                    readonly confirmed: import("@elaraai/east").NullType;
-                    readonly "in-progress": import("@elaraai/east").NullType;
-                    readonly actual: import("@elaraai/east").NullType;
-                    readonly rejected: import("@elaraai/east").NullType;
-                }>;
-                readonly status: OptionType<import("@elaraai/east").VariantType<{
-                    readonly success: import("@elaraai/east").NullType;
-                    readonly warning: import("@elaraai/east").NullType;
-                    readonly danger: import("@elaraai/east").NullType;
-                    readonly info: import("@elaraai/east").NullType;
-                    readonly neutral: import("@elaraai/east").NullType;
-                }>>;
-                readonly moved: OptionType<import("@elaraai/east").IntegerType>;
-                readonly icon: OptionType<import("@elaraai/east").StructType<{
-                    readonly name: StringType;
-                    readonly prefix: StringType;
-                    readonly label: OptionType<StringType>;
-                    readonly style: OptionType<import("@elaraai/east").StructType<{
-                        readonly size: OptionType<import("@elaraai/east").VariantType<{
-                            readonly xs: import("@elaraai/east").NullType;
-                            readonly sm: import("@elaraai/east").NullType;
-                            readonly md: import("@elaraai/east").NullType;
-                            readonly lg: import("@elaraai/east").NullType;
-                            readonly xl: import("@elaraai/east").NullType;
-                            readonly "2xl": import("@elaraai/east").NullType;
-                        }>>;
-                        readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                            readonly solid: import("@elaraai/east").NullType;
-                            readonly regular: import("@elaraai/east").NullType;
-                            readonly light: import("@elaraai/east").NullType;
-                            readonly thin: import("@elaraai/east").NullType;
-                            readonly brands: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly color: OptionType<StringType>;
-                        readonly background: OptionType<StringType>;
-                        readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly gray: import("@elaraai/east").NullType;
-                            readonly red: import("@elaraai/east").NullType;
-                            readonly orange: import("@elaraai/east").NullType;
-                            readonly yellow: import("@elaraai/east").NullType;
-                            readonly green: import("@elaraai/east").NullType;
-                            readonly teal: import("@elaraai/east").NullType;
-                            readonly blue: import("@elaraai/east").NullType;
-                            readonly cyan: import("@elaraai/east").NullType;
-                            readonly purple: import("@elaraai/east").NullType;
-                            readonly pink: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                        readonly borderRadius: OptionType<StringType>;
-                        readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").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<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                        readonly margin: OptionType<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                    }>>;
-                }>>;
-            }>>;
-            readonly decisions: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly key: StringType;
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly applied: BooleanType;
-            }>>;
-            readonly ports: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly label: OptionType<StringType>;
-            }>>;
-            readonly rollup: OptionType<import("@elaraai/east").VariantType<{
-                readonly union: import("@elaraai/east").NullType;
-                readonly byStatus: import("@elaraai/east").NullType;
-                readonly sum: import("@elaraai/east").NullType;
-            }>>;
-            readonly unit: OptionType<StringType>;
-        }>;
-        readonly buckets: import("@elaraai/east").StructType<{
-            readonly lanes: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly key: StringType;
-                readonly label: OptionType<StringType>;
-            }>>;
-            readonly events: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly key: StringType;
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly lane: OptionType<StringType>;
-                readonly label: OptionType<StringType>;
-                readonly icon: OptionType<import("@elaraai/east").StructType<{
-                    readonly name: StringType;
-                    readonly prefix: StringType;
-                    readonly label: OptionType<StringType>;
-                    readonly style: OptionType<import("@elaraai/east").StructType<{
-                        readonly size: OptionType<import("@elaraai/east").VariantType<{
-                            readonly xs: import("@elaraai/east").NullType;
-                            readonly sm: import("@elaraai/east").NullType;
-                            readonly md: import("@elaraai/east").NullType;
-                            readonly lg: import("@elaraai/east").NullType;
-                            readonly xl: import("@elaraai/east").NullType;
-                            readonly "2xl": import("@elaraai/east").NullType;
-                        }>>;
-                        readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                            readonly solid: import("@elaraai/east").NullType;
-                            readonly regular: import("@elaraai/east").NullType;
-                            readonly light: import("@elaraai/east").NullType;
-                            readonly thin: import("@elaraai/east").NullType;
-                            readonly brands: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly color: OptionType<StringType>;
-                        readonly background: OptionType<StringType>;
-                        readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly gray: import("@elaraai/east").NullType;
-                            readonly red: import("@elaraai/east").NullType;
-                            readonly orange: import("@elaraai/east").NullType;
-                            readonly yellow: import("@elaraai/east").NullType;
-                            readonly green: import("@elaraai/east").NullType;
-                            readonly teal: import("@elaraai/east").NullType;
-                            readonly blue: import("@elaraai/east").NullType;
-                            readonly cyan: import("@elaraai/east").NullType;
-                            readonly purple: import("@elaraai/east").NullType;
-                            readonly pink: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                        readonly borderRadius: OptionType<StringType>;
-                        readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").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<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                        readonly margin: OptionType<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                    }>>;
-                }>>;
-                readonly state: import("@elaraai/east").VariantType<{
-                    readonly estimated: import("@elaraai/east").NullType;
-                    readonly proposed: import("@elaraai/east").VariantType<{
-                        readonly added: import("@elaraai/east").NullType;
-                        readonly recommended: import("@elaraai/east").NullType;
-                        readonly removed: import("@elaraai/east").NullType;
-                    }>;
-                    readonly confirmed: import("@elaraai/east").NullType;
-                    readonly "in-progress": import("@elaraai/east").NullType;
-                    readonly actual: import("@elaraai/east").NullType;
-                    readonly rejected: import("@elaraai/east").NullType;
-                }>;
-                readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                    readonly success: import("@elaraai/east").NullType;
-                    readonly warning: import("@elaraai/east").NullType;
-                    readonly danger: import("@elaraai/east").NullType;
-                    readonly info: import("@elaraai/east").NullType;
-                    readonly neutral: import("@elaraai/east").NullType;
-                }>>;
-                readonly color: OptionType<StringType>;
-                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                    readonly brand: import("@elaraai/east").NullType;
-                    readonly gray: import("@elaraai/east").NullType;
-                    readonly red: import("@elaraai/east").NullType;
-                    readonly orange: import("@elaraai/east").NullType;
-                    readonly yellow: import("@elaraai/east").NullType;
-                    readonly green: import("@elaraai/east").NullType;
-                    readonly teal: import("@elaraai/east").NullType;
-                    readonly blue: import("@elaraai/east").NullType;
-                    readonly cyan: import("@elaraai/east").NullType;
-                    readonly purple: import("@elaraai/east").NullType;
-                    readonly pink: import("@elaraai/east").NullType;
-                    readonly success: import("@elaraai/east").NullType;
-                    readonly warning: import("@elaraai/east").NullType;
-                    readonly danger: import("@elaraai/east").NullType;
-                    readonly info: import("@elaraai/east").NullType;
-                    readonly neutral: import("@elaraai/east").NullType;
-                }>>;
-                readonly stretch: OptionType<import("@elaraai/east").VariantType<{
-                    readonly horizontal: import("@elaraai/east").NullType;
-                    readonly vertical: import("@elaraai/east").NullType;
-                    readonly both: import("@elaraai/east").NullType;
-                }>>;
-                readonly content: OptionType<import("@elaraai/east").StructType<{
-                    readonly horizontal: OptionType<import("@elaraai/east").VariantType<{
-                        readonly start: import("@elaraai/east").NullType;
-                        readonly center: import("@elaraai/east").NullType;
-                        readonly end: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly vertical: OptionType<import("@elaraai/east").VariantType<{
-                        readonly start: import("@elaraai/east").NullType;
-                        readonly center: import("@elaraai/east").NullType;
-                        readonly end: import("@elaraai/east").NullType;
-                    }>>;
-                }>>;
-                readonly animation: OptionType<import("@elaraai/east").VariantType<{
-                    readonly none: import("@elaraai/east").NullType;
-                    readonly pulse: import("@elaraai/east").NullType;
-                }>>;
-            }>>;
-            readonly markers: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly lane: OptionType<StringType>;
-                readonly status: import("@elaraai/east").VariantType<{
-                    readonly success: import("@elaraai/east").NullType;
-                    readonly warning: import("@elaraai/east").NullType;
-                    readonly danger: import("@elaraai/east").NullType;
-                    readonly info: import("@elaraai/east").NullType;
-                    readonly neutral: import("@elaraai/east").NullType;
-                }>;
-                readonly message: StringType;
-            }>>;
-        }>;
-        readonly chart: import("@elaraai/east").StructType<{
-            readonly layers: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
-                readonly line: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly t: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly y: import("@elaraai/east").FloatType;
-                    }>>;
-                    readonly axis: import("@elaraai/east").VariantType<{
-                        readonly left: import("@elaraai/east").NullType;
-                        readonly right: import("@elaraai/east").NullType;
-                    }>;
-                    readonly breach: OptionType<import("@elaraai/east").VariantType<{
-                        readonly above: import("@elaraai/east").FloatType;
-                        readonly below: import("@elaraai/east").FloatType;
-                    }>>;
-                }>;
-                readonly area: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly t: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly y: import("@elaraai/east").FloatType;
-                    }>>;
-                    readonly axis: import("@elaraai/east").VariantType<{
-                        readonly left: import("@elaraai/east").NullType;
-                        readonly right: import("@elaraai/east").NullType;
-                    }>;
-                }>;
-                readonly column: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly t: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly y: import("@elaraai/east").FloatType;
-                    }>>;
-                    readonly axis: import("@elaraai/east").VariantType<{
-                        readonly left: import("@elaraai/east").NullType;
-                        readonly right: import("@elaraai/east").NullType;
-                    }>;
-                    readonly series: OptionType<StringType>;
-                    readonly breach: OptionType<import("@elaraai/east").VariantType<{
-                        readonly above: import("@elaraai/east").FloatType;
-                        readonly below: import("@elaraai/east").FloatType;
-                    }>>;
-                }>;
-                readonly scatter: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly t: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly y: import("@elaraai/east").FloatType;
-                    }>>;
-                    readonly axis: import("@elaraai/east").VariantType<{
-                        readonly left: import("@elaraai/east").NullType;
-                        readonly right: import("@elaraai/east").NullType;
-                    }>;
-                }>;
-                readonly band: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly t: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly lo: import("@elaraai/east").FloatType;
-                        readonly hi: import("@elaraai/east").FloatType;
-                    }>>;
-                    readonly axis: import("@elaraai/east").VariantType<{
-                        readonly left: import("@elaraai/east").NullType;
-                        readonly right: import("@elaraai/east").NullType;
-                    }>;
-                }>;
-                readonly refLine: import("@elaraai/east").StructType<{
-                    readonly y: import("@elaraai/east").FloatType;
-                    readonly axis: import("@elaraai/east").VariantType<{
-                        readonly left: import("@elaraai/east").NullType;
-                        readonly right: import("@elaraai/east").NullType;
-                    }>;
-                    readonly label: OptionType<StringType>;
-                }>;
-                readonly refBand: import("@elaraai/east").StructType<{
-                    readonly from: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly to: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly label: OptionType<StringType>;
-                }>;
-                readonly refDot: import("@elaraai/east").StructType<{
-                    readonly t: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly y: import("@elaraai/east").FloatType;
-                    readonly axis: import("@elaraai/east").VariantType<{
-                        readonly left: import("@elaraai/east").NullType;
-                        readonly right: import("@elaraai/east").NullType;
-                    }>;
-                    readonly label: OptionType<StringType>;
-                }>;
-            }>>;
-            readonly left: OptionType<import("@elaraai/east").StructType<{
-                readonly domain: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").StructType<{
-                        readonly min: import("@elaraai/east").FloatType;
-                        readonly max: import("@elaraai/east").FloatType;
-                    }>;
-                    readonly time: import("@elaraai/east").StructType<{
-                        readonly min: import("@elaraai/east").DateTimeType;
-                        readonly max: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>>;
-                readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").ArrayType<import("@elaraai/east").FloatType>;
-                    readonly time: import("@elaraai/east").ArrayType<import("@elaraai/east").DateTimeType>;
-                }>>;
-                readonly format: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").NullType;
-                    readonly currency: import("@elaraai/east").StructType<{
-                        readonly code: StringType;
-                        readonly compact: BooleanType;
-                    }>;
-                    readonly percent: import("@elaraai/east").NullType;
-                    readonly compact: import("@elaraai/east").NullType;
-                    readonly date: StringType;
-                    readonly time: StringType;
-                    readonly datetime: StringType;
-                }>>;
-            }>>;
-            readonly right: OptionType<import("@elaraai/east").StructType<{
-                readonly domain: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").StructType<{
-                        readonly min: import("@elaraai/east").FloatType;
-                        readonly max: import("@elaraai/east").FloatType;
-                    }>;
-                    readonly time: import("@elaraai/east").StructType<{
-                        readonly min: import("@elaraai/east").DateTimeType;
-                        readonly max: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>>;
-                readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").ArrayType<import("@elaraai/east").FloatType>;
-                    readonly time: import("@elaraai/east").ArrayType<import("@elaraai/east").DateTimeType>;
-                }>>;
-                readonly format: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").NullType;
-                    readonly currency: import("@elaraai/east").StructType<{
-                        readonly code: StringType;
-                        readonly compact: BooleanType;
-                    }>;
-                    readonly percent: import("@elaraai/east").NullType;
-                    readonly compact: import("@elaraai/east").NullType;
-                    readonly date: StringType;
-                    readonly time: StringType;
-                    readonly datetime: StringType;
-                }>>;
-            }>>;
-            readonly height: import("@elaraai/east").VariantType<{
-                readonly spark: import("@elaraai/east").NullType;
-                readonly expanded: import("@elaraai/east").NullType;
-                readonly fixed: StringType;
-            }>;
-            readonly expandedHeight: OptionType<StringType>;
-            readonly expandable: OptionType<BooleanType>;
-        }>;
-        readonly heat: import("@elaraai/east").StructType<{
-            readonly cells: import("@elaraai/east").VariantType<{
-                readonly heat: import("@elaraai/east").StructType<{
-                    readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly value: OptionType<import("@elaraai/east").FloatType>;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                    readonly min: OptionType<import("@elaraai/east").FloatType>;
-                    readonly max: OptionType<import("@elaraai/east").FloatType>;
-                    readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                }>;
-                readonly weight: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly fraction: import("@elaraai/east").FloatType;
-                    readonly planned: BooleanType;
-                }>>;
-                readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly fill: import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                            readonly slack: import("@elaraai/east").NullType;
-                            readonly free: import("@elaraai/east").NullType;
-                        }>;
-                        readonly weight: import("@elaraai/east").FloatType;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                }>>;
-            }>;
-            readonly aggregate: OptionType<import("@elaraai/east").VariantType<{
-                readonly mean: import("@elaraai/east").NullType;
-                readonly max: import("@elaraai/east").NullType;
-                readonly sum: import("@elaraai/east").NullType;
-            }>>;
-        }>;
-        readonly table: import("@elaraai/east").StructType<{
-            readonly series: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly value: OptionType<import("@elaraai/east").FloatType>;
-                    readonly text: OptionType<StringType>;
-                    readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                        readonly neg: import("@elaraai/east").NullType;
-                        readonly muted: import("@elaraai/east").NullType;
-                    }>>;
-                }>>;
-                readonly format: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").StructType<{
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                            readonly auto: import("@elaraai/east").NullType;
-                            readonly never: import("@elaraai/east").NullType;
-                            readonly always: import("@elaraai/east").NullType;
-                            readonly exceptZero: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly currency: import("@elaraai/east").StructType<{
-                        readonly currency: import("@elaraai/east").VariantType<{
-                            readonly USD: import("@elaraai/east").NullType;
-                            readonly EUR: import("@elaraai/east").NullType;
-                            readonly GBP: import("@elaraai/east").NullType;
-                            readonly JPY: import("@elaraai/east").NullType;
-                            readonly CHF: import("@elaraai/east").NullType;
-                            readonly CAD: import("@elaraai/east").NullType;
-                            readonly AUD: import("@elaraai/east").NullType;
-                            readonly NZD: import("@elaraai/east").NullType;
-                            readonly CNY: import("@elaraai/east").NullType;
-                            readonly HKD: import("@elaraai/east").NullType;
-                            readonly SGD: import("@elaraai/east").NullType;
-                            readonly KRW: import("@elaraai/east").NullType;
-                            readonly INR: import("@elaraai/east").NullType;
-                            readonly TWD: import("@elaraai/east").NullType;
-                            readonly THB: import("@elaraai/east").NullType;
-                            readonly MYR: import("@elaraai/east").NullType;
-                            readonly IDR: import("@elaraai/east").NullType;
-                            readonly PHP: import("@elaraai/east").NullType;
-                            readonly VND: import("@elaraai/east").NullType;
-                            readonly SEK: import("@elaraai/east").NullType;
-                            readonly NOK: import("@elaraai/east").NullType;
-                            readonly DKK: import("@elaraai/east").NullType;
-                            readonly PLN: import("@elaraai/east").NullType;
-                            readonly CZK: import("@elaraai/east").NullType;
-                            readonly HUF: import("@elaraai/east").NullType;
-                            readonly RUB: import("@elaraai/east").NullType;
-                            readonly UAH: import("@elaraai/east").NullType;
-                            readonly RON: import("@elaraai/east").NullType;
-                            readonly MXN: import("@elaraai/east").NullType;
-                            readonly BRL: import("@elaraai/east").NullType;
-                            readonly ARS: import("@elaraai/east").NullType;
-                            readonly CLP: import("@elaraai/east").NullType;
-                            readonly COP: import("@elaraai/east").NullType;
-                            readonly PEN: import("@elaraai/east").NullType;
-                            readonly AED: import("@elaraai/east").NullType;
-                            readonly SAR: import("@elaraai/east").NullType;
-                            readonly ILS: import("@elaraai/east").NullType;
-                            readonly ZAR: import("@elaraai/east").NullType;
-                            readonly TRY: import("@elaraai/east").NullType;
-                            readonly EGP: import("@elaraai/east").NullType;
-                            readonly NGN: import("@elaraai/east").NullType;
-                            readonly KES: import("@elaraai/east").NullType;
-                        }>;
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly code: import("@elaraai/east").NullType;
-                            readonly symbol: import("@elaraai/east").NullType;
-                            readonly narrowSymbol: import("@elaraai/east").NullType;
-                            readonly name: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly compact: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    }>;
-                    readonly percent: import("@elaraai/east").StructType<{
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                            readonly auto: import("@elaraai/east").NullType;
-                            readonly never: import("@elaraai/east").NullType;
-                            readonly always: import("@elaraai/east").NullType;
-                            readonly exceptZero: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly compact: import("@elaraai/east").StructType<{
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly unit: import("@elaraai/east").StructType<{
-                        readonly unit: import("@elaraai/east").VariantType<{
-                            readonly bit: import("@elaraai/east").NullType;
-                            readonly byte: import("@elaraai/east").NullType;
-                            readonly kilobit: import("@elaraai/east").NullType;
-                            readonly kilobyte: import("@elaraai/east").NullType;
-                            readonly megabit: import("@elaraai/east").NullType;
-                            readonly megabyte: import("@elaraai/east").NullType;
-                            readonly gigabit: import("@elaraai/east").NullType;
-                            readonly gigabyte: import("@elaraai/east").NullType;
-                            readonly terabit: import("@elaraai/east").NullType;
-                            readonly terabyte: import("@elaraai/east").NullType;
-                            readonly petabyte: import("@elaraai/east").NullType;
-                            readonly nanosecond: import("@elaraai/east").NullType;
-                            readonly microsecond: import("@elaraai/east").NullType;
-                            readonly millisecond: import("@elaraai/east").NullType;
-                            readonly second: import("@elaraai/east").NullType;
-                            readonly minute: import("@elaraai/east").NullType;
-                            readonly hour: import("@elaraai/east").NullType;
-                            readonly day: import("@elaraai/east").NullType;
-                            readonly week: import("@elaraai/east").NullType;
-                            readonly month: import("@elaraai/east").NullType;
-                            readonly year: import("@elaraai/east").NullType;
-                            readonly millimeter: import("@elaraai/east").NullType;
-                            readonly centimeter: import("@elaraai/east").NullType;
-                            readonly meter: import("@elaraai/east").NullType;
-                            readonly kilometer: import("@elaraai/east").NullType;
-                            readonly inch: import("@elaraai/east").NullType;
-                            readonly foot: import("@elaraai/east").NullType;
-                            readonly yard: import("@elaraai/east").NullType;
-                            readonly mile: import("@elaraai/east").NullType;
-                            readonly gram: import("@elaraai/east").NullType;
-                            readonly kilogram: import("@elaraai/east").NullType;
-                            readonly milligram: import("@elaraai/east").NullType;
-                            readonly ounce: import("@elaraai/east").NullType;
-                            readonly pound: import("@elaraai/east").NullType;
-                            readonly stone: import("@elaraai/east").NullType;
-                            readonly celsius: import("@elaraai/east").NullType;
-                            readonly fahrenheit: import("@elaraai/east").NullType;
-                            readonly milliliter: import("@elaraai/east").NullType;
-                            readonly liter: import("@elaraai/east").NullType;
-                            readonly gallon: import("@elaraai/east").NullType;
-                            readonly fluidOunce: import("@elaraai/east").NullType;
-                            readonly acre: import("@elaraai/east").NullType;
-                            readonly hectare: import("@elaraai/east").NullType;
-                            readonly meterPerSecond: import("@elaraai/east").NullType;
-                            readonly kilometerPerHour: import("@elaraai/east").NullType;
-                            readonly milePerHour: import("@elaraai/east").NullType;
-                            readonly percent: import("@elaraai/east").NullType;
-                            readonly degree: import("@elaraai/east").NullType;
-                        }>;
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly narrow: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly scientific: import("@elaraai/east").NullType;
-                    readonly engineering: import("@elaraai/east").NullType;
-                    readonly date: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                    readonly time: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                    readonly datetime: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                }>>;
-                readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                    readonly neg: import("@elaraai/east").NullType;
-                    readonly muted: import("@elaraai/east").NullType;
-                }>>;
-                readonly strong: OptionType<BooleanType>;
-                readonly rollup: OptionType<BooleanType>;
-            }>>;
-            readonly split: import("@elaraai/east").VariantType<{
-                readonly horizontal: import("@elaraai/east").NullType;
-                readonly vertical: import("@elaraai/east").NullType;
-            }>;
-            readonly aggregate: OptionType<import("@elaraai/east").VariantType<{
-                readonly sum: import("@elaraai/east").NullType;
-                readonly mean: import("@elaraai/east").NullType;
-                readonly min: import("@elaraai/east").NullType;
-                readonly max: import("@elaraai/east").NullType;
-                readonly count: import("@elaraai/east").NullType;
-            }>>;
-            readonly format: OptionType<import("@elaraai/east").VariantType<{
-                readonly number: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly currency: import("@elaraai/east").StructType<{
-                    readonly currency: import("@elaraai/east").VariantType<{
-                        readonly USD: import("@elaraai/east").NullType;
-                        readonly EUR: import("@elaraai/east").NullType;
-                        readonly GBP: import("@elaraai/east").NullType;
-                        readonly JPY: import("@elaraai/east").NullType;
-                        readonly CHF: import("@elaraai/east").NullType;
-                        readonly CAD: import("@elaraai/east").NullType;
-                        readonly AUD: import("@elaraai/east").NullType;
-                        readonly NZD: import("@elaraai/east").NullType;
-                        readonly CNY: import("@elaraai/east").NullType;
-                        readonly HKD: import("@elaraai/east").NullType;
-                        readonly SGD: import("@elaraai/east").NullType;
-                        readonly KRW: import("@elaraai/east").NullType;
-                        readonly INR: import("@elaraai/east").NullType;
-                        readonly TWD: import("@elaraai/east").NullType;
-                        readonly THB: import("@elaraai/east").NullType;
-                        readonly MYR: import("@elaraai/east").NullType;
-                        readonly IDR: import("@elaraai/east").NullType;
-                        readonly PHP: import("@elaraai/east").NullType;
-                        readonly VND: import("@elaraai/east").NullType;
-                        readonly SEK: import("@elaraai/east").NullType;
-                        readonly NOK: import("@elaraai/east").NullType;
-                        readonly DKK: import("@elaraai/east").NullType;
-                        readonly PLN: import("@elaraai/east").NullType;
-                        readonly CZK: import("@elaraai/east").NullType;
-                        readonly HUF: import("@elaraai/east").NullType;
-                        readonly RUB: import("@elaraai/east").NullType;
-                        readonly UAH: import("@elaraai/east").NullType;
-                        readonly RON: import("@elaraai/east").NullType;
-                        readonly MXN: import("@elaraai/east").NullType;
-                        readonly BRL: import("@elaraai/east").NullType;
-                        readonly ARS: import("@elaraai/east").NullType;
-                        readonly CLP: import("@elaraai/east").NullType;
-                        readonly COP: import("@elaraai/east").NullType;
-                        readonly PEN: import("@elaraai/east").NullType;
-                        readonly AED: import("@elaraai/east").NullType;
-                        readonly SAR: import("@elaraai/east").NullType;
-                        readonly ILS: import("@elaraai/east").NullType;
-                        readonly ZAR: import("@elaraai/east").NullType;
-                        readonly TRY: import("@elaraai/east").NullType;
-                        readonly EGP: import("@elaraai/east").NullType;
-                        readonly NGN: import("@elaraai/east").NullType;
-                        readonly KES: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly code: import("@elaraai/east").NullType;
-                        readonly symbol: import("@elaraai/east").NullType;
-                        readonly narrowSymbol: import("@elaraai/east").NullType;
-                        readonly name: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly compact: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                }>;
-                readonly percent: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly compact: import("@elaraai/east").StructType<{
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly unit: import("@elaraai/east").StructType<{
-                    readonly unit: import("@elaraai/east").VariantType<{
-                        readonly bit: import("@elaraai/east").NullType;
-                        readonly byte: import("@elaraai/east").NullType;
-                        readonly kilobit: import("@elaraai/east").NullType;
-                        readonly kilobyte: import("@elaraai/east").NullType;
-                        readonly megabit: import("@elaraai/east").NullType;
-                        readonly megabyte: import("@elaraai/east").NullType;
-                        readonly gigabit: import("@elaraai/east").NullType;
-                        readonly gigabyte: import("@elaraai/east").NullType;
-                        readonly terabit: import("@elaraai/east").NullType;
-                        readonly terabyte: import("@elaraai/east").NullType;
-                        readonly petabyte: import("@elaraai/east").NullType;
-                        readonly nanosecond: import("@elaraai/east").NullType;
-                        readonly microsecond: import("@elaraai/east").NullType;
-                        readonly millisecond: import("@elaraai/east").NullType;
-                        readonly second: import("@elaraai/east").NullType;
-                        readonly minute: import("@elaraai/east").NullType;
-                        readonly hour: import("@elaraai/east").NullType;
-                        readonly day: import("@elaraai/east").NullType;
-                        readonly week: import("@elaraai/east").NullType;
-                        readonly month: import("@elaraai/east").NullType;
-                        readonly year: import("@elaraai/east").NullType;
-                        readonly millimeter: import("@elaraai/east").NullType;
-                        readonly centimeter: import("@elaraai/east").NullType;
-                        readonly meter: import("@elaraai/east").NullType;
-                        readonly kilometer: import("@elaraai/east").NullType;
-                        readonly inch: import("@elaraai/east").NullType;
-                        readonly foot: import("@elaraai/east").NullType;
-                        readonly yard: import("@elaraai/east").NullType;
-                        readonly mile: import("@elaraai/east").NullType;
-                        readonly gram: import("@elaraai/east").NullType;
-                        readonly kilogram: import("@elaraai/east").NullType;
-                        readonly milligram: import("@elaraai/east").NullType;
-                        readonly ounce: import("@elaraai/east").NullType;
-                        readonly pound: import("@elaraai/east").NullType;
-                        readonly stone: import("@elaraai/east").NullType;
-                        readonly celsius: import("@elaraai/east").NullType;
-                        readonly fahrenheit: import("@elaraai/east").NullType;
-                        readonly milliliter: import("@elaraai/east").NullType;
-                        readonly liter: import("@elaraai/east").NullType;
-                        readonly gallon: import("@elaraai/east").NullType;
-                        readonly fluidOunce: import("@elaraai/east").NullType;
-                        readonly acre: import("@elaraai/east").NullType;
-                        readonly hectare: import("@elaraai/east").NullType;
-                        readonly meterPerSecond: import("@elaraai/east").NullType;
-                        readonly kilometerPerHour: import("@elaraai/east").NullType;
-                        readonly milePerHour: import("@elaraai/east").NullType;
-                        readonly percent: import("@elaraai/east").NullType;
-                        readonly degree: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly narrow: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly scientific: import("@elaraai/east").NullType;
-                readonly engineering: import("@elaraai/east").NullType;
-                readonly date: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly time: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly datetime: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-            }>>;
-            readonly emphasis: import("@elaraai/east").VariantType<{
-                readonly body: import("@elaraai/east").NullType;
-                readonly header: import("@elaraai/east").NullType;
-                readonly footer: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly cards: import("@elaraai/east").StructType<{
-            readonly chips: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly key: StringType;
-                readonly from: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly to: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly label: StringType;
-                readonly state: import("@elaraai/east").VariantType<{
-                    readonly estimated: import("@elaraai/east").NullType;
-                    readonly proposed: import("@elaraai/east").VariantType<{
-                        readonly added: import("@elaraai/east").NullType;
-                        readonly recommended: import("@elaraai/east").NullType;
-                        readonly removed: import("@elaraai/east").NullType;
-                    }>;
-                    readonly confirmed: import("@elaraai/east").NullType;
-                    readonly "in-progress": import("@elaraai/east").NullType;
-                    readonly actual: import("@elaraai/east").NullType;
-                    readonly rejected: import("@elaraai/east").NullType;
-                }>;
-                readonly icon: OptionType<import("@elaraai/east").StructType<{
-                    readonly name: StringType;
-                    readonly prefix: StringType;
-                    readonly label: OptionType<StringType>;
-                    readonly style: OptionType<import("@elaraai/east").StructType<{
-                        readonly size: OptionType<import("@elaraai/east").VariantType<{
-                            readonly xs: import("@elaraai/east").NullType;
-                            readonly sm: import("@elaraai/east").NullType;
-                            readonly md: import("@elaraai/east").NullType;
-                            readonly lg: import("@elaraai/east").NullType;
-                            readonly xl: import("@elaraai/east").NullType;
-                            readonly "2xl": import("@elaraai/east").NullType;
-                        }>>;
-                        readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                            readonly solid: import("@elaraai/east").NullType;
-                            readonly regular: import("@elaraai/east").NullType;
-                            readonly light: import("@elaraai/east").NullType;
-                            readonly thin: import("@elaraai/east").NullType;
-                            readonly brands: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly color: OptionType<StringType>;
-                        readonly background: OptionType<StringType>;
-                        readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly gray: import("@elaraai/east").NullType;
-                            readonly red: import("@elaraai/east").NullType;
-                            readonly orange: import("@elaraai/east").NullType;
-                            readonly yellow: import("@elaraai/east").NullType;
-                            readonly green: import("@elaraai/east").NullType;
-                            readonly teal: import("@elaraai/east").NullType;
-                            readonly blue: import("@elaraai/east").NullType;
-                            readonly cyan: import("@elaraai/east").NullType;
-                            readonly purple: import("@elaraai/east").NullType;
-                            readonly pink: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                        readonly borderRadius: OptionType<StringType>;
-                        readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").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<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                        readonly margin: OptionType<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                    }>>;
-                }>>;
-            }>>;
-        }>;
-        readonly events: import("@elaraai/east").StructType<{
-            readonly marks: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly key: StringType;
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: import("@elaraai/east").DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-                readonly kind: import("@elaraai/east").VariantType<{
-                    readonly milestone: import("@elaraai/east").NullType;
-                    readonly decision: import("@elaraai/east").StructType<{
-                        readonly applied: BooleanType;
-                    }>;
-                    readonly exception: import("@elaraai/east").NullType;
-                }>;
-                readonly icon: OptionType<import("@elaraai/east").StructType<{
-                    readonly name: StringType;
-                    readonly prefix: StringType;
-                    readonly label: OptionType<StringType>;
-                    readonly style: OptionType<import("@elaraai/east").StructType<{
-                        readonly size: OptionType<import("@elaraai/east").VariantType<{
-                            readonly xs: import("@elaraai/east").NullType;
-                            readonly sm: import("@elaraai/east").NullType;
-                            readonly md: import("@elaraai/east").NullType;
-                            readonly lg: import("@elaraai/east").NullType;
-                            readonly xl: import("@elaraai/east").NullType;
-                            readonly "2xl": import("@elaraai/east").NullType;
-                        }>>;
-                        readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                            readonly solid: import("@elaraai/east").NullType;
-                            readonly regular: import("@elaraai/east").NullType;
-                            readonly light: import("@elaraai/east").NullType;
-                            readonly thin: import("@elaraai/east").NullType;
-                            readonly brands: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly color: OptionType<StringType>;
-                        readonly background: OptionType<StringType>;
-                        readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly gray: import("@elaraai/east").NullType;
-                            readonly red: import("@elaraai/east").NullType;
-                            readonly orange: import("@elaraai/east").NullType;
-                            readonly yellow: import("@elaraai/east").NullType;
-                            readonly green: import("@elaraai/east").NullType;
-                            readonly teal: import("@elaraai/east").NullType;
-                            readonly blue: import("@elaraai/east").NullType;
-                            readonly cyan: import("@elaraai/east").NullType;
-                            readonly purple: import("@elaraai/east").NullType;
-                            readonly pink: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                        readonly borderRadius: OptionType<StringType>;
-                        readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: import("@elaraai/east").NullType;
-                            readonly hidden: import("@elaraai/east").NullType;
-                            readonly scroll: import("@elaraai/east").NullType;
-                            readonly auto: import("@elaraai/east").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<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                        readonly margin: OptionType<import("@elaraai/east").StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                    }>>;
-                }>>;
-                readonly label: OptionType<StringType>;
-            }>>;
-        }>;
-    }>;
-    readonly pinned: OptionType<BooleanType>;
-    readonly height: OptionType<StringType>;
-    readonly status: OptionType<import("@elaraai/east").VariantType<{
-        readonly success: import("@elaraai/east").NullType;
-        readonly warning: import("@elaraai/east").NullType;
-        readonly danger: import("@elaraai/east").NullType;
-        readonly info: import("@elaraai/east").NullType;
-        readonly neutral: import("@elaraai/east").NullType;
-    }>>;
-    readonly approval: OptionType<import("@elaraai/east").VariantType<{
-        readonly approved: import("@elaraai/east").NullType;
-        readonly pending: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>>;
-    readonly expand: OptionType<import("@elaraai/east").StructType<{
-        readonly height: OptionType<StringType>;
-        readonly axis: import("@elaraai/east").VariantType<{
-            readonly keep: import("@elaraai/east").NullType;
-            readonly dim: import("@elaraai/east").NullType;
-            readonly off: import("@elaraai/east").NullType;
-        }>;
-    }>>;
-}>, import("@elaraai/east").StructType<{
-    readonly key: StringType;
-    readonly parent: OptionType<StringType>;
-    readonly gutter: import("@elaraai/east").StructType<{
-        readonly label: StringType;
-        readonly id: OptionType<BooleanType>;
-        readonly sub: OptionType<StringType>;
-        readonly value: OptionType<StringType>;
-        readonly meta: OptionType<StringType>;
-        readonly stacked: OptionType<BooleanType>;
-        readonly swatches: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-            readonly color: StringType;
-            readonly label: StringType;
-        }>>;
-    }>;
-    readonly kind: import("@elaraai/east").VariantType<{
-        readonly group: import("@elaraai/east").StructType<{
-            readonly summary: OptionType<import("@elaraai/east").VariantType<{
-                readonly heat: import("@elaraai/east").StructType<{
-                    readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
+                        readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    }>;
+                    readonly weight: import("@elaraai/east").StructType<{
+                        readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                            readonly at: import("@elaraai/east").VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly fraction: import("@elaraai/east").FloatType;
+                            readonly planned: BooleanType;
+                        }>>;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: import("@elaraai/east").NullType;
+                            readonly mean: import("@elaraai/east").NullType;
+                            readonly min: import("@elaraai/east").NullType;
+                            readonly max: import("@elaraai/east").NullType;
+                            readonly last: import("@elaraai/east").NullType;
+                            readonly count: import("@elaraai/east").NullType;
                         }>;
-                        readonly value: OptionType<import("@elaraai/east").FloatType>;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                    readonly min: OptionType<import("@elaraai/east").FloatType>;
-                    readonly max: OptionType<import("@elaraai/east").FloatType>;
-                    readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                }>;
-                readonly weight: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly fraction: import("@elaraai/east").FloatType;
-                    readonly planned: BooleanType;
-                }>>;
-                readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly fill: import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                            readonly slack: import("@elaraai/east").NullType;
-                            readonly free: import("@elaraai/east").NullType;
+                        readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    }>;
+                    readonly segments: import("@elaraai/east").StructType<{
+                        readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                            readonly at: import("@elaraai/east").VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly segments: ArrayType<import("@elaraai/east").StructType<{
+                                readonly fill: import("@elaraai/east").VariantType<{
+                                    readonly brand: import("@elaraai/east").NullType;
+                                    readonly success: import("@elaraai/east").NullType;
+                                    readonly warning: import("@elaraai/east").NullType;
+                                    readonly danger: import("@elaraai/east").NullType;
+                                    readonly info: import("@elaraai/east").NullType;
+                                    readonly neutral: import("@elaraai/east").NullType;
+                                    readonly slack: import("@elaraai/east").NullType;
+                                    readonly free: import("@elaraai/east").NullType;
+                                }>;
+                                readonly weight: import("@elaraai/east").FloatType;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: import("@elaraai/east").NullType;
+                            readonly mean: import("@elaraai/east").NullType;
+                            readonly min: import("@elaraai/east").NullType;
+                            readonly max: import("@elaraai/east").NullType;
+                            readonly last: import("@elaraai/east").NullType;
+                            readonly count: import("@elaraai/east").NullType;
                         }>;
-                        readonly weight: import("@elaraai/east").FloatType;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                }>>;
-            }>>;
-            readonly summaryAggregate: OptionType<import("@elaraai/east").VariantType<{
-                readonly mean: import("@elaraai/east").NullType;
-                readonly max: import("@elaraai/east").NullType;
-                readonly sum: import("@elaraai/east").NullType;
-            }>>;
-            readonly collapsed: OptionType<BooleanType>;
+                        readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    }>;
+                }>;
+                readonly aggregate: import("@elaraai/east").VariantType<{
+                    readonly mean: import("@elaraai/east").NullType;
+                    readonly max: import("@elaraai/east").NullType;
+                    readonly sum: import("@elaraai/east").NullType;
+                }>;
+            }>;
         }>;
         readonly span: import("@elaraai/east").StructType<{
-            readonly runs: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly runs: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly start: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -1362,8 +345,12 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     readonly ordinal: StringType;
                 }>;
                 readonly label: StringType;
-                readonly quantity: OptionType<StringType>;
-                readonly qty: OptionType<import("@elaraai/east").FloatType>;
+                readonly quantity: OptionType<import("@elaraai/east").StructType<{
+                    readonly value: import("@elaraai/east").FloatType;
+                    readonly unit: OptionType<StringType>;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    readonly text: OptionType<StringType>;
+                }>>;
                 readonly state: import("@elaraai/east").VariantType<{
                     readonly estimated: import("@elaraai/east").NullType;
                     readonly proposed: import("@elaraai/east").VariantType<{
@@ -1465,7 +452,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>>;
                 }>>;
             }>>;
-            readonly decisions: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly decisions: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -1474,7 +461,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 }>;
                 readonly applied: BooleanType;
             }>>;
-            readonly ports: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly ports: ArrayType<import("@elaraai/east").StructType<{
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
                     readonly number: import("@elaraai/east").FloatType;
@@ -1487,14 +474,13 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 readonly byStatus: import("@elaraai/east").NullType;
                 readonly sum: import("@elaraai/east").NullType;
             }>>;
-            readonly unit: OptionType<StringType>;
         }>;
         readonly buckets: import("@elaraai/east").StructType<{
-            readonly lanes: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly lanes: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly label: OptionType<StringType>;
             }>>;
-            readonly events: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly events: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -1643,7 +629,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     readonly pulse: import("@elaraai/east").NullType;
                 }>>;
             }>>;
-            readonly markers: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly markers: ArrayType<import("@elaraai/east").StructType<{
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
                     readonly number: import("@elaraai/east").FloatType;
@@ -1661,9 +647,9 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>>;
         }>;
         readonly chart: import("@elaraai/east").StructType<{
-            readonly layers: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly layers: ArrayType<import("@elaraai/east").VariantType<{
                 readonly line: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -1679,9 +665,17 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly above: import("@elaraai/east").FloatType;
                         readonly below: import("@elaraai/east").FloatType;
                     }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
                 }>;
                 readonly area: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -1693,9 +687,17 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly left: import("@elaraai/east").NullType;
                         readonly right: import("@elaraai/east").NullType;
                     }>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
                 }>;
                 readonly column: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -1712,9 +714,17 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly above: import("@elaraai/east").FloatType;
                         readonly below: import("@elaraai/east").FloatType;
                     }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
                 }>;
                 readonly scatter: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -1728,7 +738,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>;
                 }>;
                 readonly band: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -1789,8 +799,8 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>;
                 }>>;
                 readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").ArrayType<import("@elaraai/east").FloatType>;
-                    readonly time: import("@elaraai/east").ArrayType<import("@elaraai/east").DateTimeType>;
+                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                    readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
                 }>>;
                 readonly format: OptionType<import("@elaraai/east").VariantType<{
                     readonly number: import("@elaraai/east").NullType;
@@ -1817,8 +827,8 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>;
                 }>>;
                 readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").ArrayType<import("@elaraai/east").FloatType>;
-                    readonly time: import("@elaraai/east").ArrayType<import("@elaraai/east").DateTimeType>;
+                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                    readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
                 }>>;
                 readonly format: OptionType<import("@elaraai/east").VariantType<{
                     readonly number: import("@elaraai/east").NullType;
@@ -1839,12 +849,12 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 readonly fixed: StringType;
             }>;
             readonly expandedHeight: OptionType<StringType>;
-            readonly expandable: OptionType<BooleanType>;
+            readonly expandable: BooleanType;
         }>;
         readonly heat: import("@elaraai/east").StructType<{
             readonly cells: import("@elaraai/east").VariantType<{
                 readonly heat: import("@elaraai/east").StructType<{
-                    readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly cells: ArrayType<import("@elaraai/east").StructType<{
                         readonly at: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -1853,50 +863,88 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly value: OptionType<import("@elaraai/east").FloatType>;
                         readonly label: OptionType<StringType>;
                     }>>;
-                    readonly min: OptionType<import("@elaraai/east").FloatType>;
-                    readonly max: OptionType<import("@elaraai/east").FloatType>;
-                    readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                }>;
-                readonly weight: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
+                    readonly scale: import("@elaraai/east").StructType<{
+                        readonly min: OptionType<import("@elaraai/east").FloatType>;
+                        readonly max: OptionType<import("@elaraai/east").FloatType>;
+                        readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
                     }>;
-                    readonly fraction: import("@elaraai/east").FloatType;
-                    readonly planned: BooleanType;
-                }>>;
-                readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
                     }>;
-                    readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly fill: import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                            readonly slack: import("@elaraai/east").NullType;
-                            readonly free: import("@elaraai/east").NullType;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                }>;
+                readonly weight: import("@elaraai/east").StructType<{
+                    readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
                         }>;
-                        readonly weight: import("@elaraai/east").FloatType;
-                        readonly label: OptionType<StringType>;
+                        readonly fraction: import("@elaraai/east").FloatType;
+                        readonly planned: BooleanType;
                     }>>;
-                }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                }>;
+                readonly segments: import("@elaraai/east").StructType<{
+                    readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly segments: ArrayType<import("@elaraai/east").StructType<{
+                            readonly fill: import("@elaraai/east").VariantType<{
+                                readonly brand: import("@elaraai/east").NullType;
+                                readonly success: import("@elaraai/east").NullType;
+                                readonly warning: import("@elaraai/east").NullType;
+                                readonly danger: import("@elaraai/east").NullType;
+                                readonly info: import("@elaraai/east").NullType;
+                                readonly neutral: import("@elaraai/east").NullType;
+                                readonly slack: import("@elaraai/east").NullType;
+                                readonly free: import("@elaraai/east").NullType;
+                            }>;
+                            readonly weight: import("@elaraai/east").FloatType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                }>;
             }>;
             readonly aggregate: OptionType<import("@elaraai/east").VariantType<{
                 readonly mean: import("@elaraai/east").NullType;
                 readonly max: import("@elaraai/east").NullType;
                 readonly sum: import("@elaraai/east").NullType;
             }>>;
+            readonly scale: OptionType<import("@elaraai/east").StructType<{
+                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                readonly max: OptionType<import("@elaraai/east").FloatType>;
+                readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+            }>>;
         }>;
         readonly table: import("@elaraai/east").StructType<{
-            readonly series: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly series: ArrayType<import("@elaraai/east").StructType<{
+                readonly cells: ArrayType<import("@elaraai/east").StructType<{
                     readonly at: import("@elaraai/east").VariantType<{
                         readonly time: import("@elaraai/east").DateTimeType;
                         readonly number: import("@elaraai/east").FloatType;
@@ -1909,166 +957,21 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly muted: import("@elaraai/east").NullType;
                     }>>;
                 }>>;
-                readonly format: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").StructType<{
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                            readonly auto: import("@elaraai/east").NullType;
-                            readonly never: import("@elaraai/east").NullType;
-                            readonly always: import("@elaraai/east").NullType;
-                            readonly exceptZero: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly currency: import("@elaraai/east").StructType<{
-                        readonly currency: import("@elaraai/east").VariantType<{
-                            readonly USD: import("@elaraai/east").NullType;
-                            readonly EUR: import("@elaraai/east").NullType;
-                            readonly GBP: import("@elaraai/east").NullType;
-                            readonly JPY: import("@elaraai/east").NullType;
-                            readonly CHF: import("@elaraai/east").NullType;
-                            readonly CAD: import("@elaraai/east").NullType;
-                            readonly AUD: import("@elaraai/east").NullType;
-                            readonly NZD: import("@elaraai/east").NullType;
-                            readonly CNY: import("@elaraai/east").NullType;
-                            readonly HKD: import("@elaraai/east").NullType;
-                            readonly SGD: import("@elaraai/east").NullType;
-                            readonly KRW: import("@elaraai/east").NullType;
-                            readonly INR: import("@elaraai/east").NullType;
-                            readonly TWD: import("@elaraai/east").NullType;
-                            readonly THB: import("@elaraai/east").NullType;
-                            readonly MYR: import("@elaraai/east").NullType;
-                            readonly IDR: import("@elaraai/east").NullType;
-                            readonly PHP: import("@elaraai/east").NullType;
-                            readonly VND: import("@elaraai/east").NullType;
-                            readonly SEK: import("@elaraai/east").NullType;
-                            readonly NOK: import("@elaraai/east").NullType;
-                            readonly DKK: import("@elaraai/east").NullType;
-                            readonly PLN: import("@elaraai/east").NullType;
-                            readonly CZK: import("@elaraai/east").NullType;
-                            readonly HUF: import("@elaraai/east").NullType;
-                            readonly RUB: import("@elaraai/east").NullType;
-                            readonly UAH: import("@elaraai/east").NullType;
-                            readonly RON: import("@elaraai/east").NullType;
-                            readonly MXN: import("@elaraai/east").NullType;
-                            readonly BRL: import("@elaraai/east").NullType;
-                            readonly ARS: import("@elaraai/east").NullType;
-                            readonly CLP: import("@elaraai/east").NullType;
-                            readonly COP: import("@elaraai/east").NullType;
-                            readonly PEN: import("@elaraai/east").NullType;
-                            readonly AED: import("@elaraai/east").NullType;
-                            readonly SAR: import("@elaraai/east").NullType;
-                            readonly ILS: import("@elaraai/east").NullType;
-                            readonly ZAR: import("@elaraai/east").NullType;
-                            readonly TRY: import("@elaraai/east").NullType;
-                            readonly EGP: import("@elaraai/east").NullType;
-                            readonly NGN: import("@elaraai/east").NullType;
-                            readonly KES: import("@elaraai/east").NullType;
-                        }>;
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly code: import("@elaraai/east").NullType;
-                            readonly symbol: import("@elaraai/east").NullType;
-                            readonly narrowSymbol: import("@elaraai/east").NullType;
-                            readonly name: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly compact: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    }>;
-                    readonly percent: import("@elaraai/east").StructType<{
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                            readonly auto: import("@elaraai/east").NullType;
-                            readonly never: import("@elaraai/east").NullType;
-                            readonly always: import("@elaraai/east").NullType;
-                            readonly exceptZero: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly compact: import("@elaraai/east").StructType<{
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly unit: import("@elaraai/east").StructType<{
-                        readonly unit: import("@elaraai/east").VariantType<{
-                            readonly bit: import("@elaraai/east").NullType;
-                            readonly byte: import("@elaraai/east").NullType;
-                            readonly kilobit: import("@elaraai/east").NullType;
-                            readonly kilobyte: import("@elaraai/east").NullType;
-                            readonly megabit: import("@elaraai/east").NullType;
-                            readonly megabyte: import("@elaraai/east").NullType;
-                            readonly gigabit: import("@elaraai/east").NullType;
-                            readonly gigabyte: import("@elaraai/east").NullType;
-                            readonly terabit: import("@elaraai/east").NullType;
-                            readonly terabyte: import("@elaraai/east").NullType;
-                            readonly petabyte: import("@elaraai/east").NullType;
-                            readonly nanosecond: import("@elaraai/east").NullType;
-                            readonly microsecond: import("@elaraai/east").NullType;
-                            readonly millisecond: import("@elaraai/east").NullType;
-                            readonly second: import("@elaraai/east").NullType;
-                            readonly minute: import("@elaraai/east").NullType;
-                            readonly hour: import("@elaraai/east").NullType;
-                            readonly day: import("@elaraai/east").NullType;
-                            readonly week: import("@elaraai/east").NullType;
-                            readonly month: import("@elaraai/east").NullType;
-                            readonly year: import("@elaraai/east").NullType;
-                            readonly millimeter: import("@elaraai/east").NullType;
-                            readonly centimeter: import("@elaraai/east").NullType;
-                            readonly meter: import("@elaraai/east").NullType;
-                            readonly kilometer: import("@elaraai/east").NullType;
-                            readonly inch: import("@elaraai/east").NullType;
-                            readonly foot: import("@elaraai/east").NullType;
-                            readonly yard: import("@elaraai/east").NullType;
-                            readonly mile: import("@elaraai/east").NullType;
-                            readonly gram: import("@elaraai/east").NullType;
-                            readonly kilogram: import("@elaraai/east").NullType;
-                            readonly milligram: import("@elaraai/east").NullType;
-                            readonly ounce: import("@elaraai/east").NullType;
-                            readonly pound: import("@elaraai/east").NullType;
-                            readonly stone: import("@elaraai/east").NullType;
-                            readonly celsius: import("@elaraai/east").NullType;
-                            readonly fahrenheit: import("@elaraai/east").NullType;
-                            readonly milliliter: import("@elaraai/east").NullType;
-                            readonly liter: import("@elaraai/east").NullType;
-                            readonly gallon: import("@elaraai/east").NullType;
-                            readonly fluidOunce: import("@elaraai/east").NullType;
-                            readonly acre: import("@elaraai/east").NullType;
-                            readonly hectare: import("@elaraai/east").NullType;
-                            readonly meterPerSecond: import("@elaraai/east").NullType;
-                            readonly kilometerPerHour: import("@elaraai/east").NullType;
-                            readonly milePerHour: import("@elaraai/east").NullType;
-                            readonly percent: import("@elaraai/east").NullType;
-                            readonly degree: import("@elaraai/east").NullType;
-                        }>;
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly narrow: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly scientific: import("@elaraai/east").NullType;
-                    readonly engineering: import("@elaraai/east").NullType;
-                    readonly date: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                    readonly time: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                    readonly datetime: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                }>>;
+                readonly format: OptionType<import("../../internal.js").TickFormatType>;
                 readonly tone: OptionType<import("@elaraai/east").VariantType<{
                     readonly neg: import("@elaraai/east").NullType;
                     readonly muted: import("@elaraai/east").NullType;
                 }>>;
-                readonly strong: OptionType<BooleanType>;
-                readonly rollup: OptionType<BooleanType>;
+                readonly strong: BooleanType;
+                readonly rollup: BooleanType;
+                readonly fold: import("@elaraai/east").VariantType<{
+                    readonly sum: import("@elaraai/east").NullType;
+                    readonly mean: import("@elaraai/east").NullType;
+                    readonly min: import("@elaraai/east").NullType;
+                    readonly max: import("@elaraai/east").NullType;
+                    readonly last: import("@elaraai/east").NullType;
+                    readonly count: import("@elaraai/east").NullType;
+                }>;
             }>>;
             readonly split: import("@elaraai/east").VariantType<{
                 readonly horizontal: import("@elaraai/east").NullType;
@@ -2081,160 +984,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 readonly max: import("@elaraai/east").NullType;
                 readonly count: import("@elaraai/east").NullType;
             }>>;
-            readonly format: OptionType<import("@elaraai/east").VariantType<{
-                readonly number: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly currency: import("@elaraai/east").StructType<{
-                    readonly currency: import("@elaraai/east").VariantType<{
-                        readonly USD: import("@elaraai/east").NullType;
-                        readonly EUR: import("@elaraai/east").NullType;
-                        readonly GBP: import("@elaraai/east").NullType;
-                        readonly JPY: import("@elaraai/east").NullType;
-                        readonly CHF: import("@elaraai/east").NullType;
-                        readonly CAD: import("@elaraai/east").NullType;
-                        readonly AUD: import("@elaraai/east").NullType;
-                        readonly NZD: import("@elaraai/east").NullType;
-                        readonly CNY: import("@elaraai/east").NullType;
-                        readonly HKD: import("@elaraai/east").NullType;
-                        readonly SGD: import("@elaraai/east").NullType;
-                        readonly KRW: import("@elaraai/east").NullType;
-                        readonly INR: import("@elaraai/east").NullType;
-                        readonly TWD: import("@elaraai/east").NullType;
-                        readonly THB: import("@elaraai/east").NullType;
-                        readonly MYR: import("@elaraai/east").NullType;
-                        readonly IDR: import("@elaraai/east").NullType;
-                        readonly PHP: import("@elaraai/east").NullType;
-                        readonly VND: import("@elaraai/east").NullType;
-                        readonly SEK: import("@elaraai/east").NullType;
-                        readonly NOK: import("@elaraai/east").NullType;
-                        readonly DKK: import("@elaraai/east").NullType;
-                        readonly PLN: import("@elaraai/east").NullType;
-                        readonly CZK: import("@elaraai/east").NullType;
-                        readonly HUF: import("@elaraai/east").NullType;
-                        readonly RUB: import("@elaraai/east").NullType;
-                        readonly UAH: import("@elaraai/east").NullType;
-                        readonly RON: import("@elaraai/east").NullType;
-                        readonly MXN: import("@elaraai/east").NullType;
-                        readonly BRL: import("@elaraai/east").NullType;
-                        readonly ARS: import("@elaraai/east").NullType;
-                        readonly CLP: import("@elaraai/east").NullType;
-                        readonly COP: import("@elaraai/east").NullType;
-                        readonly PEN: import("@elaraai/east").NullType;
-                        readonly AED: import("@elaraai/east").NullType;
-                        readonly SAR: import("@elaraai/east").NullType;
-                        readonly ILS: import("@elaraai/east").NullType;
-                        readonly ZAR: import("@elaraai/east").NullType;
-                        readonly TRY: import("@elaraai/east").NullType;
-                        readonly EGP: import("@elaraai/east").NullType;
-                        readonly NGN: import("@elaraai/east").NullType;
-                        readonly KES: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly code: import("@elaraai/east").NullType;
-                        readonly symbol: import("@elaraai/east").NullType;
-                        readonly narrowSymbol: import("@elaraai/east").NullType;
-                        readonly name: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly compact: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                }>;
-                readonly percent: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly compact: import("@elaraai/east").StructType<{
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly unit: import("@elaraai/east").StructType<{
-                    readonly unit: import("@elaraai/east").VariantType<{
-                        readonly bit: import("@elaraai/east").NullType;
-                        readonly byte: import("@elaraai/east").NullType;
-                        readonly kilobit: import("@elaraai/east").NullType;
-                        readonly kilobyte: import("@elaraai/east").NullType;
-                        readonly megabit: import("@elaraai/east").NullType;
-                        readonly megabyte: import("@elaraai/east").NullType;
-                        readonly gigabit: import("@elaraai/east").NullType;
-                        readonly gigabyte: import("@elaraai/east").NullType;
-                        readonly terabit: import("@elaraai/east").NullType;
-                        readonly terabyte: import("@elaraai/east").NullType;
-                        readonly petabyte: import("@elaraai/east").NullType;
-                        readonly nanosecond: import("@elaraai/east").NullType;
-                        readonly microsecond: import("@elaraai/east").NullType;
-                        readonly millisecond: import("@elaraai/east").NullType;
-                        readonly second: import("@elaraai/east").NullType;
-                        readonly minute: import("@elaraai/east").NullType;
-                        readonly hour: import("@elaraai/east").NullType;
-                        readonly day: import("@elaraai/east").NullType;
-                        readonly week: import("@elaraai/east").NullType;
-                        readonly month: import("@elaraai/east").NullType;
-                        readonly year: import("@elaraai/east").NullType;
-                        readonly millimeter: import("@elaraai/east").NullType;
-                        readonly centimeter: import("@elaraai/east").NullType;
-                        readonly meter: import("@elaraai/east").NullType;
-                        readonly kilometer: import("@elaraai/east").NullType;
-                        readonly inch: import("@elaraai/east").NullType;
-                        readonly foot: import("@elaraai/east").NullType;
-                        readonly yard: import("@elaraai/east").NullType;
-                        readonly mile: import("@elaraai/east").NullType;
-                        readonly gram: import("@elaraai/east").NullType;
-                        readonly kilogram: import("@elaraai/east").NullType;
-                        readonly milligram: import("@elaraai/east").NullType;
-                        readonly ounce: import("@elaraai/east").NullType;
-                        readonly pound: import("@elaraai/east").NullType;
-                        readonly stone: import("@elaraai/east").NullType;
-                        readonly celsius: import("@elaraai/east").NullType;
-                        readonly fahrenheit: import("@elaraai/east").NullType;
-                        readonly milliliter: import("@elaraai/east").NullType;
-                        readonly liter: import("@elaraai/east").NullType;
-                        readonly gallon: import("@elaraai/east").NullType;
-                        readonly fluidOunce: import("@elaraai/east").NullType;
-                        readonly acre: import("@elaraai/east").NullType;
-                        readonly hectare: import("@elaraai/east").NullType;
-                        readonly meterPerSecond: import("@elaraai/east").NullType;
-                        readonly kilometerPerHour: import("@elaraai/east").NullType;
-                        readonly milePerHour: import("@elaraai/east").NullType;
-                        readonly percent: import("@elaraai/east").NullType;
-                        readonly degree: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly narrow: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly scientific: import("@elaraai/east").NullType;
-                readonly engineering: import("@elaraai/east").NullType;
-                readonly date: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly time: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly datetime: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-            }>>;
+            readonly format: OptionType<import("../../internal.js").TickFormatType>;
             readonly emphasis: import("@elaraai/east").VariantType<{
                 readonly body: import("@elaraai/east").NullType;
                 readonly header: import("@elaraai/east").NullType;
@@ -2242,7 +992,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>;
         }>;
         readonly cards: import("@elaraai/east").StructType<{
-            readonly chips: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly chips: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly from: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -2350,7 +1100,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>>;
         }>;
         readonly events: import("@elaraai/east").StructType<{
-            readonly marks: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly marks: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -2448,7 +1198,8 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>>;
         }>;
     }>;
-    readonly pinned: OptionType<BooleanType>;
+    readonly collapsed: BooleanType;
+    readonly pinned: BooleanType;
     readonly height: OptionType<StringType>;
     readonly status: OptionType<import("@elaraai/east").VariantType<{
         readonly success: import("@elaraai/east").NullType;
@@ -2470,78 +1221,148 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             readonly off: import("@elaraai/east").NullType;
         }>;
     }>>;
-}>, StringType], import("@elaraai/east").StructType<{
-    readonly key: StringType;
-    readonly parent: OptionType<StringType>;
+    readonly edits: import("@elaraai/east").StructType<{
+        readonly verdict: BooleanType;
+        readonly drop: BooleanType;
+        readonly move: OptionType<import("@elaraai/east").StructType<{
+            readonly items: StringType;
+            readonly resize: BooleanType;
+        }>>;
+    }>;
+}>>, StringType, ArrayType<StringType>, OptionType<import("@elaraai/east").VariantType<{
+    readonly entry: import("@elaraai/east").StructType<{
+        readonly series: StringType;
+        readonly path: ArrayType<StringType>;
+    }>;
+    readonly section: import("@elaraai/east").StructType<{
+        readonly series: StringType;
+        readonly path: ArrayType<StringType>;
+    }>;
+}>>], ArrayType<import("@elaraai/east").StructType<{
+    readonly id: import("@elaraai/east").VariantType<{
+        readonly entry: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+        readonly section: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+    }>;
+    readonly parent: OptionType<import("@elaraai/east").VariantType<{
+        readonly entry: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+        readonly section: import("@elaraai/east").StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+    }>>;
     readonly gutter: import("@elaraai/east").StructType<{
         readonly label: StringType;
-        readonly id: OptionType<BooleanType>;
+        readonly id: BooleanType;
         readonly sub: OptionType<StringType>;
         readonly value: OptionType<StringType>;
         readonly meta: OptionType<StringType>;
-        readonly stacked: OptionType<BooleanType>;
-        readonly swatches: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+        readonly stacked: BooleanType;
+        readonly swatches: ArrayType<import("@elaraai/east").StructType<{
             readonly color: StringType;
             readonly label: StringType;
         }>>;
     }>;
     readonly kind: import("@elaraai/east").VariantType<{
         readonly group: import("@elaraai/east").StructType<{
-            readonly summary: OptionType<import("@elaraai/east").VariantType<{
-                readonly heat: import("@elaraai/east").StructType<{
-                    readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
+            readonly summary: import("@elaraai/east").VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly cells: import("@elaraai/east").VariantType<{
+                    readonly heat: import("@elaraai/east").StructType<{
+                        readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                            readonly at: import("@elaraai/east").VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly value: OptionType<import("@elaraai/east").FloatType>;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                        readonly scale: import("@elaraai/east").StructType<{
+                            readonly min: OptionType<import("@elaraai/east").FloatType>;
+                            readonly max: OptionType<import("@elaraai/east").FloatType>;
+                            readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
                         }>;
-                        readonly value: OptionType<import("@elaraai/east").FloatType>;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                    readonly min: OptionType<import("@elaraai/east").FloatType>;
-                    readonly max: OptionType<import("@elaraai/east").FloatType>;
-                    readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                }>;
-                readonly weight: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly fraction: import("@elaraai/east").FloatType;
-                    readonly planned: BooleanType;
-                }>>;
-                readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
-                    }>;
-                    readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly fill: import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                            readonly slack: import("@elaraai/east").NullType;
-                            readonly free: import("@elaraai/east").NullType;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: import("@elaraai/east").NullType;
+                            readonly mean: import("@elaraai/east").NullType;
+                            readonly min: import("@elaraai/east").NullType;
+                            readonly max: import("@elaraai/east").NullType;
+                            readonly last: import("@elaraai/east").NullType;
+                            readonly count: import("@elaraai/east").NullType;
                         }>;
-                        readonly weight: import("@elaraai/east").FloatType;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                }>>;
-            }>>;
-            readonly summaryAggregate: OptionType<import("@elaraai/east").VariantType<{
-                readonly mean: import("@elaraai/east").NullType;
-                readonly max: import("@elaraai/east").NullType;
-                readonly sum: import("@elaraai/east").NullType;
-            }>>;
-            readonly collapsed: OptionType<BooleanType>;
+                        readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    }>;
+                    readonly weight: import("@elaraai/east").StructType<{
+                        readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                            readonly at: import("@elaraai/east").VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly fraction: import("@elaraai/east").FloatType;
+                            readonly planned: BooleanType;
+                        }>>;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: import("@elaraai/east").NullType;
+                            readonly mean: import("@elaraai/east").NullType;
+                            readonly min: import("@elaraai/east").NullType;
+                            readonly max: import("@elaraai/east").NullType;
+                            readonly last: import("@elaraai/east").NullType;
+                            readonly count: import("@elaraai/east").NullType;
+                        }>;
+                        readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    }>;
+                    readonly segments: import("@elaraai/east").StructType<{
+                        readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                            readonly at: import("@elaraai/east").VariantType<{
+                                readonly time: import("@elaraai/east").DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly segments: ArrayType<import("@elaraai/east").StructType<{
+                                readonly fill: import("@elaraai/east").VariantType<{
+                                    readonly brand: import("@elaraai/east").NullType;
+                                    readonly success: import("@elaraai/east").NullType;
+                                    readonly warning: import("@elaraai/east").NullType;
+                                    readonly danger: import("@elaraai/east").NullType;
+                                    readonly info: import("@elaraai/east").NullType;
+                                    readonly neutral: import("@elaraai/east").NullType;
+                                    readonly slack: import("@elaraai/east").NullType;
+                                    readonly free: import("@elaraai/east").NullType;
+                                }>;
+                                readonly weight: import("@elaraai/east").FloatType;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: import("@elaraai/east").NullType;
+                            readonly mean: import("@elaraai/east").NullType;
+                            readonly min: import("@elaraai/east").NullType;
+                            readonly max: import("@elaraai/east").NullType;
+                            readonly last: import("@elaraai/east").NullType;
+                            readonly count: import("@elaraai/east").NullType;
+                        }>;
+                        readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    }>;
+                }>;
+                readonly aggregate: import("@elaraai/east").VariantType<{
+                    readonly mean: import("@elaraai/east").NullType;
+                    readonly max: import("@elaraai/east").NullType;
+                    readonly sum: import("@elaraai/east").NullType;
+                }>;
+            }>;
         }>;
         readonly span: import("@elaraai/east").StructType<{
-            readonly runs: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly runs: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly start: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -2554,8 +1375,12 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     readonly ordinal: StringType;
                 }>;
                 readonly label: StringType;
-                readonly quantity: OptionType<StringType>;
-                readonly qty: OptionType<import("@elaraai/east").FloatType>;
+                readonly quantity: OptionType<import("@elaraai/east").StructType<{
+                    readonly value: import("@elaraai/east").FloatType;
+                    readonly unit: OptionType<StringType>;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                    readonly text: OptionType<StringType>;
+                }>>;
                 readonly state: import("@elaraai/east").VariantType<{
                     readonly estimated: import("@elaraai/east").NullType;
                     readonly proposed: import("@elaraai/east").VariantType<{
@@ -2657,7 +1482,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>>;
                 }>>;
             }>>;
-            readonly decisions: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly decisions: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -2666,7 +1491,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 }>;
                 readonly applied: BooleanType;
             }>>;
-            readonly ports: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly ports: ArrayType<import("@elaraai/east").StructType<{
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
                     readonly number: import("@elaraai/east").FloatType;
@@ -2679,14 +1504,13 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 readonly byStatus: import("@elaraai/east").NullType;
                 readonly sum: import("@elaraai/east").NullType;
             }>>;
-            readonly unit: OptionType<StringType>;
         }>;
         readonly buckets: import("@elaraai/east").StructType<{
-            readonly lanes: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly lanes: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly label: OptionType<StringType>;
             }>>;
-            readonly events: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly events: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -2835,7 +1659,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     readonly pulse: import("@elaraai/east").NullType;
                 }>>;
             }>>;
-            readonly markers: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly markers: ArrayType<import("@elaraai/east").StructType<{
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
                     readonly number: import("@elaraai/east").FloatType;
@@ -2853,9 +1677,9 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>>;
         }>;
         readonly chart: import("@elaraai/east").StructType<{
-            readonly layers: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly layers: ArrayType<import("@elaraai/east").VariantType<{
                 readonly line: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -2871,9 +1695,17 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly above: import("@elaraai/east").FloatType;
                         readonly below: import("@elaraai/east").FloatType;
                     }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
                 }>;
                 readonly area: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -2885,9 +1717,17 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly left: import("@elaraai/east").NullType;
                         readonly right: import("@elaraai/east").NullType;
                     }>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
                 }>;
                 readonly column: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -2904,9 +1744,17 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly above: import("@elaraai/east").FloatType;
                         readonly below: import("@elaraai/east").FloatType;
                     }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
                 }>;
                 readonly scatter: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -2920,7 +1768,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>;
                 }>;
                 readonly band: import("@elaraai/east").StructType<{
-                    readonly points: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
                         readonly t: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -2981,8 +1829,8 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>;
                 }>>;
                 readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").ArrayType<import("@elaraai/east").FloatType>;
-                    readonly time: import("@elaraai/east").ArrayType<import("@elaraai/east").DateTimeType>;
+                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                    readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
                 }>>;
                 readonly format: OptionType<import("@elaraai/east").VariantType<{
                     readonly number: import("@elaraai/east").NullType;
@@ -3009,8 +1857,8 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                     }>;
                 }>>;
                 readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").ArrayType<import("@elaraai/east").FloatType>;
-                    readonly time: import("@elaraai/east").ArrayType<import("@elaraai/east").DateTimeType>;
+                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                    readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
                 }>>;
                 readonly format: OptionType<import("@elaraai/east").VariantType<{
                     readonly number: import("@elaraai/east").NullType;
@@ -3031,12 +1879,12 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 readonly fixed: StringType;
             }>;
             readonly expandedHeight: OptionType<StringType>;
-            readonly expandable: OptionType<BooleanType>;
+            readonly expandable: BooleanType;
         }>;
         readonly heat: import("@elaraai/east").StructType<{
             readonly cells: import("@elaraai/east").VariantType<{
                 readonly heat: import("@elaraai/east").StructType<{
-                    readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    readonly cells: ArrayType<import("@elaraai/east").StructType<{
                         readonly at: import("@elaraai/east").VariantType<{
                             readonly time: import("@elaraai/east").DateTimeType;
                             readonly number: import("@elaraai/east").FloatType;
@@ -3045,50 +1893,88 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly value: OptionType<import("@elaraai/east").FloatType>;
                         readonly label: OptionType<StringType>;
                     }>>;
-                    readonly min: OptionType<import("@elaraai/east").FloatType>;
-                    readonly max: OptionType<import("@elaraai/east").FloatType>;
-                    readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                }>;
-                readonly weight: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
+                    readonly scale: import("@elaraai/east").StructType<{
+                        readonly min: OptionType<import("@elaraai/east").FloatType>;
+                        readonly max: OptionType<import("@elaraai/east").FloatType>;
+                        readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
                     }>;
-                    readonly fraction: import("@elaraai/east").FloatType;
-                    readonly planned: BooleanType;
-                }>>;
-                readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                    readonly at: import("@elaraai/east").VariantType<{
-                        readonly time: import("@elaraai/east").DateTimeType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly ordinal: StringType;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
                     }>;
-                    readonly segments: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                        readonly fill: import("@elaraai/east").VariantType<{
-                            readonly brand: import("@elaraai/east").NullType;
-                            readonly success: import("@elaraai/east").NullType;
-                            readonly warning: import("@elaraai/east").NullType;
-                            readonly danger: import("@elaraai/east").NullType;
-                            readonly info: import("@elaraai/east").NullType;
-                            readonly neutral: import("@elaraai/east").NullType;
-                            readonly slack: import("@elaraai/east").NullType;
-                            readonly free: import("@elaraai/east").NullType;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                }>;
+                readonly weight: import("@elaraai/east").StructType<{
+                    readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
                         }>;
-                        readonly weight: import("@elaraai/east").FloatType;
-                        readonly label: OptionType<StringType>;
+                        readonly fraction: import("@elaraai/east").FloatType;
+                        readonly planned: BooleanType;
                     }>>;
-                }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                }>;
+                readonly segments: import("@elaraai/east").StructType<{
+                    readonly cells: ArrayType<import("@elaraai/east").StructType<{
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: import("@elaraai/east").DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly segments: ArrayType<import("@elaraai/east").StructType<{
+                            readonly fill: import("@elaraai/east").VariantType<{
+                                readonly brand: import("@elaraai/east").NullType;
+                                readonly success: import("@elaraai/east").NullType;
+                                readonly warning: import("@elaraai/east").NullType;
+                                readonly danger: import("@elaraai/east").NullType;
+                                readonly info: import("@elaraai/east").NullType;
+                                readonly neutral: import("@elaraai/east").NullType;
+                                readonly slack: import("@elaraai/east").NullType;
+                                readonly free: import("@elaraai/east").NullType;
+                            }>;
+                            readonly weight: import("@elaraai/east").FloatType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: import("@elaraai/east").NullType;
+                        readonly mean: import("@elaraai/east").NullType;
+                        readonly min: import("@elaraai/east").NullType;
+                        readonly max: import("@elaraai/east").NullType;
+                        readonly last: import("@elaraai/east").NullType;
+                        readonly count: import("@elaraai/east").NullType;
+                    }>;
+                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
+                }>;
             }>;
             readonly aggregate: OptionType<import("@elaraai/east").VariantType<{
                 readonly mean: import("@elaraai/east").NullType;
                 readonly max: import("@elaraai/east").NullType;
                 readonly sum: import("@elaraai/east").NullType;
             }>>;
+            readonly scale: OptionType<import("@elaraai/east").StructType<{
+                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                readonly max: OptionType<import("@elaraai/east").FloatType>;
+                readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+            }>>;
         }>;
         readonly table: import("@elaraai/east").StructType<{
-            readonly series: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
-                readonly cells: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly series: ArrayType<import("@elaraai/east").StructType<{
+                readonly cells: ArrayType<import("@elaraai/east").StructType<{
                     readonly at: import("@elaraai/east").VariantType<{
                         readonly time: import("@elaraai/east").DateTimeType;
                         readonly number: import("@elaraai/east").FloatType;
@@ -3101,166 +1987,21 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                         readonly muted: import("@elaraai/east").NullType;
                     }>>;
                 }>>;
-                readonly format: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: import("@elaraai/east").StructType<{
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                            readonly auto: import("@elaraai/east").NullType;
-                            readonly never: import("@elaraai/east").NullType;
-                            readonly always: import("@elaraai/east").NullType;
-                            readonly exceptZero: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly currency: import("@elaraai/east").StructType<{
-                        readonly currency: import("@elaraai/east").VariantType<{
-                            readonly USD: import("@elaraai/east").NullType;
-                            readonly EUR: import("@elaraai/east").NullType;
-                            readonly GBP: import("@elaraai/east").NullType;
-                            readonly JPY: import("@elaraai/east").NullType;
-                            readonly CHF: import("@elaraai/east").NullType;
-                            readonly CAD: import("@elaraai/east").NullType;
-                            readonly AUD: import("@elaraai/east").NullType;
-                            readonly NZD: import("@elaraai/east").NullType;
-                            readonly CNY: import("@elaraai/east").NullType;
-                            readonly HKD: import("@elaraai/east").NullType;
-                            readonly SGD: import("@elaraai/east").NullType;
-                            readonly KRW: import("@elaraai/east").NullType;
-                            readonly INR: import("@elaraai/east").NullType;
-                            readonly TWD: import("@elaraai/east").NullType;
-                            readonly THB: import("@elaraai/east").NullType;
-                            readonly MYR: import("@elaraai/east").NullType;
-                            readonly IDR: import("@elaraai/east").NullType;
-                            readonly PHP: import("@elaraai/east").NullType;
-                            readonly VND: import("@elaraai/east").NullType;
-                            readonly SEK: import("@elaraai/east").NullType;
-                            readonly NOK: import("@elaraai/east").NullType;
-                            readonly DKK: import("@elaraai/east").NullType;
-                            readonly PLN: import("@elaraai/east").NullType;
-                            readonly CZK: import("@elaraai/east").NullType;
-                            readonly HUF: import("@elaraai/east").NullType;
-                            readonly RUB: import("@elaraai/east").NullType;
-                            readonly UAH: import("@elaraai/east").NullType;
-                            readonly RON: import("@elaraai/east").NullType;
-                            readonly MXN: import("@elaraai/east").NullType;
-                            readonly BRL: import("@elaraai/east").NullType;
-                            readonly ARS: import("@elaraai/east").NullType;
-                            readonly CLP: import("@elaraai/east").NullType;
-                            readonly COP: import("@elaraai/east").NullType;
-                            readonly PEN: import("@elaraai/east").NullType;
-                            readonly AED: import("@elaraai/east").NullType;
-                            readonly SAR: import("@elaraai/east").NullType;
-                            readonly ILS: import("@elaraai/east").NullType;
-                            readonly ZAR: import("@elaraai/east").NullType;
-                            readonly TRY: import("@elaraai/east").NullType;
-                            readonly EGP: import("@elaraai/east").NullType;
-                            readonly NGN: import("@elaraai/east").NullType;
-                            readonly KES: import("@elaraai/east").NullType;
-                        }>;
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly code: import("@elaraai/east").NullType;
-                            readonly symbol: import("@elaraai/east").NullType;
-                            readonly narrowSymbol: import("@elaraai/east").NullType;
-                            readonly name: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly compact: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    }>;
-                    readonly percent: import("@elaraai/east").StructType<{
-                        readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                            readonly auto: import("@elaraai/east").NullType;
-                            readonly never: import("@elaraai/east").NullType;
-                            readonly always: import("@elaraai/east").NullType;
-                            readonly exceptZero: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly compact: import("@elaraai/east").StructType<{
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly unit: import("@elaraai/east").StructType<{
-                        readonly unit: import("@elaraai/east").VariantType<{
-                            readonly bit: import("@elaraai/east").NullType;
-                            readonly byte: import("@elaraai/east").NullType;
-                            readonly kilobit: import("@elaraai/east").NullType;
-                            readonly kilobyte: import("@elaraai/east").NullType;
-                            readonly megabit: import("@elaraai/east").NullType;
-                            readonly megabyte: import("@elaraai/east").NullType;
-                            readonly gigabit: import("@elaraai/east").NullType;
-                            readonly gigabyte: import("@elaraai/east").NullType;
-                            readonly terabit: import("@elaraai/east").NullType;
-                            readonly terabyte: import("@elaraai/east").NullType;
-                            readonly petabyte: import("@elaraai/east").NullType;
-                            readonly nanosecond: import("@elaraai/east").NullType;
-                            readonly microsecond: import("@elaraai/east").NullType;
-                            readonly millisecond: import("@elaraai/east").NullType;
-                            readonly second: import("@elaraai/east").NullType;
-                            readonly minute: import("@elaraai/east").NullType;
-                            readonly hour: import("@elaraai/east").NullType;
-                            readonly day: import("@elaraai/east").NullType;
-                            readonly week: import("@elaraai/east").NullType;
-                            readonly month: import("@elaraai/east").NullType;
-                            readonly year: import("@elaraai/east").NullType;
-                            readonly millimeter: import("@elaraai/east").NullType;
-                            readonly centimeter: import("@elaraai/east").NullType;
-                            readonly meter: import("@elaraai/east").NullType;
-                            readonly kilometer: import("@elaraai/east").NullType;
-                            readonly inch: import("@elaraai/east").NullType;
-                            readonly foot: import("@elaraai/east").NullType;
-                            readonly yard: import("@elaraai/east").NullType;
-                            readonly mile: import("@elaraai/east").NullType;
-                            readonly gram: import("@elaraai/east").NullType;
-                            readonly kilogram: import("@elaraai/east").NullType;
-                            readonly milligram: import("@elaraai/east").NullType;
-                            readonly ounce: import("@elaraai/east").NullType;
-                            readonly pound: import("@elaraai/east").NullType;
-                            readonly stone: import("@elaraai/east").NullType;
-                            readonly celsius: import("@elaraai/east").NullType;
-                            readonly fahrenheit: import("@elaraai/east").NullType;
-                            readonly milliliter: import("@elaraai/east").NullType;
-                            readonly liter: import("@elaraai/east").NullType;
-                            readonly gallon: import("@elaraai/east").NullType;
-                            readonly fluidOunce: import("@elaraai/east").NullType;
-                            readonly acre: import("@elaraai/east").NullType;
-                            readonly hectare: import("@elaraai/east").NullType;
-                            readonly meterPerSecond: import("@elaraai/east").NullType;
-                            readonly kilometerPerHour: import("@elaraai/east").NullType;
-                            readonly milePerHour: import("@elaraai/east").NullType;
-                            readonly percent: import("@elaraai/east").NullType;
-                            readonly degree: import("@elaraai/east").NullType;
-                        }>;
-                        readonly display: OptionType<import("@elaraai/east").VariantType<{
-                            readonly short: import("@elaraai/east").NullType;
-                            readonly narrow: import("@elaraai/east").NullType;
-                            readonly long: import("@elaraai/east").NullType;
-                        }>>;
-                    }>;
-                    readonly scientific: import("@elaraai/east").NullType;
-                    readonly engineering: import("@elaraai/east").NullType;
-                    readonly date: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                    readonly time: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                    readonly datetime: import("@elaraai/east").StructType<{
-                        readonly format: StringType;
-                    }>;
-                }>>;
+                readonly format: OptionType<import("../../internal.js").TickFormatType>;
                 readonly tone: OptionType<import("@elaraai/east").VariantType<{
                     readonly neg: import("@elaraai/east").NullType;
                     readonly muted: import("@elaraai/east").NullType;
                 }>>;
-                readonly strong: OptionType<BooleanType>;
-                readonly rollup: OptionType<BooleanType>;
+                readonly strong: BooleanType;
+                readonly rollup: BooleanType;
+                readonly fold: import("@elaraai/east").VariantType<{
+                    readonly sum: import("@elaraai/east").NullType;
+                    readonly mean: import("@elaraai/east").NullType;
+                    readonly min: import("@elaraai/east").NullType;
+                    readonly max: import("@elaraai/east").NullType;
+                    readonly last: import("@elaraai/east").NullType;
+                    readonly count: import("@elaraai/east").NullType;
+                }>;
             }>>;
             readonly split: import("@elaraai/east").VariantType<{
                 readonly horizontal: import("@elaraai/east").NullType;
@@ -3273,160 +2014,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
                 readonly max: import("@elaraai/east").NullType;
                 readonly count: import("@elaraai/east").NullType;
             }>>;
-            readonly format: OptionType<import("@elaraai/east").VariantType<{
-                readonly number: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly currency: import("@elaraai/east").StructType<{
-                    readonly currency: import("@elaraai/east").VariantType<{
-                        readonly USD: import("@elaraai/east").NullType;
-                        readonly EUR: import("@elaraai/east").NullType;
-                        readonly GBP: import("@elaraai/east").NullType;
-                        readonly JPY: import("@elaraai/east").NullType;
-                        readonly CHF: import("@elaraai/east").NullType;
-                        readonly CAD: import("@elaraai/east").NullType;
-                        readonly AUD: import("@elaraai/east").NullType;
-                        readonly NZD: import("@elaraai/east").NullType;
-                        readonly CNY: import("@elaraai/east").NullType;
-                        readonly HKD: import("@elaraai/east").NullType;
-                        readonly SGD: import("@elaraai/east").NullType;
-                        readonly KRW: import("@elaraai/east").NullType;
-                        readonly INR: import("@elaraai/east").NullType;
-                        readonly TWD: import("@elaraai/east").NullType;
-                        readonly THB: import("@elaraai/east").NullType;
-                        readonly MYR: import("@elaraai/east").NullType;
-                        readonly IDR: import("@elaraai/east").NullType;
-                        readonly PHP: import("@elaraai/east").NullType;
-                        readonly VND: import("@elaraai/east").NullType;
-                        readonly SEK: import("@elaraai/east").NullType;
-                        readonly NOK: import("@elaraai/east").NullType;
-                        readonly DKK: import("@elaraai/east").NullType;
-                        readonly PLN: import("@elaraai/east").NullType;
-                        readonly CZK: import("@elaraai/east").NullType;
-                        readonly HUF: import("@elaraai/east").NullType;
-                        readonly RUB: import("@elaraai/east").NullType;
-                        readonly UAH: import("@elaraai/east").NullType;
-                        readonly RON: import("@elaraai/east").NullType;
-                        readonly MXN: import("@elaraai/east").NullType;
-                        readonly BRL: import("@elaraai/east").NullType;
-                        readonly ARS: import("@elaraai/east").NullType;
-                        readonly CLP: import("@elaraai/east").NullType;
-                        readonly COP: import("@elaraai/east").NullType;
-                        readonly PEN: import("@elaraai/east").NullType;
-                        readonly AED: import("@elaraai/east").NullType;
-                        readonly SAR: import("@elaraai/east").NullType;
-                        readonly ILS: import("@elaraai/east").NullType;
-                        readonly ZAR: import("@elaraai/east").NullType;
-                        readonly TRY: import("@elaraai/east").NullType;
-                        readonly EGP: import("@elaraai/east").NullType;
-                        readonly NGN: import("@elaraai/east").NullType;
-                        readonly KES: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly code: import("@elaraai/east").NullType;
-                        readonly symbol: import("@elaraai/east").NullType;
-                        readonly narrowSymbol: import("@elaraai/east").NullType;
-                        readonly name: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly compact: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                }>;
-                readonly percent: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly compact: import("@elaraai/east").StructType<{
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly unit: import("@elaraai/east").StructType<{
-                    readonly unit: import("@elaraai/east").VariantType<{
-                        readonly bit: import("@elaraai/east").NullType;
-                        readonly byte: import("@elaraai/east").NullType;
-                        readonly kilobit: import("@elaraai/east").NullType;
-                        readonly kilobyte: import("@elaraai/east").NullType;
-                        readonly megabit: import("@elaraai/east").NullType;
-                        readonly megabyte: import("@elaraai/east").NullType;
-                        readonly gigabit: import("@elaraai/east").NullType;
-                        readonly gigabyte: import("@elaraai/east").NullType;
-                        readonly terabit: import("@elaraai/east").NullType;
-                        readonly terabyte: import("@elaraai/east").NullType;
-                        readonly petabyte: import("@elaraai/east").NullType;
-                        readonly nanosecond: import("@elaraai/east").NullType;
-                        readonly microsecond: import("@elaraai/east").NullType;
-                        readonly millisecond: import("@elaraai/east").NullType;
-                        readonly second: import("@elaraai/east").NullType;
-                        readonly minute: import("@elaraai/east").NullType;
-                        readonly hour: import("@elaraai/east").NullType;
-                        readonly day: import("@elaraai/east").NullType;
-                        readonly week: import("@elaraai/east").NullType;
-                        readonly month: import("@elaraai/east").NullType;
-                        readonly year: import("@elaraai/east").NullType;
-                        readonly millimeter: import("@elaraai/east").NullType;
-                        readonly centimeter: import("@elaraai/east").NullType;
-                        readonly meter: import("@elaraai/east").NullType;
-                        readonly kilometer: import("@elaraai/east").NullType;
-                        readonly inch: import("@elaraai/east").NullType;
-                        readonly foot: import("@elaraai/east").NullType;
-                        readonly yard: import("@elaraai/east").NullType;
-                        readonly mile: import("@elaraai/east").NullType;
-                        readonly gram: import("@elaraai/east").NullType;
-                        readonly kilogram: import("@elaraai/east").NullType;
-                        readonly milligram: import("@elaraai/east").NullType;
-                        readonly ounce: import("@elaraai/east").NullType;
-                        readonly pound: import("@elaraai/east").NullType;
-                        readonly stone: import("@elaraai/east").NullType;
-                        readonly celsius: import("@elaraai/east").NullType;
-                        readonly fahrenheit: import("@elaraai/east").NullType;
-                        readonly milliliter: import("@elaraai/east").NullType;
-                        readonly liter: import("@elaraai/east").NullType;
-                        readonly gallon: import("@elaraai/east").NullType;
-                        readonly fluidOunce: import("@elaraai/east").NullType;
-                        readonly acre: import("@elaraai/east").NullType;
-                        readonly hectare: import("@elaraai/east").NullType;
-                        readonly meterPerSecond: import("@elaraai/east").NullType;
-                        readonly kilometerPerHour: import("@elaraai/east").NullType;
-                        readonly milePerHour: import("@elaraai/east").NullType;
-                        readonly percent: import("@elaraai/east").NullType;
-                        readonly degree: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly narrow: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly scientific: import("@elaraai/east").NullType;
-                readonly engineering: import("@elaraai/east").NullType;
-                readonly date: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly time: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly datetime: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-            }>>;
+            readonly format: OptionType<import("../../internal.js").TickFormatType>;
             readonly emphasis: import("@elaraai/east").VariantType<{
                 readonly body: import("@elaraai/east").NullType;
                 readonly header: import("@elaraai/east").NullType;
@@ -3434,7 +2022,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>;
         }>;
         readonly cards: import("@elaraai/east").StructType<{
-            readonly chips: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly chips: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly from: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -3542,7 +2130,7 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>>;
         }>;
         readonly events: import("@elaraai/east").StructType<{
-            readonly marks: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            readonly marks: ArrayType<import("@elaraai/east").StructType<{
                 readonly key: StringType;
                 readonly at: import("@elaraai/east").VariantType<{
                     readonly time: import("@elaraai/east").DateTimeType;
@@ -3640,7 +2228,8 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             }>>;
         }>;
     }>;
-    readonly pinned: OptionType<BooleanType>;
+    readonly collapsed: BooleanType;
+    readonly pinned: BooleanType;
     readonly height: OptionType<StringType>;
     readonly status: OptionType<import("@elaraai/east").VariantType<{
         readonly success: import("@elaraai/east").NullType;
@@ -3662,71 +2251,24 @@ export declare const LAST_WINS: import("@elaraai/east").CallableFunctionExpr<[im
             readonly off: import("@elaraai/east").NullType;
         }>;
     }>>;
-}>>;
-/** Assemble one row from its base input + kind value, as a 1-row subtree.
- *  Keying it HERE is where uniqueness becomes structural: a factory cannot
- *  emit two rows under one key. */
-export declare function makeRow(base: PlanRowBaseInput, kind: ExprType<PlanRowKindType>): PlanRowsValue;
-/**
- * A nested-rows input — a single flattened-subtree expression (a factory /
- * `Plan.rows` result) or a TS array of them. Kinded factory results
- * ({@link PlanRowsValue}) carry their axis kind through, so a parent takes
- * the union of its children's kinds; any other collection value is erased.
- *
- * @typeParam K - The kind inferred from the kinded subtrees in the input
- */
-export type PlanRowsInput<K extends PlanAxisKindLiteral = never> = SubtypeExprOrValue<PlanRowsCollectionType> | PlanRowsValue<K> | (SubtypeExprOrValue<PlanRowsCollectionType> | PlanRowsValue<K>)[];
-/** Normalize a nested-rows input into ONE subtree — the authored siblings
- *  unioned, last wins on a repeated key. Accepts any kind (the caller
- *  re-brands its result). */
-export declare function normalizeRows(input: PlanRowsInput<PlanAxisKindLiteral> | undefined): PlanRowsValue;
-/** Re-parent the ROOTS of a subtree (rows with `parent: none`). Values only —
- *  re-parenting never renames a row, so the keys are untouched and any
- *  author-written `links` / grandchild `parent` refs keep pointing. */
-export declare function reparentRoots(rows: PlanRowsValue, parentKey: SubtypeExprOrValue<StringType>): PlanRowsValue;
-/** The subtree ROOTS of a child collection (rows with `parent: none`). */
-export declare function rootsOf(rows: PlanRowsValue): PlanRowsValue;
-/** The per-level group-parent constructor the grouping engine calls per group. */
-export type PlanGroupParentFn = ExprType<FunctionType<[StringType, StringType, PlanRowsCollectionType], PlanRowsCollectionType>>;
-/**
- * Builds the per-level group-parent constructor shared by every grouped form
- * — one reified East function `(pathKey, label, children) => subtree`: the
- * parent row (its `kind` fully declared by the caller) joined with its
- * re-parented children in one keyed collection.
- *
- * @remarks
- * The parent's POSITION is no longer load-bearing — its key orders it, and the
- * renderer walks the tree from the roots. `meta` is a CONSTANT gutter meta line
- * (the `.of` aggregate tag); anything derived from the members — the `"8 rs"`
- * count — is computed renderer-side, because a parent synthesized per paged
- * window would otherwise bake THAT window's count into the row (#568).
- *
- * @param kind - The parent row's fully-declared kind
- * @param meta - Optional constant gutter meta line
- * @returns The reified `(pathKey, label, children) => subtree` function
- */
-export declare function groupParentFn(kind: ExprType<PlanRowKindType>, meta?: SubtypeExprOrValue<OptionType<StringType>>): PlanGroupParentFn;
-/**
- * Per-row `Option` fields the `.of` accessor forms inject — the expression
- * channel for the row envelope. Accessors return the fields' actual IR types
- * (`Option<…>`), so presence is a per-row data fact; the host config bag
- * never carries expressions of options.
- */
-interface PlanRowOverrides {
-    sub?: SubtypeExprOrValue<OptionType<StringType>>;
-    value?: SubtypeExprOrValue<OptionType<StringType>>;
-    status?: SubtypeExprOrValue<OptionType<StatusValueType>>;
-    approval?: SubtypeExprOrValue<OptionType<ApprovalStateType>>;
-    expand?: SubtypeExprOrValue<OptionType<PlanExpandType>>;
-    pinned?: SubtypeExprOrValue<OptionType<BooleanType>>;
-}
-/** Rebuild a 1-row subtree with accessor-supplied `Option` envelope fields. */
-export declare function applyRowOverrides(rows: PlanRowsValue, o: PlanRowOverrides): PlanRowsValue;
+    readonly edits: import("@elaraai/east").StructType<{
+        readonly verdict: BooleanType;
+        readonly drop: BooleanType;
+        readonly move: OptionType<import("@elaraai/east").StructType<{
+            readonly items: StringType;
+            readonly resize: BooleanType;
+        }>>;
+    }>;
+}>>>;
 /**
  * Assemble a nesting parent — the parent row (its kind fully declared; the
- * renderer computes any derived numbers) joined with its re-parented children
- * in one keyed collection.
+ * renderer computes any derived numbers) followed by its children, re-based
+ * under it.
+ *
+ * @param base - The parent's base input
+ * @param rows - The nested child streams
+ * @param kind - The parent's kind
+ * @returns The stream — the parent, then its subtree
  */
 export declare function assembleNested(base: PlanRowBaseInput, rows: PlanRowsInput<PlanAxisKindLiteral>, kind: ExprType<PlanRowKindType>): PlanRowsValue;
-export {};
 //# sourceMappingURL=assemble.d.ts.map