@elaraai/e3-ui 1.0.85 → 1.0.87

package/dist/src/plan/event-rows.d.ts

@@ -0,0 +1,2565 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Events into rows (#1192, `Plan Builder Spec.md` §9.4, PB12–PB18): the
+ * resources' rows a Plan of event kinds draws over a window, every kind's
+ * drafts in place — the payload's `blocks`.
+ *
+ * The rows are series' rows (#822), with the events joined in, so they are
+ * derived the way every other row of the canvas is. Each resource kind is a
+ * `Plan.series.views` over its resources: one member per way the event kinds
+ * placed on it draw (bars, tiles, chips, marks, in that order), each element
+ * an event in the window wearing its kind's icon, then the kind's measures,
+ * each applied to the resource's row (PB12, PB13). A resource that names
+ * another of its kind as its parent nests under it, and the parent's bars roll
+ * its children's up (PB14, #1219); a kind with `group` sits under its group
+ * strips. A row's id is its series' key and its path (PB15):
+ * `entry { series: "<kind>.<draw>", path: [group?, …parents, key] }`, a
+ * measure's its own key, a strip's `"<kind>.group"`.
+ *
+ * An event whose resource is none, or names a resource its kind does not have,
+ * draws on its kind's Unassigned row, after every resource kind (PB16). Every
+ * kind's events are read with its drafts in place, so a draft draws as Save
+ * would leave it (PB17).
+ *
+ * Every block is fixed: no entry of the canvas's `data` makes these rows, so a
+ * paged canvas serves them with every window and draws them once.
+ *
+ * What a viewer hides in the library's Series tab stays out (PB29, #1195): a
+ * hidden event kind is not read, so its elements draw nowhere, its Unassigned
+ * row included, and a row only hidden kinds draw on goes with them; a hidden
+ * resource kind draws no rows; a hidden measure no row under each resource. A
+ * resource's first row is its own, and stays while its kind shows.
+ *
+ * A resource kind given its resources as a paged read (#1199, PB55) is PAGED,
+ * as a paged canvas pages its blocks: its rows come a window of resources at a
+ * time as the canvas scrolls, through the payload's `paged`
+ * ({@link createEventPaged}), and the key search seeks a resource by its key. The `blocks` seam keeps its
+ * place among the kinds' blocks with an empty paged block (`fixed: false`,
+ * the one block it serves that is not fixed) and never reads its resources;
+ * the events placed on them are read with the rest, by way of drawing and by
+ * the resource's key (`placed`), and each window of its resources draws the
+ * ones placed on it (`rows`). An event on a paged kind is never on the
+ * Unassigned row: whether the kind has its resource would take every window
+ * to know, so an event naming a resource it has not draws nowhere.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BooleanType, DateTimeType, DictType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, type EastType, type ExprType } from "@elaraai/east";
+import { PlanEventKindType } from "../schedule/types.js";
+import type { ScheduleEventKind } from "../schedule/events.js";
+import type { ScheduleResourceKind } from "../schedule/resources.js";
+import { type PlanDrawLiteral } from "./types.js";
+/**
+ * Every event kind's drafts, by the kind's slot, then by entry id — each the
+ * entry's draft as bytes, as a kind's seams read them.
+ */
+export declare const PlanEventDraftsType: DictType<StringType, DictType<StringType, import("@elaraai/east").BlobType>>;
+/** Type representing {@link PlanEventDraftsType}. */
+export type PlanEventDraftsType = typeof PlanEventDraftsType;
+/**
+ * The resources' rows over a window, every event kind's drafts in place
+ * (#1192): `(from, to, drafts by kind, then by entry id, the ids the viewer
+ * hides)` → the canvas's blocks, `none` while a kind's read is in flight. The
+ * hidden ids are the library's Series tab's (#1195): `resources.<slot>`,
+ * `events.<slot>` and `measures.<key>` stay out, and the rest are not this
+ * seam's. A paged resource kind's place (#1199) is an empty block that is not
+ * fixed, which the payload's `paged` fills a window at a time.
+ */
+export declare const PlanEventBlocksType: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<ArrayType<StructType<{
+    readonly fixed: BooleanType;
+    readonly parent: OptionType<import("@elaraai/east").VariantType<{
+        readonly entry: StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+        readonly section: StructType<{
+            readonly series: StringType;
+            readonly path: ArrayType<StringType>;
+        }>;
+    }>>;
+    readonly rows: ArrayType<StructType<{
+        readonly id: import("@elaraai/east").VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>;
+        readonly parent: OptionType<import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+            readonly group: StructType<{
+                readonly summary: import("@elaraai/east").VariantType<{
+                    readonly none: NullType;
+                    readonly cells: import("@elaraai/east").VariantType<{
+                        readonly heat: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly fraction: import("@elaraai/east").FloatType;
+                                readonly planned: BooleanType;
+                            }>>;
+                            readonly fold: import("@elaraai/east").VariantType<{
+                                readonly sum: 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: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly segments: ArrayType<StructType<{
+                                    readonly fill: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                        readonly mean: NullType;
+                        readonly max: NullType;
+                        readonly sum: NullType;
+                    }>;
+                }>;
+            }>;
+            readonly span: StructType<{
+                readonly runs: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly end: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<import("@elaraai/east").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<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 decisions: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly applied: BooleanType;
+                }>>;
+                readonly ports: ArrayType<StructType<{
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: OptionType<StringType>;
+                }>>;
+                readonly rollup: OptionType<import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<import("@elaraai/east").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<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 state: import("@elaraai/east").VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
+                    readonly color: OptionType<StringType>;
+                    readonly colorPalette: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                        readonly horizontal: NullType;
+                        readonly vertical: NullType;
+                        readonly both: NullType;
+                    }>>;
+                    readonly content: OptionType<StructType<{
+                        readonly horizontal: OptionType<import("@elaraai/east").VariantType<{
+                            readonly start: NullType;
+                            readonly center: NullType;
+                            readonly end: NullType;
+                        }>>;
+                        readonly vertical: OptionType<import("@elaraai/east").VariantType<{
+                            readonly start: NullType;
+                            readonly center: NullType;
+                            readonly end: NullType;
+                        }>>;
+                    }>>;
+                    readonly animation: OptionType<import("@elaraai/east").VariantType<{
+                        readonly none: NullType;
+                        readonly pulse: NullType;
+                    }>>;
+                }>>;
+                readonly markers: ArrayType<StructType<{
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly lane: OptionType<StringType>;
+                    readonly status: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                    readonly line: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: import("@elaraai/east").FloatType;
+                        }>>;
+                        readonly axis: import("@elaraai/east").VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly breach: OptionType<import("@elaraai/east").VariantType<{
+                            readonly above: import("@elaraai/east").FloatType;
+                            readonly below: import("@elaraai/east").FloatType;
+                        }>>;
+                        readonly fold: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: import("@elaraai/east").FloatType;
+                        }>>;
+                        readonly axis: import("@elaraai/east").VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly fold: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: import("@elaraai/east").FloatType;
+                        }>>;
+                        readonly axis: import("@elaraai/east").VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly series: OptionType<StringType>;
+                        readonly breach: OptionType<import("@elaraai/east").VariantType<{
+                            readonly above: import("@elaraai/east").FloatType;
+                            readonly below: import("@elaraai/east").FloatType;
+                        }>>;
+                        readonly fold: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: import("@elaraai/east").FloatType;
+                        }>>;
+                        readonly axis: import("@elaraai/east").VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                    }>;
+                    readonly band: StructType<{
+                        readonly points: ArrayType<StructType<{
+                            readonly t: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                    }>;
+                    readonly refLine: StructType<{
+                        readonly y: import("@elaraai/east").FloatType;
+                        readonly axis: import("@elaraai/east").VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                    readonly refBand: StructType<{
+                        readonly from: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly to: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                    readonly refDot: StructType<{
+                        readonly t: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly y: import("@elaraai/east").FloatType;
+                        readonly axis: import("@elaraai/east").VariantType<{
+                            readonly left: NullType;
+                            readonly right: NullType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>;
+                }>>;
+                readonly left: OptionType<StructType<{
+                    readonly domain: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                        readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                        readonly time: ArrayType<DateTimeType>;
+                    }>>;
+                    readonly format: OptionType<import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                        readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                        readonly time: ArrayType<DateTimeType>;
+                    }>>;
+                    readonly format: OptionType<import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                    readonly spark: NullType;
+                    readonly expanded: NullType;
+                    readonly fixed: StringType;
+                }>;
+                readonly expandedHeight: OptionType<StringType>;
+                readonly expandable: BooleanType;
+            }>;
+            readonly heat: StructType<{
+                readonly cells: import("@elaraai/east").VariantType<{
+                    readonly heat: StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly fraction: import("@elaraai/east").FloatType;
+                            readonly planned: BooleanType;
+                        }>>;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: 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: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly segments: ArrayType<StructType<{
+                                readonly fill: import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                            readonly neg: NullType;
+                            readonly muted: NullType;
+                        }>>;
+                    }>>;
+                    readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                    readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                        readonly neg: NullType;
+                        readonly muted: NullType;
+                    }>>;
+                    readonly strong: BooleanType;
+                    readonly rollup: BooleanType;
+                    readonly fold: import("@elaraai/east").VariantType<{
+                        readonly sum: NullType;
+                        readonly mean: NullType;
+                        readonly min: NullType;
+                        readonly max: NullType;
+                        readonly last: NullType;
+                        readonly count: NullType;
+                    }>;
+                }>>;
+                readonly split: import("@elaraai/east").VariantType<{
+                    readonly horizontal: NullType;
+                    readonly vertical: NullType;
+                }>;
+                readonly aggregate: OptionType<import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                    readonly body: NullType;
+                    readonly header: NullType;
+                    readonly footer: NullType;
+                }>;
+            }>;
+            readonly cards: StructType<{
+                readonly chips: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly from: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly to: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly label: StringType;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<import("@elaraai/east").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<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 events: StructType<{
+                readonly marks: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                    readonly kind: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<StringType>;
+                            readonly background: OptionType<StringType>;
+                            readonly colorPalette: OptionType<import("@elaraai/east").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<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 label: OptionType<StringType>;
+                }>>;
+            }>;
+        }>;
+        readonly collapsed: BooleanType;
+        readonly pinned: BooleanType;
+        readonly height: OptionType<StringType>;
+        readonly status: OptionType<import("@elaraai/east").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: import("@elaraai/east").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;
+            }>>;
+        }>;
+    }>>;
+}>>>>;
+/** Type representing {@link PlanEventBlocksType}. */
+export type PlanEventBlocksType = typeof PlanEventBlocksType;
+/** A resource kind, its types erased. */
+type AnyResourceKind = ScheduleResourceKind<EastType, EastType>;
+/** An event kind, its types erased. */
+type AnyEventKind = ScheduleEventKind<EastType, EastType>;
+/**
+ * The ways the event kinds placed on a resource kind draw, in the order its
+ * rows take them.
+ *
+ * @param slot - The resource kind's slot
+ * @param events - The event kinds, by slot
+ * @returns The draw styles, each once
+ */
+export declare function eventDrawsOf(slot: string, events: readonly (readonly [string, AnyEventKind])[]): readonly PlanDrawLiteral[];
+/**
+ * The events placed on a paged resource kind's resources (#1199): by the way
+ * they draw (`span`, `buckets`, `cards`, `marks`), then by the resource key's
+ * text — each event as Plan draws it, its two times and its kind's icon. What
+ * each window of the kind's resources draws on its rows.
+ */
+export declare const PlanEventPlacedType: DictType<StringType, DictType<StringType, ArrayType<StructType<{
+    readonly item: StructType<{
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+        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 lane: OptionType<StringType>;
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: import("@elaraai/east").VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly icon: StructType<{
+        readonly name: StringType;
+        readonly prefix: StringType;
+        readonly label: OptionType<StringType>;
+        readonly style: OptionType<StructType<{
+            readonly size: OptionType<import("@elaraai/east").VariantType<{
+                readonly xs: NullType;
+                readonly sm: NullType;
+                readonly md: NullType;
+                readonly lg: NullType;
+                readonly xl: NullType;
+                readonly "2xl": NullType;
+            }>>;
+            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                readonly solid: NullType;
+            }>>;
+            readonly color: OptionType<StringType>;
+            readonly background: OptionType<StringType>;
+            readonly colorPalette: OptionType<import("@elaraai/east").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<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>;
+            }>>;
+        }>>;
+    }>;
+}>>>>;
+/** Type representing {@link PlanEventPlacedType}. */
+export type PlanEventPlacedType = typeof PlanEventPlacedType;
+/**
+ * The `blocks` seam (see the module docs): `(from, to, drafts, hidden)` → the
+ * resources' rows over `[from, to)`, every kind's drafts in place, what the
+ * viewer hides left out.
+ *
+ * @remarks
+ * Made inside the function that assembles the payload, so `built` is the
+ * payload's own array of event kinds: the seam captures it, and the payload
+ * carries each kind once.
+ *
+ * @param resources - The resource kinds, by slot, in order
+ * @param events - The event kinds, by slot, in order
+ * @param built - The event kinds as the payload holds them, in the same order
+ * @returns The seam
+ * @internal
+ */
+export declare function createEventBlocks(resources: readonly (readonly [string, AnyResourceKind])[], events: readonly (readonly [string, AnyEventKind])[], built: ExprType<ArrayType<PlanEventKindType>>): ExprType<PlanEventBlocksType>;
+/**
+ * A paged resource kind's rows (#1199, PB55): its resources a window at a
+ * time, as a paged canvas pages its blocks. The renderer reads `placed` over
+ * the range it draws with the `blocks` seam, and serves the canvas a paged
+ * source whose every window is the event kinds' blocks with this kind's place
+ * filled by `rows` over that window of its resources — so its rows come as
+ * the canvas scrolls, its key search seeks a resource by its key, and its
+ * resources are never read whole.
+ *
+ * @property kind - The paged resource kind's slot
+ * @property id - The identity of the kind's resources' window
+ * @property placed - `(from, to, drafts by kind, the ids the viewer hides)` → the events placed on the kind's resources over `[from, to)`, every kind's drafts in place, by way of drawing and by the resource key's text; `none` while a kind's read is in flight
+ * @property rows - `(offset, limit, placed, the ids the viewer hides)` → the kind's rows for its resources `[offset, offset + limit)` — a whole window of them — with the events given placed on them: one block, not fixed (an empty one while the viewer hides the kind); `none` while the window is in flight
+ * @property total - How many resources the kind has, once known
+ * @property seek - Where a key search lands among the kind's resources: the window's own key search
+ * @property revision - The snapshot of the resources the windows are read at
+ * @property refresh - Moves the resources' window to a snapshot, or to the one it holds now
+ */
+export declare const PlanEventPagedType: StructType<{
+    readonly kind: StringType;
+    readonly id: StringType;
+    readonly placed: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<DictType<StringType, DictType<StringType, ArrayType<StructType<{
+        readonly item: StructType<{
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+            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 lane: OptionType<StringType>;
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: import("@elaraai/east").VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly icon: StructType<{
+            readonly name: StringType;
+            readonly prefix: StringType;
+            readonly label: OptionType<StringType>;
+            readonly style: OptionType<StructType<{
+                readonly size: OptionType<import("@elaraai/east").VariantType<{
+                    readonly xs: NullType;
+                    readonly sm: NullType;
+                    readonly md: NullType;
+                    readonly lg: NullType;
+                    readonly xl: NullType;
+                    readonly "2xl": NullType;
+                }>>;
+                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                    readonly solid: NullType;
+                }>>;
+                readonly color: OptionType<StringType>;
+                readonly background: OptionType<StringType>;
+                readonly colorPalette: OptionType<import("@elaraai/east").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<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 rows: FunctionType<[IntegerType, IntegerType, DictType<StringType, DictType<StringType, ArrayType<StructType<{
+        readonly item: StructType<{
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+            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 lane: OptionType<StringType>;
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: import("@elaraai/east").VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly icon: StructType<{
+            readonly name: StringType;
+            readonly prefix: StringType;
+            readonly label: OptionType<StringType>;
+            readonly style: OptionType<StructType<{
+                readonly size: OptionType<import("@elaraai/east").VariantType<{
+                    readonly xs: NullType;
+                    readonly sm: NullType;
+                    readonly md: NullType;
+                    readonly lg: NullType;
+                    readonly xl: NullType;
+                    readonly "2xl": NullType;
+                }>>;
+                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                    readonly solid: NullType;
+                }>>;
+                readonly color: OptionType<StringType>;
+                readonly background: OptionType<StringType>;
+                readonly colorPalette: OptionType<import("@elaraai/east").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<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>;
+                }>>;
+            }>>;
+        }>;
+    }>>>>, ArrayType<StringType>], OptionType<ArrayType<StructType<{
+        readonly fixed: BooleanType;
+        readonly parent: OptionType<import("@elaraai/east").VariantType<{
+            readonly entry: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+            readonly section: StructType<{
+                readonly series: StringType;
+                readonly path: ArrayType<StringType>;
+            }>;
+        }>>;
+        readonly rows: ArrayType<StructType<{
+            readonly id: import("@elaraai/east").VariantType<{
+                readonly entry: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+                readonly section: StructType<{
+                    readonly series: StringType;
+                    readonly path: ArrayType<StringType>;
+                }>;
+            }>;
+            readonly parent: OptionType<import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                readonly group: StructType<{
+                    readonly summary: import("@elaraai/east").VariantType<{
+                        readonly none: NullType;
+                        readonly cells: import("@elaraai/east").VariantType<{
+                            readonly heat: StructType<{
+                                readonly cells: ArrayType<StructType<{
+                                    readonly at: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly fraction: import("@elaraai/east").FloatType;
+                                    readonly planned: BooleanType;
+                                }>>;
+                                readonly fold: import("@elaraai/east").VariantType<{
+                                    readonly sum: 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: import("@elaraai/east").VariantType<{
+                                        readonly time: DateTimeType;
+                                        readonly number: import("@elaraai/east").FloatType;
+                                        readonly ordinal: StringType;
+                                    }>;
+                                    readonly segments: ArrayType<StructType<{
+                                        readonly fill: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                            readonly mean: NullType;
+                            readonly max: NullType;
+                            readonly sum: NullType;
+                        }>;
+                    }>;
+                }>;
+                readonly span: StructType<{
+                    readonly runs: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly start: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly end: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<import("@elaraai/east").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<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 decisions: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly applied: BooleanType;
+                    }>>;
+                    readonly ports: ArrayType<StructType<{
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly rollup: OptionType<import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<import("@elaraai/east").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<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 state: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly color: OptionType<StringType>;
+                        readonly colorPalette: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                            readonly horizontal: NullType;
+                            readonly vertical: NullType;
+                            readonly both: NullType;
+                        }>>;
+                        readonly content: OptionType<StructType<{
+                            readonly horizontal: OptionType<import("@elaraai/east").VariantType<{
+                                readonly start: NullType;
+                                readonly center: NullType;
+                                readonly end: NullType;
+                            }>>;
+                            readonly vertical: OptionType<import("@elaraai/east").VariantType<{
+                                readonly start: NullType;
+                                readonly center: NullType;
+                                readonly end: NullType;
+                            }>>;
+                        }>>;
+                        readonly animation: OptionType<import("@elaraai/east").VariantType<{
+                            readonly none: NullType;
+                            readonly pulse: NullType;
+                        }>>;
+                    }>>;
+                    readonly markers: ArrayType<StructType<{
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly lane: OptionType<StringType>;
+                        readonly status: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                        readonly line: StructType<{
+                            readonly points: ArrayType<StructType<{
+                                readonly t: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: import("@elaraai/east").FloatType;
+                            }>>;
+                            readonly axis: import("@elaraai/east").VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly breach: OptionType<import("@elaraai/east").VariantType<{
+                                readonly above: import("@elaraai/east").FloatType;
+                                readonly below: import("@elaraai/east").FloatType;
+                            }>>;
+                            readonly fold: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: import("@elaraai/east").FloatType;
+                            }>>;
+                            readonly axis: import("@elaraai/east").VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly fold: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: import("@elaraai/east").FloatType;
+                            }>>;
+                            readonly axis: import("@elaraai/east").VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly series: OptionType<StringType>;
+                            readonly breach: OptionType<import("@elaraai/east").VariantType<{
+                                readonly above: import("@elaraai/east").FloatType;
+                                readonly below: import("@elaraai/east").FloatType;
+                            }>>;
+                            readonly fold: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly y: import("@elaraai/east").FloatType;
+                            }>>;
+                            readonly axis: import("@elaraai/east").VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                        }>;
+                        readonly band: StructType<{
+                            readonly points: ArrayType<StructType<{
+                                readonly t: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                        }>;
+                        readonly refLine: StructType<{
+                            readonly y: import("@elaraai/east").FloatType;
+                            readonly axis: import("@elaraai/east").VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly label: OptionType<StringType>;
+                        }>;
+                        readonly refBand: StructType<{
+                            readonly from: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly to: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly label: OptionType<StringType>;
+                        }>;
+                        readonly refDot: StructType<{
+                            readonly t: import("@elaraai/east").VariantType<{
+                                readonly time: DateTimeType;
+                                readonly number: import("@elaraai/east").FloatType;
+                                readonly ordinal: StringType;
+                            }>;
+                            readonly y: import("@elaraai/east").FloatType;
+                            readonly axis: import("@elaraai/east").VariantType<{
+                                readonly left: NullType;
+                                readonly right: NullType;
+                            }>;
+                            readonly label: OptionType<StringType>;
+                        }>;
+                    }>>;
+                    readonly left: OptionType<StructType<{
+                        readonly domain: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                            readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                            readonly time: ArrayType<DateTimeType>;
+                        }>>;
+                        readonly format: OptionType<import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                            readonly number: ArrayType<import("@elaraai/east").FloatType>;
+                            readonly time: ArrayType<DateTimeType>;
+                        }>>;
+                        readonly format: OptionType<import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                        readonly spark: NullType;
+                        readonly expanded: NullType;
+                        readonly fixed: StringType;
+                    }>;
+                    readonly expandedHeight: OptionType<StringType>;
+                    readonly expandable: BooleanType;
+                }>;
+                readonly heat: StructType<{
+                    readonly cells: import("@elaraai/east").VariantType<{
+                        readonly heat: StructType<{
+                            readonly cells: ArrayType<StructType<{
+                                readonly at: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly fraction: import("@elaraai/east").FloatType;
+                                readonly planned: BooleanType;
+                            }>>;
+                            readonly fold: import("@elaraai/east").VariantType<{
+                                readonly sum: 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: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: import("@elaraai/east").FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                                readonly segments: ArrayType<StructType<{
+                                    readonly fill: import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly neg: NullType;
+                                readonly muted: NullType;
+                            }>>;
+                        }>>;
+                        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                        readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                            readonly neg: NullType;
+                            readonly muted: NullType;
+                        }>>;
+                        readonly strong: BooleanType;
+                        readonly rollup: BooleanType;
+                        readonly fold: import("@elaraai/east").VariantType<{
+                            readonly sum: NullType;
+                            readonly mean: NullType;
+                            readonly min: NullType;
+                            readonly max: NullType;
+                            readonly last: NullType;
+                            readonly count: NullType;
+                        }>;
+                    }>>;
+                    readonly split: import("@elaraai/east").VariantType<{
+                        readonly horizontal: NullType;
+                        readonly vertical: NullType;
+                    }>;
+                    readonly aggregate: OptionType<import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                        readonly body: NullType;
+                        readonly header: NullType;
+                        readonly footer: NullType;
+                    }>;
+                }>;
+                readonly cards: StructType<{
+                    readonly chips: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly from: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly to: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly label: StringType;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<import("@elaraai/east").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<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 events: StructType<{
+                    readonly marks: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly at: import("@elaraai/east").VariantType<{
+                            readonly time: DateTimeType;
+                            readonly number: import("@elaraai/east").FloatType;
+                            readonly ordinal: StringType;
+                        }>;
+                        readonly kind: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                    readonly xs: NullType;
+                                    readonly sm: NullType;
+                                    readonly md: NullType;
+                                    readonly lg: NullType;
+                                    readonly xl: NullType;
+                                    readonly "2xl": NullType;
+                                }>>;
+                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly solid: NullType;
+                                }>>;
+                                readonly color: OptionType<StringType>;
+                                readonly background: OptionType<StringType>;
+                                readonly colorPalette: OptionType<import("@elaraai/east").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<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 label: OptionType<StringType>;
+                    }>>;
+                }>;
+            }>;
+            readonly collapsed: BooleanType;
+            readonly pinned: BooleanType;
+            readonly height: OptionType<StringType>;
+            readonly status: OptionType<import("@elaraai/east").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: import("@elaraai/east").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 total: FunctionType<[], OptionType<IntegerType>>;
+    readonly seek: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
+        readonly key: StringType;
+        readonly prefix: StringType;
+        readonly fields: StructType<{
+            readonly values: ArrayType<StringType>;
+            readonly prefix: OptionType<StringType>;
+        }>;
+        readonly range: StructType<{
+            readonly from: ArrayType<StringType>;
+            readonly to: ArrayType<StringType>;
+        }>;
+    }>], OptionType<StructType<{
+        readonly found: BooleanType;
+        readonly row: IntegerType;
+        readonly count: IntegerType;
+    }>>>>;
+    readonly revision: FunctionType<[], OptionType<StringType>>;
+    readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+}>;
+/** Type representing {@link PlanEventPagedType}. */
+export type PlanEventPagedType = typeof PlanEventPagedType;
+/**
+ * The paged resource kind's rows (see {@link PlanEventPagedType}), when a
+ * resource kind is given its resources as a paged read.
+ *
+ * @remarks
+ * Made inside the function that assembles the payload, as the `blocks` seam
+ * is, so `built` is the payload's own array of event kinds.
+ *
+ * @param resources - The resource kinds, by slot, in order — at most one of them paged (the Plan refuses more)
+ * @param events - The event kinds, by slot, in order
+ * @param built - The event kinds as the payload holds them, in the same order
+ * @returns The paged rows, or `undefined` when no resource kind is paged
+ * @throws {Error} When the kind's paged read is not a paged source of its resources
+ * @internal
+ */
+export declare function createEventPaged(resources: readonly (readonly [string, AnyResourceKind])[], events: readonly (readonly [string, AnyEventKind])[], built: ExprType<ArrayType<PlanEventKindType>>): ExprType<PlanEventPagedType> | undefined;
+export {};
+//# sourceMappingURL=event-rows.d.ts.map