@elaraai/e3-ui 1.0.98 → 1.0.99

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

@@ -62,6 +62,8 @@ import type { ScheduleResourceKind } from "../schedule/resources.js";
 import { type PlanAxisKindLiteral, type PlanRowsValue } from "./types.js";
 import { type PlanConfig } from "./root.js";
 import { type PlanOverRows } from "./over.js";
+import { type PlanSeriesInput } from "./series.js";
+import type { PlanNestedChecked, PlanRowsNestedOf } from "./nested.js";
 import { type PlanLibraryTab } from "./library.js";
 export { PlanEventBlocksType, PlanEventDraftsType, PlanEventPagedType, PlanEventPlacedType, PlanEventReadsType, PlanEventShadeType, PlanEventShadingType, PlanEventShownType, } from "./event-rows.js";
 /**
@@ -1150,6 +1152,10 @@ export declare const PlanPayloadType: StructType<{
                         readonly items: StringType;
                         readonly resize: BooleanType;
                     }>>;
+                    readonly values: ArrayType<StructType<{
+                        readonly position: IntegerType;
+                        readonly whole: BooleanType;
+                    }>>;
                 }>;
             }>>;
         }>>>;
@@ -1721,12 +1727,6 @@ export declare const PlanPayloadType: StructType<{
                                         readonly to: import("@elaraai/east").StringType;
                                     }>;
                                     readonly prefix: import("@elaraai/east").StringType;
-                                    readonly window: StructType<{
-                                        readonly minX: import("@elaraai/east").FloatType;
-                                        readonly minY: import("@elaraai/east").FloatType;
-                                        readonly maxX: import("@elaraai/east").FloatType;
-                                        readonly maxY: import("@elaraai/east").FloatType;
-                                    }>;
                                 }>>;
                             }>>;
                         }>;
@@ -1738,12 +1738,6 @@ export declare const PlanPayloadType: StructType<{
                                     readonly to: import("@elaraai/east").StringType;
                                 }>;
                                 readonly prefix: import("@elaraai/east").StringType;
-                                readonly window: StructType<{
-                                    readonly minX: import("@elaraai/east").FloatType;
-                                    readonly minY: import("@elaraai/east").FloatType;
-                                    readonly maxX: import("@elaraai/east").FloatType;
-                                    readonly maxY: import("@elaraai/east").FloatType;
-                                }>;
                             }>>;
                             readonly preset: OptionType<import("@elaraai/east").StringType>;
                             readonly resolution: OptionType<VariantType<{
@@ -1764,12 +1758,6 @@ export declare const PlanPayloadType: StructType<{
                                     readonly to: import("@elaraai/east").StringType;
                                 }>;
                                 readonly prefix: import("@elaraai/east").StringType;
-                                readonly window: StructType<{
-                                    readonly minX: import("@elaraai/east").FloatType;
-                                    readonly minY: import("@elaraai/east").FloatType;
-                                    readonly maxX: import("@elaraai/east").FloatType;
-                                    readonly maxY: import("@elaraai/east").FloatType;
-                                }>;
                             }>>;
                             readonly preset: OptionType<import("@elaraai/east").StringType>;
                             readonly resolution: OptionType<VariantType<{
@@ -1788,20 +1776,25 @@ export declare const PlanPayloadType: StructType<{
                         readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
                         readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
                         readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
-                        readonly countWhere: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
-                            readonly values: ArrayType<import("@elaraai/east").StringType>;
-                            readonly range: StructType<{
-                                readonly from: import("@elaraai/east").StringType;
-                                readonly to: import("@elaraai/east").StringType;
-                            }>;
-                            readonly prefix: import("@elaraai/east").StringType;
-                            readonly window: StructType<{
-                                readonly minX: import("@elaraai/east").FloatType;
-                                readonly minY: import("@elaraai/east").FloatType;
-                                readonly maxX: import("@elaraai/east").FloatType;
-                                readonly maxY: import("@elaraai/east").FloatType;
-                            }>;
-                        }>>], OptionType<import("@elaraai/east").IntegerType>>;
+                        readonly countWhere: import("@elaraai/east").FunctionType<[StructType<{
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                                readonly range: StructType<{
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                }>;
+                                readonly prefix: import("@elaraai/east").StringType;
+                            }>>;
+                            readonly area: OptionType<VariantType<{
+                                readonly window: StructType<{
+                                    readonly minX: import("@elaraai/east").FloatType;
+                                    readonly minY: import("@elaraai/east").FloatType;
+                                    readonly maxX: import("@elaraai/east").FloatType;
+                                    readonly maxY: import("@elaraai/east").FloatType;
+                                }>;
+                                readonly unplaced: NullType;
+                            }>>;
+                        }>], OptionType<import("@elaraai/east").IntegerType>>;
                         readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
                         readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
                             readonly from: import("@elaraai/east").StringType;
@@ -1842,12 +1835,6 @@ export declare const PlanPayloadType: StructType<{
                                 readonly to: import("@elaraai/east").StringType;
                             }>;
                             readonly prefix: import("@elaraai/east").StringType;
-                            readonly window: StructType<{
-                                readonly minX: import("@elaraai/east").FloatType;
-                                readonly minY: import("@elaraai/east").FloatType;
-                                readonly maxX: import("@elaraai/east").FloatType;
-                                readonly maxY: import("@elaraai/east").FloatType;
-                            }>;
                         }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
                         readonly containsRow: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
                             readonly values: ArrayType<import("@elaraai/east").StringType>;
@@ -1856,12 +1843,6 @@ export declare const PlanPayloadType: StructType<{
                                 readonly to: import("@elaraai/east").StringType;
                             }>;
                             readonly prefix: import("@elaraai/east").StringType;
-                            readonly window: StructType<{
-                                readonly minX: import("@elaraai/east").FloatType;
-                                readonly minY: import("@elaraai/east").FloatType;
-                                readonly maxX: import("@elaraai/east").FloatType;
-                                readonly maxY: import("@elaraai/east").FloatType;
-                            }>;
                         }>>, import("@elaraai/east").StringType, import("@elaraai/east").BlobType], OptionType<import("@elaraai/east").BooleanType>>;
                     }>;
                 }>>;
@@ -1887,137 +1868,72 @@ export declare const PlanPayloadType: StructType<{
                 readonly url: NullType;
             }>>;
         }>>;
-        readonly footer: ArrayType<StructType<{
-            readonly text: StringType;
-            readonly tone: OptionType<VariantType<{
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-                readonly info: NullType;
-                readonly neutral: NullType;
+        readonly nested: OptionType<StructType<{
+            readonly index: StringType;
+            readonly source: StringType;
+            readonly tile: VariantType<{
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>;
+            readonly summary: OptionType<VariantType<{
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
             }>>;
-            readonly end: BooleanType;
-        }>>;
-        readonly id: OptionType<StringType>;
-        readonly sources: ArrayType<StringType>;
-        readonly canDrop: OptionType<FunctionType<[VariantType<{
-            readonly add: StructType<{
-                readonly from: StructType<{
-                    readonly library: StringType;
-                    readonly key: StringType;
-                }>;
-                readonly into: StructType<{
-                    readonly surface: StringType;
-                    readonly row: StringType;
-                    readonly slot: StringType;
-                    readonly event: OptionType<StringType>;
-                }>;
-                readonly duplicate: BooleanType;
-            }>;
-            readonly move: StructType<{
-                readonly from: StructType<{
-                    readonly surface: StringType;
-                    readonly row: StringType;
-                    readonly slot: StringType;
-                    readonly event: OptionType<StringType>;
-                }>;
-                readonly to: StructType<{
-                    readonly surface: StringType;
-                    readonly row: StringType;
-                    readonly slot: StringType;
-                    readonly event: OptionType<StringType>;
-                }>;
-            }>;
-            readonly remove: StructType<{
-                readonly from: StructType<{
-                    readonly surface: StringType;
-                    readonly row: StringType;
-                    readonly slot: StringType;
-                    readonly event: OptionType<StringType>;
-                }>;
-                readonly to: VariantType<{
-                    readonly trash: NullType;
-                    readonly source: NullType;
-                }>;
-            }>;
-            readonly resize: StructType<{
-                readonly event: StructType<{
-                    readonly surface: StringType;
-                    readonly row: StringType;
-                    readonly slot: StringType;
-                    readonly event: OptionType<StringType>;
-                }>;
-                readonly edge: VariantType<{
-                    readonly start: NullType;
-                    readonly end: NullType;
-                }>;
-            }>;
-        }>], BooleanType>>;
-        readonly onSelect: OptionType<FunctionType<[VariantType<{
-            readonly entry: StructType<{
-                readonly series: StringType;
-                readonly path: ArrayType<StringType>;
-            }>;
-            readonly section: StructType<{
+            readonly uses: ArrayType<StructType<{
                 readonly series: StringType;
-                readonly path: ArrayType<StringType>;
-            }>;
-        }>], NullType>>;
-        readonly onElementClick: OptionType<FunctionType<[VariantType<{
-            readonly run: StructType<{
-                readonly row: VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly run: StringType;
-            }>;
-            readonly event: StructType<{
-                readonly row: VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly event: StringType;
-            }>;
-            readonly chip: StructType<{
-                readonly row: VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
+                readonly place: ArrayType<StringType>;
+                readonly levels: ArrayType<VariantType<{
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+                readonly shade: VariantType<{
+                    readonly booked: NullType;
+                    readonly count: NullType;
+                    readonly fold: VariantType<{
+                        readonly sum: NullType;
+                        readonly mean: NullType;
+                        readonly min: NullType;
+                        readonly max: NullType;
+                        readonly last: NullType;
+                        readonly count: NullType;
                     }>;
                 }>;
-                readonly chip: StringType;
-            }>;
-            readonly mark: StructType<{
-                readonly row: VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
+                readonly parents: OptionType<VariantType<{
+                    readonly subtotals: StructType<{
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly aggregate: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly count: NullType;
+                        }>;
                     }>;
-                }>;
-                readonly mark: StringType;
-            }>;
-            readonly cell: StructType<{
-                readonly row: VariantType<{
+                    readonly bands: NullType;
+                }>>;
+            }>>;
+            readonly rows: FunctionType<[IntegerType, IntegerType, import("@elaraai/east").BlobType, DictType<StringType, import("@elaraai/east").BlobType>, DictType<StringType, DictType<StringType, ArrayType<StructType<{
+                readonly at: DateTimeType;
+                readonly value: OptionType<import("@elaraai/east").FloatType>;
+            }>>>>], OptionType<ArrayType<StructType<{
+                readonly fixed: BooleanType;
+                readonly parent: OptionType<VariantType<{
                     readonly entry: StructType<{
                         readonly series: StringType;
                         readonly path: ArrayType<StringType>;
@@ -2026,17 +1942,10 @@ export declare const PlanPayloadType: StructType<{
                         readonly series: StringType;
                         readonly path: ArrayType<StringType>;
                     }>;
-                }>;
-                readonly at: VariantType<{
-                    readonly time: DateTimeType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly ordinal: StringType;
-                }>;
-            }>;
-            readonly link: StructType<{
-                readonly key: StringType;
-                readonly from: StructType<{
-                    readonly row: VariantType<{
+                }>>;
+                readonly charts: OptionType<IntegerType>;
+                readonly rows: ArrayType<StructType<{
+                    readonly id: VariantType<{
                         readonly entry: StructType<{
                             readonly series: StringType;
                             readonly path: ArrayType<StringType>;
@@ -2046,10 +1955,7 @@ export declare const PlanPayloadType: StructType<{
                             readonly path: ArrayType<StringType>;
                         }>;
                     }>;
-                    readonly run: StringType;
-                }>;
-                readonly to: StructType<{
-                    readonly row: VariantType<{
+                    readonly parent: OptionType<VariantType<{
                         readonly entry: StructType<{
                             readonly series: StringType;
                             readonly path: ArrayType<StringType>;
@@ -2058,50 +1964,1207 @@ export declare const PlanPayloadType: StructType<{
                             readonly series: StringType;
                             readonly path: ArrayType<StringType>;
                         }>;
+                    }>>;
+                    readonly gutter: StructType<{
+                        readonly label: StringType;
+                        readonly id: BooleanType;
+                        readonly sub: OptionType<StringType>;
+                        readonly value: OptionType<StringType>;
+                        readonly meta: OptionType<StringType>;
+                        readonly stacked: BooleanType;
+                        readonly swatches: ArrayType<StructType<{
+                            readonly color: StringType;
+                            readonly label: StringType;
+                        }>>;
                     }>;
-                    readonly run: StringType;
-                }>;
-            }>;
-        }>], NullType>>;
-        readonly onGroupToggle: OptionType<FunctionType<[StructType<{
-            readonly row: VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly expanded: BooleanType;
-        }>], NullType>>;
-        readonly onGrainChange: OptionType<FunctionType<[VariantType<{
-            readonly group: NullType;
-            readonly resource: NullType;
-        }>], NullType>>;
-        readonly ui: OptionType<StructType<{
-            readonly read: FunctionType<[], StructType<{
-                readonly selected: OptionType<VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>>;
-                readonly collapsed: ArrayType<VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>>;
+                    readonly kind: VariantType<{
+                        readonly group: StructType<{
+                            readonly summary: VariantType<{
+                                readonly none: NullType;
+                                readonly cells: VariantType<{
+                                    readonly heat: StructType<{
+                                        readonly cells: ArrayType<StructType<{
+                                            readonly at: VariantType<{
+                                                readonly time: DateTimeType;
+                                                readonly number: import("@elaraai/east").FloatType;
+                                                readonly ordinal: StringType;
+                                            }>;
+                                            readonly value: OptionType<import("@elaraai/east").FloatType>;
+                                            readonly label: OptionType<StringType>;
+                                        }>>;
+                                        readonly scale: StructType<{
+                                            readonly min: OptionType<import("@elaraai/east").FloatType>;
+                                            readonly max: OptionType<import("@elaraai/east").FloatType>;
+                                            readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+                                        }>;
+                                        readonly fold: VariantType<{
+                                            readonly sum: NullType;
+                                            readonly mean: NullType;
+                                            readonly min: NullType;
+                                            readonly max: NullType;
+                                            readonly last: NullType;
+                                            readonly count: NullType;
+                                        }>;
+                                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    }>;
+                                    readonly weight: StructType<{
+                                        readonly cells: ArrayType<StructType<{
+                                            readonly at: VariantType<{
+                                                readonly time: DateTimeType;
+                                                readonly number: import("@elaraai/east").FloatType;
+                                                readonly ordinal: StringType;
+                                            }>;
+                                            readonly fraction: import("@elaraai/east").FloatType;
+                                            readonly planned: BooleanType;
+                                        }>>;
+                                        readonly fold: VariantType<{
+                                            readonly sum: NullType;
+                                            readonly mean: NullType;
+                                            readonly min: NullType;
+                                            readonly max: NullType;
+                                            readonly last: NullType;
+                                            readonly count: NullType;
+                                        }>;
+                                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    }>;
+                                    readonly segments: StructType<{
+                                        readonly cells: ArrayType<StructType<{
+                                            readonly at: VariantType<{
+                                                readonly time: DateTimeType;
+                                                readonly number: import("@elaraai/east").FloatType;
+                                                readonly ordinal: StringType;
+                                            }>;
+                                            readonly segments: ArrayType<StructType<{
+                                                readonly fill: VariantType<{
+                                                    readonly brand: NullType;
+                                                    readonly success: NullType;
+                                                    readonly warning: NullType;
+                                                    readonly danger: NullType;
+                                                    readonly info: NullType;
+                                                    readonly neutral: NullType;
+                                                    readonly slack: NullType;
+                                                    readonly free: NullType;
+                                                }>;
+                                                readonly weight: import("@elaraai/east").FloatType;
+                                                readonly label: OptionType<StringType>;
+                                            }>>;
+                                        }>>;
+                                        readonly fold: VariantType<{
+                                            readonly sum: NullType;
+                                            readonly mean: NullType;
+                                            readonly min: NullType;
+                                            readonly max: NullType;
+                                            readonly last: NullType;
+                                            readonly count: NullType;
+                                        }>;
+                                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    }>;
+                                }>;
+                                readonly aggregate: VariantType<{
+                                    readonly mean: NullType;
+                                    readonly max: NullType;
+                                    readonly sum: NullType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly span: StructType<{
+                            readonly runs: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly start: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly end: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly label: StringType;
+                                readonly quantity: OptionType<StructType<{
+                                    readonly value: import("@elaraai/east").FloatType;
+                                    readonly unit: OptionType<StringType>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    readonly text: OptionType<StringType>;
+                                }>>;
+                                readonly state: VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                                readonly status: OptionType<VariantType<{
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly moved: OptionType<IntegerType>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
+                            }>>;
+                            readonly decisions: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly applied: BooleanType;
+                            }>>;
+                            readonly ports: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                            readonly rollup: OptionType<VariantType<{
+                                readonly union: NullType;
+                                readonly byStatus: NullType;
+                                readonly sum: NullType;
+                            }>>;
+                        }>;
+                        readonly buckets: StructType<{
+                            readonly lanes: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                            readonly events: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly lane: OptionType<StringType>;
+                                readonly label: OptionType<StringType>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
+                                readonly state: VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                                readonly tone: OptionType<VariantType<{
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly colorPalette: OptionType<VariantType<{
+                                    readonly brand: NullType;
+                                    readonly gray: NullType;
+                                    readonly red: NullType;
+                                    readonly orange: NullType;
+                                    readonly yellow: NullType;
+                                    readonly green: NullType;
+                                    readonly teal: NullType;
+                                    readonly blue: NullType;
+                                    readonly cyan: NullType;
+                                    readonly purple: NullType;
+                                    readonly pink: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly stretch: OptionType<VariantType<{
+                                    readonly horizontal: NullType;
+                                    readonly vertical: NullType;
+                                    readonly both: NullType;
+                                }>>;
+                                readonly content: OptionType<StructType<{
+                                    readonly horizontal: OptionType<VariantType<{
+                                        readonly start: NullType;
+                                        readonly center: NullType;
+                                        readonly end: NullType;
+                                    }>>;
+                                    readonly vertical: OptionType<VariantType<{
+                                        readonly start: NullType;
+                                        readonly center: NullType;
+                                        readonly end: NullType;
+                                    }>>;
+                                }>>;
+                                readonly animation: OptionType<VariantType<{
+                                    readonly none: NullType;
+                                    readonly pulse: NullType;
+                                }>>;
+                            }>>;
+                            readonly markers: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly lane: OptionType<StringType>;
+                                readonly status: VariantType<{
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>;
+                                readonly message: StringType;
+                            }>>;
+                        }>;
+                        readonly chart: StructType<{
+                            readonly layers: ArrayType<VariantType<{
+                                readonly line: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly breach: OptionType<VariantType<{
+                                        readonly above: import("@elaraai/east").FloatType;
+                                        readonly below: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                }>;
+                                readonly area: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                }>;
+                                readonly column: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly series: OptionType<StringType>;
+                                    readonly breach: OptionType<VariantType<{
+                                        readonly above: import("@elaraai/east").FloatType;
+                                        readonly below: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                }>;
+                                readonly scatter: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                }>;
+                                readonly band: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly lo: import("@elaraai/east").FloatType;
+                                        readonly hi: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                }>;
+                                readonly refLine: StructType<{
+                                    readonly y: import("@elaraai/east").FloatType;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly label: OptionType<StringType>;
+                                }>;
+                                readonly refBand: StructType<{
+                                    readonly from: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly to: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly label: OptionType<StringType>;
+                                }>;
+                                readonly refDot: StructType<{
+                                    readonly t: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly y: import("@elaraai/east").FloatType;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly label: OptionType<StringType>;
+                                }>;
+                            }>>;
+                            readonly left: OptionType<StructType<{
+                                readonly domain: OptionType<VariantType<{
+                                    readonly number: StructType<{
+                                        readonly min: import("@elaraai/east").FloatType;
+                                        readonly max: import("@elaraai/east").FloatType;
+                                    }>;
+                                    readonly time: StructType<{
+                                        readonly min: DateTimeType;
+                                        readonly max: DateTimeType;
+                                    }>;
+                                }>>;
+                                readonly tickValues: OptionType<VariantType<{
+                                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                                    readonly time: ArrayType<DateTimeType>;
+                                }>>;
+                                readonly format: OptionType<VariantType<{
+                                    readonly number: NullType;
+                                    readonly currency: StructType<{
+                                        readonly code: StringType;
+                                        readonly compact: BooleanType;
+                                    }>;
+                                    readonly percent: NullType;
+                                    readonly compact: NullType;
+                                    readonly date: StringType;
+                                    readonly time: StringType;
+                                    readonly datetime: StringType;
+                                }>>;
+                            }>>;
+                            readonly right: OptionType<StructType<{
+                                readonly domain: OptionType<VariantType<{
+                                    readonly number: StructType<{
+                                        readonly min: import("@elaraai/east").FloatType;
+                                        readonly max: import("@elaraai/east").FloatType;
+                                    }>;
+                                    readonly time: StructType<{
+                                        readonly min: DateTimeType;
+                                        readonly max: DateTimeType;
+                                    }>;
+                                }>>;
+                                readonly tickValues: OptionType<VariantType<{
+                                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                                    readonly time: ArrayType<DateTimeType>;
+                                }>>;
+                                readonly format: OptionType<VariantType<{
+                                    readonly number: NullType;
+                                    readonly currency: StructType<{
+                                        readonly code: StringType;
+                                        readonly compact: BooleanType;
+                                    }>;
+                                    readonly percent: NullType;
+                                    readonly compact: NullType;
+                                    readonly date: StringType;
+                                    readonly time: StringType;
+                                    readonly datetime: StringType;
+                                }>>;
+                            }>>;
+                            readonly height: VariantType<{
+                                readonly spark: NullType;
+                                readonly expanded: NullType;
+                                readonly fixed: StringType;
+                            }>;
+                            readonly expandedHeight: OptionType<StringType>;
+                            readonly expandable: BooleanType;
+                        }>;
+                        readonly heat: StructType<{
+                            readonly cells: VariantType<{
+                                readonly heat: StructType<{
+                                    readonly cells: ArrayType<StructType<{
+                                        readonly at: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly value: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly label: OptionType<StringType>;
+                                    }>>;
+                                    readonly scale: StructType<{
+                                        readonly min: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly max: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+                                    }>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                }>;
+                                readonly weight: StructType<{
+                                    readonly cells: ArrayType<StructType<{
+                                        readonly at: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly fraction: import("@elaraai/east").FloatType;
+                                        readonly planned: BooleanType;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                }>;
+                                readonly segments: StructType<{
+                                    readonly cells: ArrayType<StructType<{
+                                        readonly at: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly segments: ArrayType<StructType<{
+                                            readonly fill: VariantType<{
+                                                readonly brand: NullType;
+                                                readonly success: NullType;
+                                                readonly warning: NullType;
+                                                readonly danger: NullType;
+                                                readonly info: NullType;
+                                                readonly neutral: NullType;
+                                                readonly slack: NullType;
+                                                readonly free: NullType;
+                                            }>;
+                                            readonly weight: import("@elaraai/east").FloatType;
+                                            readonly label: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                }>;
+                            }>;
+                            readonly aggregate: OptionType<VariantType<{
+                                readonly mean: NullType;
+                                readonly max: NullType;
+                                readonly sum: NullType;
+                            }>>;
+                            readonly scale: OptionType<StructType<{
+                                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                                readonly max: OptionType<import("@elaraai/east").FloatType>;
+                                readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+                            }>>;
+                        }>;
+                        readonly table: StructType<{
+                            readonly series: ArrayType<StructType<{
+                                readonly cells: ArrayType<StructType<{
+                                    readonly at: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly value: OptionType<import("@elaraai/east").FloatType>;
+                                    readonly text: OptionType<StringType>;
+                                    readonly tone: OptionType<VariantType<{
+                                        readonly neg: NullType;
+                                        readonly muted: NullType;
+                                    }>>;
+                                }>>;
+                                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                readonly tone: OptionType<VariantType<{
+                                    readonly neg: NullType;
+                                    readonly muted: NullType;
+                                }>>;
+                                readonly strong: BooleanType;
+                                readonly rollup: BooleanType;
+                                readonly fold: VariantType<{
+                                    readonly sum: NullType;
+                                    readonly mean: NullType;
+                                    readonly min: NullType;
+                                    readonly max: NullType;
+                                    readonly last: NullType;
+                                    readonly count: NullType;
+                                }>;
+                            }>>;
+                            readonly split: VariantType<{
+                                readonly horizontal: NullType;
+                                readonly vertical: NullType;
+                            }>;
+                            readonly aggregate: OptionType<VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly count: NullType;
+                            }>>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                            readonly emphasis: VariantType<{
+                                readonly body: NullType;
+                                readonly header: NullType;
+                                readonly footer: NullType;
+                            }>;
+                        }>;
+                        readonly cards: StructType<{
+                            readonly chips: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly from: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly to: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly label: StringType;
+                                readonly state: VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
+                            }>>;
+                        }>;
+                        readonly events: StructType<{
+                            readonly marks: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly kind: VariantType<{
+                                    readonly milestone: NullType;
+                                    readonly decision: StructType<{
+                                        readonly applied: BooleanType;
+                                    }>;
+                                    readonly exception: NullType;
+                                }>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
+                                readonly label: OptionType<StringType>;
+                            }>>;
+                        }>;
+                    }>;
+                    readonly collapsed: BooleanType;
+                    readonly pinned: BooleanType;
+                    readonly height: OptionType<StringType>;
+                    readonly status: OptionType<VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly expand: OptionType<StructType<{
+                        readonly height: OptionType<StringType>;
+                        readonly axis: VariantType<{
+                            readonly keep: NullType;
+                            readonly dim: NullType;
+                            readonly off: NullType;
+                        }>;
+                    }>>;
+                    readonly edits: StructType<{
+                        readonly drop: BooleanType;
+                        readonly move: OptionType<StructType<{
+                            readonly items: StringType;
+                            readonly resize: BooleanType;
+                        }>>;
+                        readonly values: ArrayType<StructType<{
+                            readonly position: IntegerType;
+                            readonly whole: BooleanType;
+                        }>>;
+                    }>;
+                }>>;
+            }>>>>;
+        }>>;
+        readonly footer: ArrayType<StructType<{
+            readonly text: StringType;
+            readonly tone: OptionType<VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+            readonly end: BooleanType;
+        }>>;
+        readonly id: OptionType<StringType>;
+        readonly sources: ArrayType<StringType>;
+        readonly canDrop: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
+            }>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                }>;
+            }>;
+        }>], BooleanType>>;
+        readonly onSelect: OptionType<FunctionType<[VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>], NullType>>;
+        readonly onElementClick: OptionType<FunctionType<[VariantType<{
+            readonly run: StructType<{
+                readonly row: VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>;
+                readonly run: StringType;
+            }>;
+            readonly event: StructType<{
+                readonly row: VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>;
+                readonly event: StringType;
+            }>;
+            readonly chip: StructType<{
+                readonly row: VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>;
+                readonly chip: StringType;
+            }>;
+            readonly mark: StructType<{
+                readonly row: VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>;
+                readonly mark: StringType;
+            }>;
+            readonly cell: StructType<{
+                readonly row: VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>;
+                readonly at: VariantType<{
+                    readonly time: DateTimeType;
+                    readonly number: import("@elaraai/east").FloatType;
+                    readonly ordinal: StringType;
+                }>;
+            }>;
+            readonly link: StructType<{
+                readonly key: StringType;
+                readonly from: StructType<{
+                    readonly row: VariantType<{
+                        readonly entry: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                        readonly section: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                    }>;
+                    readonly run: StringType;
+                }>;
+                readonly to: StructType<{
+                    readonly row: VariantType<{
+                        readonly entry: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                        readonly section: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                    }>;
+                    readonly run: StringType;
+                }>;
+            }>;
+        }>], NullType>>;
+        readonly onGroupToggle: OptionType<FunctionType<[StructType<{
+            readonly row: VariantType<{
+                readonly entry: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+                readonly section: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+            }>;
+            readonly expanded: BooleanType;
+        }>], NullType>>;
+        readonly onGrainChange: OptionType<FunctionType<[VariantType<{
+            readonly group: NullType;
+            readonly resource: NullType;
+        }>], NullType>>;
+        readonly ui: OptionType<StructType<{
+            readonly read: FunctionType<[], StructType<{
+                readonly selected: OptionType<VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>>;
+                readonly collapsed: ArrayType<VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>>;
                 readonly expanded: ArrayType<VariantType<{
                     readonly entry: StructType<{
                         readonly series: StringType;
@@ -2911,6 +3974,9 @@ export declare const PlanPayloadType: StructType<{
             readonly end: StringType;
             readonly resource: OptionType<StringType>;
             readonly status: OptionType<StringType>;
+            readonly quantity: OptionType<StringType>;
+            readonly parts: OptionType<StringType>;
+            readonly withTimes: ArrayType<StringType>;
         }>;
         readonly seriesKey: FunctionType<[OptionType<StructType<{
             readonly kind: StringType;
@@ -3975,6 +5041,10 @@ export declare const PlanPayloadType: StructType<{
                     readonly items: StringType;
                     readonly resize: BooleanType;
                 }>>;
+                readonly values: ArrayType<StructType<{
+                    readonly position: IntegerType;
+                    readonly whole: BooleanType;
+                }>>;
             }>;
         }>>;
     }>>>>>;
@@ -5240,6 +6310,10 @@ export declare const PlanPayloadType: StructType<{
                         readonly items: StringType;
                         readonly resize: BooleanType;
                     }>>;
+                    readonly values: ArrayType<StructType<{
+                        readonly position: IntegerType;
+                        readonly whole: BooleanType;
+                    }>>;
                 }>;
             }>>;
         }>>>>;
@@ -6506,6 +7580,10 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                         readonly items: StringType;
                         readonly resize: BooleanType;
                     }>>;
+                    readonly values: ArrayType<StructType<{
+                        readonly position: IntegerType;
+                        readonly whole: BooleanType;
+                    }>>;
                 }>;
             }>>;
         }>>>;
@@ -6876,372 +7954,1429 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                             readonly scroll: NullType;
                             readonly auto: NullType;
                         }>>;
-                        readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: NullType;
-                            readonly hidden: NullType;
-                            readonly scroll: NullType;
-                            readonly auto: NullType;
+                        readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly width: OptionType<StringType>;
+                        readonly height: OptionType<StringType>;
+                        readonly minWidth: OptionType<StringType>;
+                        readonly minHeight: OptionType<StringType>;
+                        readonly maxWidth: OptionType<StringType>;
+                        readonly maxHeight: OptionType<StringType>;
+                        readonly padding: OptionType<StructType<{
+                            readonly top: OptionType<StringType>;
+                            readonly right: OptionType<StringType>;
+                            readonly bottom: OptionType<StringType>;
+                            readonly left: OptionType<StringType>;
+                        }>>;
+                        readonly margin: OptionType<StructType<{
+                            readonly top: OptionType<StringType>;
+                            readonly right: OptionType<StringType>;
+                            readonly bottom: OptionType<StringType>;
+                            readonly left: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                }>>;
+                readonly count: OptionType<IntegerType>;
+                readonly narrowed: BooleanType;
+            }>>;
+        }>>;
+        readonly slice: OptionType<StructType<{
+            readonly slice: StructType<{
+                readonly key: import("@elaraai/east").StringType;
+                readonly parts: ArrayType<StructType<{
+                    readonly source: import("@elaraai/east").StringType;
+                    readonly label: OptionType<import("@elaraai/east").StringType>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: import("@elaraai/east").StringType;
+                        readonly prefix: import("@elaraai/east").StringType;
+                        readonly label: OptionType<import("@elaraai/east").StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<import("@elaraai/east").StringType>;
+                            readonly background: OptionType<import("@elaraai/east").StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                            readonly borderRadius: OptionType<import("@elaraai/east").StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<import("@elaraai/east").StringType>;
+                            readonly height: OptionType<import("@elaraai/east").StringType>;
+                            readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                    readonly slice: StructType<{
+                        readonly key: import("@elaraai/east").StringType;
+                        readonly config: StructType<{
+                            readonly fields: ArrayType<StructType<{
+                                readonly fieldId: import("@elaraai/east").StringType;
+                                readonly label: import("@elaraai/east").StringType;
+                                readonly kind: import("@elaraai/east").StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly multiple: import("@elaraai/east").BooleanType;
+                                readonly set: import("@elaraai/east").BooleanType;
+                                readonly values: ArrayType<StructType<{
+                                    readonly value: import("@elaraai/east").StringType;
+                                    readonly label: import("@elaraai/east").StringType;
+                                }>>;
+                                readonly format: OptionType<VariantType<{
+                                    readonly number: NullType;
+                                    readonly currency: StructType<{
+                                        readonly code: import("@elaraai/east").StringType;
+                                        readonly compact: import("@elaraai/east").BooleanType;
+                                    }>;
+                                    readonly percent: NullType;
+                                    readonly compact: NullType;
+                                    readonly date: import("@elaraai/east").StringType;
+                                    readonly time: import("@elaraai/east").StringType;
+                                    readonly datetime: import("@elaraai/east").StringType;
+                                }>>;
+                            }>>;
+                            readonly indexes: ArrayType<StructType<{
+                                readonly name: import("@elaraai/east").StringType;
+                                readonly fields: ArrayType<import("@elaraai/east").StringType>;
+                                readonly sets: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                                readonly structured: import("@elaraai/east").BooleanType;
+                                readonly interval: OptionType<StructType<{
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                    readonly optional: import("@elaraai/east").BooleanType;
+                                }>>;
+                                readonly area: OptionType<StructType<{
+                                    readonly x: import("@elaraai/east").StringType;
+                                    readonly y: import("@elaraai/east").StringType;
+                                    readonly width: OptionType<import("@elaraai/east").StringType>;
+                                    readonly height: OptionType<import("@elaraai/east").StringType>;
+                                    readonly centre: import("@elaraai/east").BooleanType;
+                                    readonly cell: import("@elaraai/east").FloatType;
+                                    readonly optional: import("@elaraai/east").BooleanType;
+                                }>>;
+                                readonly series: OptionType<StructType<{
+                                    readonly key: import("@elaraai/east").StringType;
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                    readonly tile: VariantType<{
+                                        readonly day: NullType;
+                                        readonly week: NullType;
+                                        readonly month: NullType;
+                                        readonly quarter: NullType;
+                                        readonly year: NullType;
+                                    }>;
+                                }>>;
+                                readonly summary: OptionType<StructType<{
+                                    readonly key: import("@elaraai/east").StringType;
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                    readonly tile: VariantType<{
+                                        readonly day: NullType;
+                                        readonly week: NullType;
+                                        readonly month: NullType;
+                                        readonly quarter: NullType;
+                                        readonly year: NullType;
+                                    }>;
+                                }>>;
+                            }>>;
+                            readonly range: OptionType<import("@elaraai/east").StringType>;
+                            readonly search: ArrayType<import("@elaraai/east").StringType>;
+                            readonly presets: ArrayType<StructType<{
+                                readonly id: import("@elaraai/east").StringType;
+                                readonly name: import("@elaraai/east").StringType;
+                                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                                    readonly values: ArrayType<import("@elaraai/east").StringType>;
+                                    readonly range: StructType<{
+                                        readonly from: import("@elaraai/east").StringType;
+                                        readonly to: import("@elaraai/east").StringType;
+                                    }>;
+                                    readonly prefix: import("@elaraai/east").StringType;
+                                }>>;
+                            }>>;
+                        }>;
+                        readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                                readonly range: StructType<{
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                }>;
+                                readonly prefix: import("@elaraai/east").StringType;
+                            }>>;
+                            readonly preset: OptionType<import("@elaraai/east").StringType>;
+                            readonly resolution: OptionType<VariantType<{
+                                readonly auto: NullType;
+                                readonly hour: NullType;
+                                readonly day: NullType;
+                                readonly week: NullType;
+                                readonly month: NullType;
+                                readonly quarter: NullType;
+                                readonly year: NullType;
+                            }>>;
                         }>>;
-                        readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                            readonly visible: NullType;
-                            readonly hidden: NullType;
-                            readonly scroll: NullType;
+                        readonly write: import("@elaraai/east").FunctionType<[StructType<{
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                                readonly range: StructType<{
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                }>;
+                                readonly prefix: import("@elaraai/east").StringType;
+                            }>>;
+                            readonly preset: OptionType<import("@elaraai/east").StringType>;
+                            readonly resolution: OptionType<VariantType<{
+                                readonly auto: NullType;
+                                readonly hour: NullType;
+                                readonly day: NullType;
+                                readonly week: NullType;
+                                readonly month: NullType;
+                                readonly quarter: NullType;
+                                readonly year: NullType;
+                            }>>;
+                        }>], NullType>;
+                        readonly choose: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, ArrayType<import("@elaraai/east").StringType>], NullType>;
+                        readonly range: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+                        readonly prefix: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+                        readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+                        readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+                        readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+                        readonly countWhere: import("@elaraai/east").FunctionType<[StructType<{
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                                readonly range: StructType<{
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                }>;
+                                readonly prefix: import("@elaraai/east").StringType;
+                            }>>;
+                            readonly area: OptionType<VariantType<{
+                                readonly window: StructType<{
+                                    readonly minX: import("@elaraai/east").FloatType;
+                                    readonly minY: import("@elaraai/east").FloatType;
+                                    readonly maxX: import("@elaraai/east").FloatType;
+                                    readonly maxY: import("@elaraai/east").FloatType;
+                                }>;
+                                readonly unplaced: NullType;
+                            }>>;
+                        }>], OptionType<import("@elaraai/east").IntegerType>>;
+                        readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+                        readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>>>;
+                        readonly values: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<StructType<{
+                            readonly value: import("@elaraai/east").StringType;
+                            readonly label: import("@elaraai/east").StringType;
+                            readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                            readonly selected: import("@elaraai/east").BooleanType;
+                            readonly error: OptionType<import("@elaraai/east").StringType>;
+                        }>>>;
+                        readonly suggest: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], OptionType<ArrayType<StructType<{
+                            readonly value: import("@elaraai/east").StringType;
+                            readonly label: import("@elaraai/east").StringType;
+                            readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                            readonly selected: import("@elaraai/east").BooleanType;
+                            readonly error: OptionType<import("@elaraai/east").StringType>;
+                        }>>>>;
+                        readonly replaces: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<import("@elaraai/east").StringType>>;
+                        readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+                        readonly setResolution: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
                             readonly auto: NullType;
-                        }>>;
-                        readonly width: OptionType<StringType>;
-                        readonly height: OptionType<StringType>;
-                        readonly minWidth: OptionType<StringType>;
-                        readonly minHeight: OptionType<StringType>;
-                        readonly maxWidth: OptionType<StringType>;
-                        readonly maxHeight: OptionType<StringType>;
-                        readonly padding: OptionType<StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                        readonly margin: OptionType<StructType<{
-                            readonly top: OptionType<StringType>;
-                            readonly right: OptionType<StringType>;
-                            readonly bottom: OptionType<StringType>;
-                            readonly left: OptionType<StringType>;
-                        }>>;
-                    }>>;
+                            readonly hour: NullType;
+                            readonly day: NullType;
+                            readonly week: NullType;
+                            readonly month: NullType;
+                            readonly quarter: NullType;
+                            readonly year: NullType;
+                        }>>], NullType>;
+                        readonly retry: import("@elaraai/east").FunctionType<[], NullType>;
+                        readonly sourceId: import("@elaraai/east").StringType;
+                        readonly readEntry: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<OptionType<import("@elaraai/east").BlobType>>>;
+                        readonly contains: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                            readonly values: ArrayType<import("@elaraai/east").StringType>;
+                            readonly range: StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                            }>;
+                            readonly prefix: import("@elaraai/east").StringType;
+                        }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+                        readonly containsRow: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                            readonly values: ArrayType<import("@elaraai/east").StringType>;
+                            readonly range: StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                            }>;
+                            readonly prefix: import("@elaraai/east").StringType;
+                        }>>, import("@elaraai/east").StringType, import("@elaraai/east").BlobType], OptionType<import("@elaraai/east").BooleanType>>;
+                    }>;
                 }>>;
-                readonly count: OptionType<IntegerType>;
-                readonly narrowed: BooleanType;
+                readonly presets: ArrayType<StructType<{
+                    readonly id: import("@elaraai/east").StringType;
+                    readonly name: import("@elaraai/east").StringType;
+                }>>;
+                readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+                readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+            }>;
+            readonly affordances: ArrayType<VariantType<{
+                readonly fields: NullType;
+                readonly search: NullType;
+                readonly range: NullType;
+                readonly presets: NullType;
+                readonly resolution: NullType;
+                readonly brush: NullType;
+                readonly summary: NullType;
+            }>>;
+            readonly persist: OptionType<VariantType<{
+                readonly local: NullType;
+                readonly session: NullType;
+                readonly url: NullType;
             }>>;
         }>>;
-        readonly slice: OptionType<StructType<{
-            readonly slice: StructType<{
-                readonly key: import("@elaraai/east").StringType;
-                readonly parts: ArrayType<StructType<{
-                    readonly source: import("@elaraai/east").StringType;
-                    readonly label: OptionType<import("@elaraai/east").StringType>;
-                    readonly icon: OptionType<StructType<{
-                        readonly name: import("@elaraai/east").StringType;
-                        readonly prefix: import("@elaraai/east").StringType;
-                        readonly label: OptionType<import("@elaraai/east").StringType>;
-                        readonly style: OptionType<StructType<{
-                            readonly size: OptionType<VariantType<{
-                                readonly xs: NullType;
-                                readonly sm: NullType;
-                                readonly md: NullType;
-                                readonly lg: NullType;
-                                readonly xl: NullType;
-                                readonly "2xl": NullType;
+        readonly nested: OptionType<StructType<{
+            readonly index: StringType;
+            readonly source: StringType;
+            readonly tile: VariantType<{
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>;
+            readonly summary: OptionType<VariantType<{
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>>;
+            readonly uses: ArrayType<StructType<{
+                readonly series: StringType;
+                readonly place: ArrayType<StringType>;
+                readonly levels: ArrayType<VariantType<{
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+                readonly shade: VariantType<{
+                    readonly booked: NullType;
+                    readonly count: NullType;
+                    readonly fold: VariantType<{
+                        readonly sum: NullType;
+                        readonly mean: NullType;
+                        readonly min: NullType;
+                        readonly max: NullType;
+                        readonly last: NullType;
+                        readonly count: NullType;
+                    }>;
+                }>;
+                readonly parents: OptionType<VariantType<{
+                    readonly subtotals: StructType<{
+                        readonly fold: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                        readonly aggregate: VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>;
+                    readonly bands: NullType;
+                }>>;
+            }>>;
+            readonly rows: FunctionType<[IntegerType, IntegerType, import("@elaraai/east").BlobType, DictType<StringType, import("@elaraai/east").BlobType>, DictType<StringType, DictType<StringType, ArrayType<StructType<{
+                readonly at: DateTimeType;
+                readonly value: OptionType<import("@elaraai/east").FloatType>;
+            }>>>>], OptionType<ArrayType<StructType<{
+                readonly fixed: BooleanType;
+                readonly parent: OptionType<VariantType<{
+                    readonly entry: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                    readonly section: StructType<{
+                        readonly series: StringType;
+                        readonly path: ArrayType<StringType>;
+                    }>;
+                }>>;
+                readonly charts: OptionType<IntegerType>;
+                readonly rows: ArrayType<StructType<{
+                    readonly id: VariantType<{
+                        readonly entry: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                        readonly section: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                    }>;
+                    readonly parent: OptionType<VariantType<{
+                        readonly entry: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                        readonly section: StructType<{
+                            readonly series: StringType;
+                            readonly path: ArrayType<StringType>;
+                        }>;
+                    }>>;
+                    readonly gutter: StructType<{
+                        readonly label: StringType;
+                        readonly id: BooleanType;
+                        readonly sub: OptionType<StringType>;
+                        readonly value: OptionType<StringType>;
+                        readonly meta: OptionType<StringType>;
+                        readonly stacked: BooleanType;
+                        readonly swatches: ArrayType<StructType<{
+                            readonly color: StringType;
+                            readonly label: StringType;
+                        }>>;
+                    }>;
+                    readonly kind: VariantType<{
+                        readonly group: StructType<{
+                            readonly summary: VariantType<{
+                                readonly none: NullType;
+                                readonly cells: VariantType<{
+                                    readonly heat: StructType<{
+                                        readonly cells: ArrayType<StructType<{
+                                            readonly at: VariantType<{
+                                                readonly time: DateTimeType;
+                                                readonly number: import("@elaraai/east").FloatType;
+                                                readonly ordinal: StringType;
+                                            }>;
+                                            readonly value: OptionType<import("@elaraai/east").FloatType>;
+                                            readonly label: OptionType<StringType>;
+                                        }>>;
+                                        readonly scale: StructType<{
+                                            readonly min: OptionType<import("@elaraai/east").FloatType>;
+                                            readonly max: OptionType<import("@elaraai/east").FloatType>;
+                                            readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+                                        }>;
+                                        readonly fold: VariantType<{
+                                            readonly sum: NullType;
+                                            readonly mean: NullType;
+                                            readonly min: NullType;
+                                            readonly max: NullType;
+                                            readonly last: NullType;
+                                            readonly count: NullType;
+                                        }>;
+                                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    }>;
+                                    readonly weight: StructType<{
+                                        readonly cells: ArrayType<StructType<{
+                                            readonly at: VariantType<{
+                                                readonly time: DateTimeType;
+                                                readonly number: import("@elaraai/east").FloatType;
+                                                readonly ordinal: StringType;
+                                            }>;
+                                            readonly fraction: import("@elaraai/east").FloatType;
+                                            readonly planned: BooleanType;
+                                        }>>;
+                                        readonly fold: VariantType<{
+                                            readonly sum: NullType;
+                                            readonly mean: NullType;
+                                            readonly min: NullType;
+                                            readonly max: NullType;
+                                            readonly last: NullType;
+                                            readonly count: NullType;
+                                        }>;
+                                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    }>;
+                                    readonly segments: StructType<{
+                                        readonly cells: ArrayType<StructType<{
+                                            readonly at: VariantType<{
+                                                readonly time: DateTimeType;
+                                                readonly number: import("@elaraai/east").FloatType;
+                                                readonly ordinal: StringType;
+                                            }>;
+                                            readonly segments: ArrayType<StructType<{
+                                                readonly fill: VariantType<{
+                                                    readonly brand: NullType;
+                                                    readonly success: NullType;
+                                                    readonly warning: NullType;
+                                                    readonly danger: NullType;
+                                                    readonly info: NullType;
+                                                    readonly neutral: NullType;
+                                                    readonly slack: NullType;
+                                                    readonly free: NullType;
+                                                }>;
+                                                readonly weight: import("@elaraai/east").FloatType;
+                                                readonly label: OptionType<StringType>;
+                                            }>>;
+                                        }>>;
+                                        readonly fold: VariantType<{
+                                            readonly sum: NullType;
+                                            readonly mean: NullType;
+                                            readonly min: NullType;
+                                            readonly max: NullType;
+                                            readonly last: NullType;
+                                            readonly count: NullType;
+                                        }>;
+                                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    }>;
+                                }>;
+                                readonly aggregate: VariantType<{
+                                    readonly mean: NullType;
+                                    readonly max: NullType;
+                                    readonly sum: NullType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly span: StructType<{
+                            readonly runs: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly start: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly end: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly label: StringType;
+                                readonly quantity: OptionType<StructType<{
+                                    readonly value: import("@elaraai/east").FloatType;
+                                    readonly unit: OptionType<StringType>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                    readonly text: OptionType<StringType>;
+                                }>>;
+                                readonly state: VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                                readonly status: OptionType<VariantType<{
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly moved: OptionType<IntegerType>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
                             }>>;
-                            readonly variant: OptionType<VariantType<{
-                                readonly solid: NullType;
+                            readonly decisions: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly applied: BooleanType;
                             }>>;
-                            readonly color: OptionType<import("@elaraai/east").StringType>;
-                            readonly background: OptionType<import("@elaraai/east").StringType>;
-                            readonly colorPalette: OptionType<VariantType<{
-                                readonly brand: NullType;
-                                readonly gray: NullType;
-                                readonly red: NullType;
-                                readonly orange: NullType;
-                                readonly yellow: NullType;
-                                readonly green: NullType;
-                                readonly teal: NullType;
-                                readonly blue: NullType;
-                                readonly cyan: NullType;
-                                readonly purple: NullType;
-                                readonly pink: NullType;
-                                readonly success: NullType;
-                                readonly warning: NullType;
-                                readonly danger: NullType;
-                                readonly info: NullType;
-                                readonly neutral: NullType;
+                            readonly ports: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly label: OptionType<StringType>;
                             }>>;
-                            readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                            readonly borderRadius: OptionType<import("@elaraai/east").StringType>;
-                            readonly overflow: OptionType<VariantType<{
-                                readonly visible: NullType;
-                                readonly hidden: NullType;
-                                readonly scroll: NullType;
-                                readonly auto: NullType;
+                            readonly rollup: OptionType<VariantType<{
+                                readonly union: NullType;
+                                readonly byStatus: NullType;
+                                readonly sum: NullType;
                             }>>;
-                            readonly overflowX: OptionType<VariantType<{
-                                readonly visible: NullType;
-                                readonly hidden: NullType;
-                                readonly scroll: NullType;
-                                readonly auto: NullType;
+                        }>;
+                        readonly buckets: StructType<{
+                            readonly lanes: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
                             }>>;
-                            readonly overflowY: OptionType<VariantType<{
-                                readonly visible: NullType;
-                                readonly hidden: NullType;
-                                readonly scroll: NullType;
-                                readonly auto: NullType;
+                            readonly events: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly lane: OptionType<StringType>;
+                                readonly label: OptionType<StringType>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
+                                readonly state: VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                                readonly tone: OptionType<VariantType<{
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly colorPalette: OptionType<VariantType<{
+                                    readonly brand: NullType;
+                                    readonly gray: NullType;
+                                    readonly red: NullType;
+                                    readonly orange: NullType;
+                                    readonly yellow: NullType;
+                                    readonly green: NullType;
+                                    readonly teal: NullType;
+                                    readonly blue: NullType;
+                                    readonly cyan: NullType;
+                                    readonly purple: NullType;
+                                    readonly pink: NullType;
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>>;
+                                readonly stretch: OptionType<VariantType<{
+                                    readonly horizontal: NullType;
+                                    readonly vertical: NullType;
+                                    readonly both: NullType;
+                                }>>;
+                                readonly content: OptionType<StructType<{
+                                    readonly horizontal: OptionType<VariantType<{
+                                        readonly start: NullType;
+                                        readonly center: NullType;
+                                        readonly end: NullType;
+                                    }>>;
+                                    readonly vertical: OptionType<VariantType<{
+                                        readonly start: NullType;
+                                        readonly center: NullType;
+                                        readonly end: NullType;
+                                    }>>;
+                                }>>;
+                                readonly animation: OptionType<VariantType<{
+                                    readonly none: NullType;
+                                    readonly pulse: NullType;
+                                }>>;
                             }>>;
-                            readonly width: OptionType<import("@elaraai/east").StringType>;
-                            readonly height: OptionType<import("@elaraai/east").StringType>;
-                            readonly minWidth: OptionType<import("@elaraai/east").StringType>;
-                            readonly minHeight: OptionType<import("@elaraai/east").StringType>;
-                            readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
-                            readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
-                            readonly padding: OptionType<StructType<{
-                                readonly top: OptionType<import("@elaraai/east").StringType>;
-                                readonly right: OptionType<import("@elaraai/east").StringType>;
-                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
-                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            readonly markers: ArrayType<StructType<{
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly lane: OptionType<StringType>;
+                                readonly status: VariantType<{
+                                    readonly success: NullType;
+                                    readonly warning: NullType;
+                                    readonly danger: NullType;
+                                    readonly info: NullType;
+                                    readonly neutral: NullType;
+                                }>;
+                                readonly message: StringType;
                             }>>;
-                            readonly margin: OptionType<StructType<{
-                                readonly top: OptionType<import("@elaraai/east").StringType>;
-                                readonly right: OptionType<import("@elaraai/east").StringType>;
-                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
-                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>;
+                        readonly chart: StructType<{
+                            readonly layers: ArrayType<VariantType<{
+                                readonly line: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly breach: OptionType<VariantType<{
+                                        readonly above: import("@elaraai/east").FloatType;
+                                        readonly below: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                }>;
+                                readonly area: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                }>;
+                                readonly column: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly series: OptionType<StringType>;
+                                    readonly breach: OptionType<VariantType<{
+                                        readonly above: import("@elaraai/east").FloatType;
+                                        readonly below: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                }>;
+                                readonly scatter: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly y: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                }>;
+                                readonly band: StructType<{
+                                    readonly points: ArrayType<StructType<{
+                                        readonly t: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly lo: import("@elaraai/east").FloatType;
+                                        readonly hi: import("@elaraai/east").FloatType;
+                                    }>>;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                }>;
+                                readonly refLine: StructType<{
+                                    readonly y: import("@elaraai/east").FloatType;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly label: OptionType<StringType>;
+                                }>;
+                                readonly refBand: StructType<{
+                                    readonly from: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly to: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly label: OptionType<StringType>;
+                                }>;
+                                readonly refDot: StructType<{
+                                    readonly t: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly y: import("@elaraai/east").FloatType;
+                                    readonly axis: VariantType<{
+                                        readonly left: NullType;
+                                        readonly right: NullType;
+                                    }>;
+                                    readonly label: OptionType<StringType>;
+                                }>;
                             }>>;
-                        }>>;
-                    }>>;
-                    readonly slice: StructType<{
-                        readonly key: import("@elaraai/east").StringType;
-                        readonly config: StructType<{
-                            readonly fields: ArrayType<StructType<{
-                                readonly fieldId: import("@elaraai/east").StringType;
-                                readonly label: import("@elaraai/east").StringType;
-                                readonly kind: import("@elaraai/east").StringType;
-                                readonly optional: import("@elaraai/east").BooleanType;
-                                readonly multiple: import("@elaraai/east").BooleanType;
-                                readonly set: import("@elaraai/east").BooleanType;
-                                readonly values: ArrayType<StructType<{
-                                    readonly value: import("@elaraai/east").StringType;
-                                    readonly label: import("@elaraai/east").StringType;
+                            readonly left: OptionType<StructType<{
+                                readonly domain: OptionType<VariantType<{
+                                    readonly number: StructType<{
+                                        readonly min: import("@elaraai/east").FloatType;
+                                        readonly max: import("@elaraai/east").FloatType;
+                                    }>;
+                                    readonly time: StructType<{
+                                        readonly min: DateTimeType;
+                                        readonly max: DateTimeType;
+                                    }>;
+                                }>>;
+                                readonly tickValues: OptionType<VariantType<{
+                                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                                    readonly time: ArrayType<DateTimeType>;
                                 }>>;
                                 readonly format: OptionType<VariantType<{
                                     readonly number: NullType;
                                     readonly currency: StructType<{
-                                        readonly code: import("@elaraai/east").StringType;
-                                        readonly compact: import("@elaraai/east").BooleanType;
+                                        readonly code: StringType;
+                                        readonly compact: BooleanType;
                                     }>;
                                     readonly percent: NullType;
                                     readonly compact: NullType;
-                                    readonly date: import("@elaraai/east").StringType;
-                                    readonly time: import("@elaraai/east").StringType;
-                                    readonly datetime: import("@elaraai/east").StringType;
+                                    readonly date: StringType;
+                                    readonly time: StringType;
+                                    readonly datetime: StringType;
                                 }>>;
                             }>>;
-                            readonly indexes: ArrayType<StructType<{
-                                readonly name: import("@elaraai/east").StringType;
-                                readonly fields: ArrayType<import("@elaraai/east").StringType>;
-                                readonly sets: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                                readonly structured: import("@elaraai/east").BooleanType;
-                                readonly interval: OptionType<StructType<{
-                                    readonly from: import("@elaraai/east").StringType;
-                                    readonly to: import("@elaraai/east").StringType;
-                                    readonly optional: import("@elaraai/east").BooleanType;
+                            readonly right: OptionType<StructType<{
+                                readonly domain: OptionType<VariantType<{
+                                    readonly number: StructType<{
+                                        readonly min: import("@elaraai/east").FloatType;
+                                        readonly max: import("@elaraai/east").FloatType;
+                                    }>;
+                                    readonly time: StructType<{
+                                        readonly min: DateTimeType;
+                                        readonly max: DateTimeType;
+                                    }>;
                                 }>>;
-                                readonly area: OptionType<StructType<{
-                                    readonly x: import("@elaraai/east").StringType;
-                                    readonly y: import("@elaraai/east").StringType;
-                                    readonly width: OptionType<import("@elaraai/east").StringType>;
-                                    readonly height: OptionType<import("@elaraai/east").StringType>;
-                                    readonly centre: import("@elaraai/east").BooleanType;
-                                    readonly cell: import("@elaraai/east").FloatType;
-                                    readonly optional: import("@elaraai/east").BooleanType;
+                                readonly tickValues: OptionType<VariantType<{
+                                    readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                                    readonly time: ArrayType<DateTimeType>;
                                 }>>;
-                                readonly series: OptionType<StructType<{
-                                    readonly key: import("@elaraai/east").StringType;
-                                    readonly from: import("@elaraai/east").StringType;
-                                    readonly to: import("@elaraai/east").StringType;
-                                    readonly tile: VariantType<{
-                                        readonly day: NullType;
-                                        readonly week: NullType;
-                                        readonly month: NullType;
-                                        readonly quarter: NullType;
-                                        readonly year: NullType;
+                                readonly format: OptionType<VariantType<{
+                                    readonly number: NullType;
+                                    readonly currency: StructType<{
+                                        readonly code: StringType;
+                                        readonly compact: BooleanType;
                                     }>;
+                                    readonly percent: NullType;
+                                    readonly compact: NullType;
+                                    readonly date: StringType;
+                                    readonly time: StringType;
+                                    readonly datetime: StringType;
                                 }>>;
-                                readonly summary: OptionType<StructType<{
-                                    readonly key: import("@elaraai/east").StringType;
-                                    readonly from: import("@elaraai/east").StringType;
-                                    readonly to: import("@elaraai/east").StringType;
-                                    readonly tile: VariantType<{
-                                        readonly day: NullType;
-                                        readonly week: NullType;
-                                        readonly month: NullType;
-                                        readonly quarter: NullType;
-                                        readonly year: NullType;
+                            }>>;
+                            readonly height: VariantType<{
+                                readonly spark: NullType;
+                                readonly expanded: NullType;
+                                readonly fixed: StringType;
+                            }>;
+                            readonly expandedHeight: OptionType<StringType>;
+                            readonly expandable: BooleanType;
+                        }>;
+                        readonly heat: StructType<{
+                            readonly cells: VariantType<{
+                                readonly heat: StructType<{
+                                    readonly cells: ArrayType<StructType<{
+                                        readonly at: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly value: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly label: OptionType<StringType>;
+                                    }>>;
+                                    readonly scale: StructType<{
+                                        readonly min: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly max: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+                                    }>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                }>;
+                                readonly weight: StructType<{
+                                    readonly cells: ArrayType<StructType<{
+                                        readonly at: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly fraction: import("@elaraai/east").FloatType;
+                                        readonly planned: BooleanType;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
+                                    }>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                }>;
+                                readonly segments: StructType<{
+                                    readonly cells: ArrayType<StructType<{
+                                        readonly at: VariantType<{
+                                            readonly time: DateTimeType;
+                                            readonly number: import("@elaraai/east").FloatType;
+                                            readonly ordinal: StringType;
+                                        }>;
+                                        readonly segments: ArrayType<StructType<{
+                                            readonly fill: VariantType<{
+                                                readonly brand: NullType;
+                                                readonly success: NullType;
+                                                readonly warning: NullType;
+                                                readonly danger: NullType;
+                                                readonly info: NullType;
+                                                readonly neutral: NullType;
+                                                readonly slack: NullType;
+                                                readonly free: NullType;
+                                            }>;
+                                            readonly weight: import("@elaraai/east").FloatType;
+                                            readonly label: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                    readonly fold: VariantType<{
+                                        readonly sum: NullType;
+                                        readonly mean: NullType;
+                                        readonly min: NullType;
+                                        readonly max: NullType;
+                                        readonly last: NullType;
+                                        readonly count: NullType;
                                     }>;
-                                }>>;
+                                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                }>;
+                            }>;
+                            readonly aggregate: OptionType<VariantType<{
+                                readonly mean: NullType;
+                                readonly max: NullType;
+                                readonly sum: NullType;
                             }>>;
-                            readonly range: OptionType<import("@elaraai/east").StringType>;
-                            readonly search: ArrayType<import("@elaraai/east").StringType>;
-                            readonly presets: ArrayType<StructType<{
-                                readonly id: import("@elaraai/east").StringType;
-                                readonly name: import("@elaraai/east").StringType;
-                                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
-                                    readonly values: ArrayType<import("@elaraai/east").StringType>;
-                                    readonly range: StructType<{
-                                        readonly from: import("@elaraai/east").StringType;
-                                        readonly to: import("@elaraai/east").StringType;
-                                    }>;
-                                    readonly prefix: import("@elaraai/east").StringType;
-                                    readonly window: StructType<{
-                                        readonly minX: import("@elaraai/east").FloatType;
-                                        readonly minY: import("@elaraai/east").FloatType;
-                                        readonly maxX: import("@elaraai/east").FloatType;
-                                        readonly maxY: import("@elaraai/east").FloatType;
+                            readonly scale: OptionType<StructType<{
+                                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                                readonly max: OptionType<import("@elaraai/east").FloatType>;
+                                readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+                            }>>;
+                        }>;
+                        readonly table: StructType<{
+                            readonly series: ArrayType<StructType<{
+                                readonly cells: ArrayType<StructType<{
+                                    readonly at: VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
                                     }>;
+                                    readonly value: OptionType<import("@elaraai/east").FloatType>;
+                                    readonly text: OptionType<StringType>;
+                                    readonly tone: OptionType<VariantType<{
+                                        readonly neg: NullType;
+                                        readonly muted: NullType;
+                                    }>>;
+                                }>>;
+                                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                                readonly tone: OptionType<VariantType<{
+                                    readonly neg: NullType;
+                                    readonly muted: NullType;
                                 }>>;
+                                readonly strong: BooleanType;
+                                readonly rollup: BooleanType;
+                                readonly fold: VariantType<{
+                                    readonly sum: NullType;
+                                    readonly mean: NullType;
+                                    readonly min: NullType;
+                                    readonly max: NullType;
+                                    readonly last: NullType;
+                                    readonly count: NullType;
+                                }>;
+                            }>>;
+                            readonly split: VariantType<{
+                                readonly horizontal: NullType;
+                                readonly vertical: NullType;
+                            }>;
+                            readonly aggregate: OptionType<VariantType<{
+                                readonly sum: NullType;
+                                readonly mean: NullType;
+                                readonly min: NullType;
+                                readonly max: NullType;
+                                readonly count: NullType;
                             }>>;
+                            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                            readonly emphasis: VariantType<{
+                                readonly body: NullType;
+                                readonly header: NullType;
+                                readonly footer: NullType;
+                            }>;
                         }>;
-                        readonly read: import("@elaraai/east").FunctionType<[], StructType<{
-                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
-                                readonly values: ArrayType<import("@elaraai/east").StringType>;
-                                readonly range: StructType<{
-                                    readonly from: import("@elaraai/east").StringType;
-                                    readonly to: import("@elaraai/east").StringType;
+                        readonly cards: StructType<{
+                            readonly chips: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly from: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
                                 }>;
-                                readonly prefix: import("@elaraai/east").StringType;
-                                readonly window: StructType<{
-                                    readonly minX: import("@elaraai/east").FloatType;
-                                    readonly minY: import("@elaraai/east").FloatType;
-                                    readonly maxX: import("@elaraai/east").FloatType;
-                                    readonly maxY: import("@elaraai/east").FloatType;
+                                readonly to: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
                                 }>;
+                                readonly label: StringType;
+                                readonly state: VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
                             }>>;
-                            readonly preset: OptionType<import("@elaraai/east").StringType>;
-                            readonly resolution: OptionType<VariantType<{
-                                readonly auto: NullType;
-                                readonly hour: NullType;
-                                readonly day: NullType;
-                                readonly week: NullType;
-                                readonly month: NullType;
-                                readonly quarter: NullType;
-                                readonly year: NullType;
-                            }>>;
-                        }>>;
-                        readonly write: import("@elaraai/east").FunctionType<[StructType<{
-                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
-                                readonly values: ArrayType<import("@elaraai/east").StringType>;
-                                readonly range: StructType<{
-                                    readonly from: import("@elaraai/east").StringType;
-                                    readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly events: StructType<{
+                            readonly marks: ArrayType<StructType<{
+                                readonly key: StringType;
+                                readonly at: VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
                                 }>;
-                                readonly prefix: import("@elaraai/east").StringType;
-                                readonly window: StructType<{
-                                    readonly minX: import("@elaraai/east").FloatType;
-                                    readonly minY: import("@elaraai/east").FloatType;
-                                    readonly maxX: import("@elaraai/east").FloatType;
-                                    readonly maxY: import("@elaraai/east").FloatType;
+                                readonly kind: VariantType<{
+                                    readonly milestone: NullType;
+                                    readonly decision: StructType<{
+                                        readonly applied: BooleanType;
+                                    }>;
+                                    readonly exception: NullType;
                                 }>;
+                                readonly icon: OptionType<StructType<{
+                                    readonly name: StringType;
+                                    readonly prefix: StringType;
+                                    readonly label: OptionType<StringType>;
+                                    readonly style: OptionType<StructType<{
+                                        readonly size: OptionType<VariantType<{
+                                            readonly xs: NullType;
+                                            readonly sm: NullType;
+                                            readonly md: NullType;
+                                            readonly lg: NullType;
+                                            readonly xl: NullType;
+                                            readonly "2xl": NullType;
+                                        }>>;
+                                        readonly variant: OptionType<VariantType<{
+                                            readonly solid: NullType;
+                                        }>>;
+                                        readonly color: OptionType<StringType>;
+                                        readonly background: OptionType<StringType>;
+                                        readonly colorPalette: OptionType<VariantType<{
+                                            readonly brand: NullType;
+                                            readonly gray: NullType;
+                                            readonly red: NullType;
+                                            readonly orange: NullType;
+                                            readonly yellow: NullType;
+                                            readonly green: NullType;
+                                            readonly teal: NullType;
+                                            readonly blue: NullType;
+                                            readonly cyan: NullType;
+                                            readonly purple: NullType;
+                                            readonly pink: NullType;
+                                            readonly success: NullType;
+                                            readonly warning: NullType;
+                                            readonly danger: NullType;
+                                            readonly info: NullType;
+                                            readonly neutral: NullType;
+                                        }>>;
+                                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                                        readonly borderRadius: OptionType<StringType>;
+                                        readonly overflow: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowX: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly overflowY: OptionType<VariantType<{
+                                            readonly visible: NullType;
+                                            readonly hidden: NullType;
+                                            readonly scroll: NullType;
+                                            readonly auto: NullType;
+                                        }>>;
+                                        readonly width: OptionType<StringType>;
+                                        readonly height: OptionType<StringType>;
+                                        readonly minWidth: OptionType<StringType>;
+                                        readonly minHeight: OptionType<StringType>;
+                                        readonly maxWidth: OptionType<StringType>;
+                                        readonly maxHeight: OptionType<StringType>;
+                                        readonly padding: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                        readonly margin: OptionType<StructType<{
+                                            readonly top: OptionType<StringType>;
+                                            readonly right: OptionType<StringType>;
+                                            readonly bottom: OptionType<StringType>;
+                                            readonly left: OptionType<StringType>;
+                                        }>>;
+                                    }>>;
+                                }>>;
+                                readonly label: OptionType<StringType>;
                             }>>;
-                            readonly preset: OptionType<import("@elaraai/east").StringType>;
-                            readonly resolution: OptionType<VariantType<{
-                                readonly auto: NullType;
-                                readonly hour: NullType;
-                                readonly day: NullType;
-                                readonly week: NullType;
-                                readonly month: NullType;
-                                readonly quarter: NullType;
-                                readonly year: NullType;
-                            }>>;
-                        }>], NullType>;
-                        readonly choose: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, ArrayType<import("@elaraai/east").StringType>], NullType>;
-                        readonly range: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
-                        readonly prefix: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
-                        readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
-                        readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
-                        readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
-                        readonly countWhere: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
-                            readonly values: ArrayType<import("@elaraai/east").StringType>;
-                            readonly range: StructType<{
-                                readonly from: import("@elaraai/east").StringType;
-                                readonly to: import("@elaraai/east").StringType;
-                            }>;
-                            readonly prefix: import("@elaraai/east").StringType;
-                            readonly window: StructType<{
-                                readonly minX: import("@elaraai/east").FloatType;
-                                readonly minY: import("@elaraai/east").FloatType;
-                                readonly maxX: import("@elaraai/east").FloatType;
-                                readonly maxY: import("@elaraai/east").FloatType;
-                            }>;
-                        }>>], OptionType<import("@elaraai/east").IntegerType>>;
-                        readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
-                        readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
-                            readonly from: import("@elaraai/east").StringType;
-                            readonly to: import("@elaraai/east").StringType;
-                        }>>>;
-                        readonly values: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<StructType<{
-                            readonly value: import("@elaraai/east").StringType;
-                            readonly label: import("@elaraai/east").StringType;
-                            readonly count: OptionType<import("@elaraai/east").IntegerType>;
-                            readonly selected: import("@elaraai/east").BooleanType;
-                            readonly error: OptionType<import("@elaraai/east").StringType>;
-                        }>>>;
-                        readonly suggest: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], OptionType<ArrayType<StructType<{
-                            readonly value: import("@elaraai/east").StringType;
-                            readonly label: import("@elaraai/east").StringType;
-                            readonly count: OptionType<import("@elaraai/east").IntegerType>;
-                            readonly selected: import("@elaraai/east").BooleanType;
-                            readonly error: OptionType<import("@elaraai/east").StringType>;
-                        }>>>>;
-                        readonly replaces: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<import("@elaraai/east").StringType>>;
-                        readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
-                        readonly setResolution: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
-                            readonly auto: NullType;
-                            readonly hour: NullType;
-                            readonly day: NullType;
-                            readonly week: NullType;
-                            readonly month: NullType;
-                            readonly quarter: NullType;
-                            readonly year: NullType;
-                        }>>], NullType>;
-                        readonly retry: import("@elaraai/east").FunctionType<[], NullType>;
-                        readonly sourceId: import("@elaraai/east").StringType;
-                        readonly readEntry: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<OptionType<import("@elaraai/east").BlobType>>>;
-                        readonly contains: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
-                            readonly values: ArrayType<import("@elaraai/east").StringType>;
-                            readonly range: StructType<{
-                                readonly from: import("@elaraai/east").StringType;
-                                readonly to: import("@elaraai/east").StringType;
-                            }>;
-                            readonly prefix: import("@elaraai/east").StringType;
-                            readonly window: StructType<{
-                                readonly minX: import("@elaraai/east").FloatType;
-                                readonly minY: import("@elaraai/east").FloatType;
-                                readonly maxX: import("@elaraai/east").FloatType;
-                                readonly maxY: import("@elaraai/east").FloatType;
-                            }>;
-                        }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
-                        readonly containsRow: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
-                            readonly values: ArrayType<import("@elaraai/east").StringType>;
-                            readonly range: StructType<{
-                                readonly from: import("@elaraai/east").StringType;
-                                readonly to: import("@elaraai/east").StringType;
-                            }>;
-                            readonly prefix: import("@elaraai/east").StringType;
-                            readonly window: StructType<{
-                                readonly minX: import("@elaraai/east").FloatType;
-                                readonly minY: import("@elaraai/east").FloatType;
-                                readonly maxX: import("@elaraai/east").FloatType;
-                                readonly maxY: import("@elaraai/east").FloatType;
-                            }>;
-                        }>>, import("@elaraai/east").StringType, import("@elaraai/east").BlobType], OptionType<import("@elaraai/east").BooleanType>>;
+                        }>;
+                    }>;
+                    readonly collapsed: BooleanType;
+                    readonly pinned: BooleanType;
+                    readonly height: OptionType<StringType>;
+                    readonly status: OptionType<VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly expand: OptionType<StructType<{
+                        readonly height: OptionType<StringType>;
+                        readonly axis: VariantType<{
+                            readonly keep: NullType;
+                            readonly dim: NullType;
+                            readonly off: NullType;
+                        }>;
+                    }>>;
+                    readonly edits: StructType<{
+                        readonly drop: BooleanType;
+                        readonly move: OptionType<StructType<{
+                            readonly items: StringType;
+                            readonly resize: BooleanType;
+                        }>>;
+                        readonly values: ArrayType<StructType<{
+                            readonly position: IntegerType;
+                            readonly whole: BooleanType;
+                        }>>;
                     }>;
                 }>>;
-                readonly presets: ArrayType<StructType<{
-                    readonly id: import("@elaraai/east").StringType;
-                    readonly name: import("@elaraai/east").StringType;
-                }>>;
-                readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
-                readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
-            }>;
-            readonly affordances: ArrayType<VariantType<{
-                readonly fields: NullType;
-                readonly search: NullType;
-                readonly range: NullType;
-                readonly presets: NullType;
-                readonly resolution: NullType;
-                readonly brush: NullType;
-                readonly summary: NullType;
-            }>>;
-            readonly persist: OptionType<VariantType<{
-                readonly local: NullType;
-                readonly session: NullType;
-                readonly url: NullType;
-            }>>;
+            }>>>>;
         }>>;
         readonly footer: ArrayType<StructType<{
             readonly text: StringType;
@@ -8267,6 +10402,9 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             readonly end: StringType;
             readonly resource: OptionType<StringType>;
             readonly status: OptionType<StringType>;
+            readonly quantity: OptionType<StringType>;
+            readonly parts: OptionType<StringType>;
+            readonly withTimes: ArrayType<StringType>;
         }>;
         readonly seriesKey: FunctionType<[OptionType<StructType<{
             readonly kind: StringType;
@@ -9331,6 +11469,10 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                     readonly items: StringType;
                     readonly resize: BooleanType;
                 }>>;
+                readonly values: ArrayType<StructType<{
+                    readonly position: IntegerType;
+                    readonly whole: BooleanType;
+                }>>;
             }>;
         }>>;
     }>>>>>;
@@ -10596,6 +12738,10 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                         readonly items: StringType;
                         readonly resize: BooleanType;
                     }>>;
+                    readonly values: ArrayType<StructType<{
+                        readonly position: IntegerType;
+                        readonly whole: BooleanType;
+                    }>>;
                 }>;
             }>>;
         }>>>>;
@@ -10860,11 +13006,23 @@ export type PlanRowsItem<K extends PlanAxisKindLiteral = never> = PlanRowsValue<
  * hand-built row must lie within it (a `"time"` series on a `"number"` axis
  * fails to compile here), and event kinds need a time axis.
  *
+ * Its `series` is held to its rows' nested series index too (#1435): beside
+ * `data` or a `slice` whose `rows` source lists one
+ * (`Data.bindPaged(record, { indexes })`), a series reading a collection the
+ * index does not declare, by other times than it files by, items as values or
+ * values as items, a subtotal by a rollup it does not keep, or runs rolled up
+ * that it files under no parent, fails to compile here, the refusal in words.
+ *
  * @typeParam K - The canvas's axis kind, inferred from `axis`
+ * @typeParam D - The `data` prop's type, inferred: what the rows' nested series index declares, where it lists one
+ * @typeParam S - The `slice` prop's type, inferred: its `rows` source's declarations, where it has one
+ * @typeParam L - The `series` prop's type, inferred: held to the declarations ({@link PlanNestedChecked})
  */
-export interface PlanProps<K extends PlanAxisKindLiteral = PlanAxisKindLiteral> extends Omit<PlanConfig<K>, "data" | "canDrop"> {
+export interface PlanProps<K extends PlanAxisKindLiteral = PlanAxisKindLiteral, D = unknown, S = unknown, L = unknown> extends Omit<PlanConfig<K>, "data" | "canDrop" | "series"> {
     /** The rows' source — a keyed collection, a bind handle over one or a paged source of one, laid out by `series` or `pick` (see {@link PlanConfig}). Leave it out for a Plan of event kinds or `rows` alone, and beside `slice`'s `rows` source, which gives the rows. */
-    data?: PlanConfig<K>["data"];
+    data?: D & PlanConfig<K>["data"];
+    /** The row series over the rows (see {@link PlanConfig}), each held to the rows' nested series index where they carry one (#1435). */
+    series?: L & PlanSeriesInput<NoInfer<K>> & PlanNestedChecked<NoInfer<L>, NoInfer<PlanRowsNestedOf<D, S>>>;
     /**
      * The narrowing (#1344): `slice={{ slice: Slice.bindRecords(key, { rows, … }) }}`, one rail on the toolbar, with
      * its `affordances` and `persist`. Its `rows` source gives the canvas its rows, paged from it in its index's order —
@@ -10882,7 +13040,7 @@ export interface PlanProps<K extends PlanAxisKindLiteral = PlanAxisKindLiteral>
      * the footer's counts, the overlaps — read every event. `Slice.bind`, a single `Slice.bindRecord` and a source
      * nothing names are refused.
      */
-    slice?: RecordSlicesChromeOptions;
+    slice?: S & RecordSlicesChromeOptions;
     /** The resource kinds, by slot — `Schedule.resources(rows, { … })`, or a paged read of them: the rows events are placed on, in this order. */
     resources?: Readonly<Record<string, ScheduleResourceKind<EastType, EastType>>>;
     /** The event kinds, by slot — `Schedule.events(record, { … })`, each a record of its own: at least one, when given. An event is scheduled in time, so they need a time axis. */
@@ -10975,10 +13133,13 @@ export declare function createPlanPayload(props: PlanProps): ExprType<PlanPayloa
  * `optionsTag(...)`, whose props would fix `K` at every kind.
  *
  * @typeParam K - The canvas's axis kind, inferred from `axis`
+ * @typeParam D - The `data` prop's type, inferred
+ * @typeParam S - The `slice` prop's type, inferred
+ * @typeParam L - The `series` prop's type, inferred, held to the rows' nested series index (#1435)
  * @param props - The Plan's props ({@link PlanProps})
  * @returns The Plan — the `Plan` carrier over its payload
  */
-export declare function PlanTag<K extends PlanAxisKindLiteral = PlanAxisKindLiteral>(props: PlanProps<K>): UIElement;
+export declare function PlanTag<K extends PlanAxisKindLiteral = PlanAxisKindLiteral, D = unknown, S = unknown, L = unknown>(props: PlanProps<K, D, S, L>): UIElement;
 /** The type of `<Plan>` as a tag. */
 export type PlanTagType = typeof PlanTag;
 //# sourceMappingURL=plan.d.ts.map