@elaraai/e3-ui 1.0.97 → 1.0.99

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

@@ -14,10 +14,11 @@
  *
  * @packageDocumentation
  */
-import { type ExprType, type SubtypeExprOrValue, ArrayType, BooleanType, DateTimeType, FloatType, IntegerType, OptionType, StringType, StructType } from "@elaraai/east";
+import { type EastType, type ExprType, type SubtypeExprOrValue, Expr, ArrayType, BooleanType, DateTimeType, FloatType, IntegerType, OptionType, StringType, StructType, variant } from "@elaraai/east";
 import { EventStateType, IconType, StatusValueType, type EventStateLiteral, type IconName, type StatusValueLiteral } from "@elaraai/east-ui";
 import { ColorSchemeType, MatrixFillType, TickFormatType, type ColorSchemeLiteral, type MatrixFillLiteral, type SolidIconPrefix } from "@elaraai/east-ui/internal";
-import { type PlanAxisOptions, type PlanNumberAxisOptions, type PlanOrdinalAxisOptions, PlanInstantType, type PlanInstantLikeType, type PlanInstantInput, type PlanAxisKindLiteral, type PlanKindOf, type PlanInstantExpr, type PlanRunExpr, type PlanDecisionMarkExpr, type PlanPortExpr, type PlanBucketEventExpr, type PlanCellMarkerExpr, type PlanChipExpr, type PlanEventMarkExpr, type PlanHeatCellsExpr, type PlanTableCellsExpr, type PlanTableSeriesExpr, type PlanAxisExpr, type PlanCellsInput, type PlanTableCellsInput, PlanStretchType, type PlanStretchLiteral, PlanContentAlignType, type PlanContentAlignLiteral, PlanAnimationType, type PlanAnimationLiteral, PlanEventMarkKindType, PlanHeatCellType, PlanWeightCellType, PlanSegmentType, PlanSegmentCellType, PlanTableToneType, type PlanTableToneLiteral, PlanLinkType, PlanRunRefType, PlanLaneType, PlanRowIdType, PlanFoldType, type PlanFoldLiteral, PlanQuantityType, PlanHeatScaleType, PlanUiStateType } from "./types.js";
+import { type PlanAxisOptions, type PlanNumberAxisOptions, type PlanOrdinalAxisOptions, PlanInstantType, type PlanInstantLikeType, type PlanInstantInput, type PlanAxisKindLiteral, type PlanKindOf, type PlanInstantExpr, type PlanRunExpr, type PlanDecisionMarkExpr, type PlanPortExpr, type PlanBucketEventExpr, type PlanCellMarkerExpr, type PlanChipExpr, type PlanEventMarkExpr, type PlanHeatCellsExpr, type PlanTableCellsExpr, type PlanTableSeriesExpr, type PlanAxisExpr, type PlanCellsInput, type PlanTableCellsInput, PlanStretchType, type PlanStretchLiteral, PlanContentAlignType, type PlanContentAlignLiteral, PlanContentType, PlanAnimationType, type PlanAnimationLiteral, PlanEventMarkKindType, PlanHeatCellType, PlanWeightCellType, PlanSegmentType, PlanSegmentCellType, PlanTableToneType, type PlanTableToneLiteral, PlanLinkType, PlanRunRefType, PlanLaneType, PlanRowIdType, PlanFoldType, type PlanFoldLiteral, PlanQuantityType, PlanHeatScaleType, PlanUiStateType } from "./types.js";
+import { type PlanValuesEdit, type PlanValuesInput, type PlanValuesUse } from "./reads.js";
 /**
  * Resolves the shared event-lifecycle string shorthands into an
  * {@link EventStateType} value: `"estimated"`, `"added"`, `"recommended"`,
@@ -111,7 +112,8 @@ export declare const at: {
 };
 /**
  * The axis values built WITHOUT a window (#822) — a canvas given one must bind
- * a slice, whose range supplies the window, or the root refuses it at build
+ * a slice a source of which holds the window in its range (an event kind's or
+ * a tab's, never the canvas's rows', #1344), or the Plan refuses it at build
  * time. An axis held in a variable (`$.const(Plan.axis(…))`) is not the value
  * recorded here, so its canvas is held to the rule at render instead.
  */
@@ -124,6 +126,14 @@ export declare const WINDOWLESS_AXES: WeakSet<object>;
  * @internal
  */
 export declare function axisKindOf(axis: unknown): PlanAxisKindLiteral | undefined;
+/**
+ * The resolutions a time axis `Plan.axis` built offers (#1435).
+ *
+ * @param axis - A Plan's `axis`
+ * @returns Each resolution written as a literal; `undefined` for an axis held in a variable, or one of another kind
+ * @internal
+ */
+export declare function axisResolutionsOf(axis: unknown): readonly string[] | undefined;
 /**
  * Builds the `time` axis declaration — `Plan.axis({ … })` / `Plan.axis.time`.
  *
@@ -131,11 +141,13 @@ export declare function axisKindOf(axis: unknown): PlanAxisKindLiteral | undefin
  * @returns An East expression of {@link PlanAxisType} (the `time` arm), branded `"time"` — the root's canvas kind
  *
  * @remarks
- * The window is half-open `[min, max)` in UTC; omit it to follow the bound
- * slice's datetime range — a canvas states one or the other (#822). There is
- * no fit to the data. `resolutions` lists the WEEK/DAY-style segment options
- * (omit ⇒ no segment). When the Plan is slice-bound, slice state supersedes
- * window + resolution after mount — the slice is the single source of truth.
+ * The window is half-open `[min, max)` in UTC; omit it to follow the datetime
+ * range a source of the bound slice holds — an event kind's or a tab's, never
+ * the canvas's rows' (#1344) — a canvas states one or the other (#822). There
+ * is no fit to the data. `resolutions` lists the WEEK/DAY-style segment
+ * options (omit ⇒ no segment). Where a source of the Plan's slice holds the
+ * window, its state supersedes the window after mount; with none holding it,
+ * the canvas holds its own, from this one. The resolution is the slice's.
  */
 export declare function createTimeAxis(options: PlanAxisOptions): PlanAxisExpr<"time">;
 /**
@@ -148,8 +160,9 @@ export declare function createTimeAxis(options: PlanAxisOptions): PlanAxisExpr<"
  * @remarks
  * `[min, max)` ÷ `step` = `n` buckets, edges on whole multiples of `step`
  * (the `TimeResolution` rule, numerically). Omit the window to follow the
- * bound slice's `float` / `integer` range — a canvas states one or the other
- * (#822). Element instants on this canvas are numbers — a `FloatType` /
+ * `float` / `integer` range a source of the bound slice holds — never the
+ * canvas's rows' (#1344) — a canvas states one or the other (#822). Element
+ * instants on this canvas are numbers — a `FloatType` /
  * `IntegerType` accessor or a bare number wraps to the `number` arm.
  */
 export declare function createNumberAxis(options: PlanNumberAxisOptions): PlanAxisExpr<"number">;
@@ -215,6 +228,1462 @@ export interface PlanQuantityOptions {
  * @returns An East expression of {@link PlanQuantityType}
  */
 export declare function createQuantity(value: SubtypeExprOrValue<FloatType> | number, options?: PlanQuantityOptions): ExprType<PlanQuantityType>;
+/**
+ * A look field its element holds as an `Option` (#1436): the value, or the
+ * `Option` itself (`label: some(stop)`), so a field an item already holds as
+ * an `Option` passes as it is.
+ *
+ * @typeParam T - The field's East type
+ * @typeParam S - The shorthands it takes besides (a status literal, a number)
+ */
+export type PlanLookOption<T extends EastType, S = never> = SubtypeExprOrValue<T> | SubtypeExprOrValue<OptionType<T>> | S;
+/**
+ * What `draw` gives for a run — `Plan.items(field, { from, to }, draw)` on a
+ * span series' `runs`: everything {@link Plan.run} takes but its key and its
+ * instants, which are the item's id and its times.
+ *
+ * @property label - The bar text
+ * @property state - The lifecycle state
+ * @property quantity - The quantity the bar prints and a parent's band sums
+ * @property status - The status tint
+ * @property moved - The same-status churn counter
+ * @property icon - The leading glyph
+ */
+export interface PlanRunLook {
+    /** The bar text (`"RUN · J-4642"`). */
+    label: SubtypeExprOrValue<StringType>;
+    /** The lifecycle state — a string shorthand or an `EventStateType` value. */
+    state: SubtypeExprOrValue<EventStateType> | EventStateLiteral;
+    /** The quantity — `Plan.quantity(96, { unit: "k sheets" })`, or an `Option` of one. */
+    quantity?: PlanLookOption<PlanQuantityType>;
+    /** The status tint — `"warning"` draws the over-dwell ring. */
+    status?: PlanLookOption<StatusValueType, StatusValueLiteral>;
+    /** The same-status churn counter. */
+    moved?: PlanLookOption<IntegerType, number>;
+    /** The leading glyph. */
+    icon?: PlanIconInput | SubtypeExprOrValue<OptionType<IconType>>;
+}
+/**
+ * What `draw` gives for a decision diamond — `Plan.items(field, { at }, draw)`
+ * on a span series' `decisions`.
+ *
+ * @property applied - `true` fills the diamond
+ */
+export interface PlanDecisionLook {
+    /** `true` fills the diamond (◆ applied). */
+    applied: SubtypeExprOrValue<BooleanType> | boolean;
+}
+/**
+ * What `draw` gives for a port — `Plan.values(field, draw)` on a span series'
+ * `ports`: a port has no id, so its instant is its key.
+ *
+ * @property label - The caption
+ */
+export interface PlanPortLook {
+    /** The caption (`"−24 k sheets"`). */
+    label?: PlanLookOption<StringType>;
+}
+/**
+ * What `draw` gives for a bucket-row tile — `Plan.items(field, { at }, draw)`
+ * on a bucket series' `events`: everything {@link Plan.event} takes but its
+ * key and its instant.
+ *
+ * @property state - The lifecycle state
+ * @property lane - The lane key
+ * @property label - The tile text
+ * @property icon - The leading glyph
+ * @property tone - The semantic tint
+ * @property color - A raw colour token
+ * @property colorPalette - A brand palette
+ * @property stretch - The fill axis
+ * @property content - The content alignment
+ * @property animation - The attention animation
+ */
+export interface PlanBucketEventLook {
+    /** The lifecycle state. */
+    state: SubtypeExprOrValue<EventStateType> | EventStateLiteral;
+    /** The lane key. */
+    lane?: PlanLookOption<StringType>;
+    /** The tile text; omitted ⇒ ✓ or the dashed `plan` chip. */
+    label?: PlanLookOption<StringType>;
+    /** The leading glyph. */
+    icon?: PlanIconInput | SubtypeExprOrValue<OptionType<IconType>>;
+    /** The semantic tint. */
+    tone?: PlanLookOption<StatusValueType, StatusValueLiteral>;
+    /** A raw colour token (`"teal.solid"`). */
+    color?: PlanLookOption<StringType>;
+    /** A brand palette (`"teal"`). */
+    colorPalette?: PlanLookOption<ColorSchemeType, ColorSchemeLiteral>;
+    /** The fill axis. */
+    stretch?: PlanLookOption<PlanStretchType, PlanStretchLiteral>;
+    /** The two-axis content alignment, or an `Option` of one. */
+    content?: PlanBucketEventInput["content"] | SubtypeExprOrValue<OptionType<PlanContentType>>;
+    /** The attention animation. */
+    animation?: PlanLookOption<PlanAnimationType, PlanAnimationLiteral>;
+}
+/**
+ * What `draw` gives for a cell marker — `Plan.values(field, draw)` on a bucket
+ * series' `markers`: a marker has no id, so its instant is its key.
+ *
+ * @property message - The hover text
+ * @property lane - The lane key within the cell
+ * @property status - The semantic status (default `"danger"`)
+ */
+export interface PlanCellMarkerLook {
+    /** The hover-tooltip text. */
+    message: SubtypeExprOrValue<StringType>;
+    /** The lane key within the cell. */
+    lane?: PlanLookOption<StringType>;
+    /** The semantic status (default `"danger"`). */
+    status?: SubtypeExprOrValue<StatusValueType> | StatusValueLiteral;
+}
+/**
+ * What `draw` gives for a cards-row chip — `Plan.items(field, { from, to },
+ * draw)` on a cards series' `chips`.
+ *
+ * @property label - The chip text
+ * @property state - The lifecycle state
+ * @property icon - The leading glyph
+ */
+export interface PlanChipLook {
+    /** The chip text (`"80h"`). */
+    label: SubtypeExprOrValue<StringType>;
+    /** The lifecycle state. */
+    state: SubtypeExprOrValue<EventStateType> | EventStateLiteral;
+    /** The leading glyph. */
+    icon?: PlanIconInput | SubtypeExprOrValue<OptionType<IconType>>;
+}
+/**
+ * What `draw` gives for an event-row mark — `Plan.items(field, { at }, draw)`
+ * on an events series' `marks`.
+ *
+ * @property kind - `"milestone"` / `"exception"` / `Plan.markKind.decision(applied)`
+ * @property icon - A glyph swap
+ * @property label - The caption
+ */
+export interface PlanEventMarkLook {
+    /** The mark kind. */
+    kind: SubtypeExprOrValue<PlanEventMarkKindType> | "milestone" | "exception";
+    /** A glyph swap (still kind-coloured). */
+    icon?: PlanIconInput | SubtypeExprOrValue<OptionType<IconType>>;
+    /** The caption. */
+    label?: PlanLookOption<StringType>;
+}
+/**
+ * What `draw` gives for a heat cell — `Plan.heatCells(Plan.values(field,
+ * draw))`.
+ *
+ * @property value - The value — `some(v)`, `none` for the no-data hatch, or a plain value
+ * @property label - The cell's caption
+ */
+export interface PlanHeatCellLook {
+    /** The value: `some(v)`, `none` for the no-data hatch, or a plain value. */
+    value: PlanLookOption<FloatType, number>;
+    /** The cell's caption. */
+    label?: PlanLookOption<StringType>;
+}
+/**
+ * What `draw` gives for a weight cell — `Plan.weightCells(Plan.values(field,
+ * draw))`.
+ *
+ * @property fraction - The fraction of the bucket booked
+ * @property planned - Whether it is planned (pale)
+ */
+export interface PlanWeightCellLook {
+    /** The fraction of the bucket booked. */
+    fraction: SubtypeExprOrValue<FloatType> | number;
+    /** Whether it is planned (drawn pale). */
+    planned: SubtypeExprOrValue<BooleanType> | boolean;
+}
+/**
+ * What `draw` gives for a segment cell — `Plan.segmentCells(Plan.values(field,
+ * draw))`.
+ *
+ * @property segments - The cell's segments (`Plan.segment` values)
+ */
+export interface PlanSegmentCellLook {
+    /** The cell's segments (`Plan.segment` values). */
+    segments: SubtypeExprOrValue<ArrayType<typeof PlanSegmentType>>;
+}
+/**
+ * What `draw` gives for a table cell — `Plan.tableCells(Plan.values(field,
+ * draw))`.
+ *
+ * @property value - The value — `some(v)`, `none` for the muted em-dash, or a plain value
+ * @property text - Text printed in place of the value
+ * @property tone - The cell's tone
+ */
+export interface PlanTableCellLook {
+    /** The value: `some(v)`, `none` for the muted em-dash, or a plain value. */
+    value: PlanLookOption<FloatType, number>;
+    /** Text printed in place of the value. */
+    text?: PlanLookOption<StringType>;
+    /** The cell's tone (`"muted"`, `"neg"`). */
+    tone?: PlanLookOption<PlanTableToneType, PlanTableToneLiteral>;
+}
+/**
+ * What `draw` gives for a chart point — `Plan.line`, `Plan.area`,
+ * `Plan.column` or `Plan.scatter` over `Plan.values(field, draw)`.
+ *
+ * @property y - The point's value
+ */
+export interface PlanChartPointLook {
+    /** The point's value. */
+    y: SubtypeExprOrValue<FloatType> | number;
+}
+/**
+ * What `draw` gives for a band point — `Plan.band(Plan.values(field, draw))`.
+ *
+ * @property lo - The band's low edge
+ * @property hi - The band's high edge
+ */
+export interface PlanChartBandLook {
+    /** The band's low edge. */
+    lo: SubtypeExprOrValue<FloatType> | number;
+    /** The band's high edge. */
+    hi: SubtypeExprOrValue<FloatType> | number;
+}
+/** A run's look, resolved into its fields (#1436) — shared by {@link Plan.run} and a read's `draw`. @internal */
+export declare function runLookFields(look: PlanRunLook, where?: string): {
+    label: string | Expr<import("@elaraai/east").NeverType> | Expr<StringType>;
+    quantity: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StructType<{
+            readonly value: FloatType;
+            readonly unit: OptionType<StringType>;
+            readonly format: OptionType<TickFormatType>;
+            readonly text: OptionType<StringType>;
+        }>;
+    }>;
+    state: Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+        readonly estimated?: import("@elaraai/east").NullType;
+        readonly proposed?: import("@elaraai/east").VariantType<{
+            readonly added?: import("@elaraai/east").NullType;
+            readonly recommended?: import("@elaraai/east").NullType;
+            readonly removed?: import("@elaraai/east").NullType;
+        }>;
+        readonly confirmed?: import("@elaraai/east").NullType;
+        readonly "in-progress"?: import("@elaraai/east").NullType;
+        readonly actual?: import("@elaraai/east").NullType;
+        readonly rejected?: import("@elaraai/east").NullType;
+    }>> | variant<"rejected", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"proposed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+        readonly added?: import("@elaraai/east").NullType;
+        readonly recommended?: import("@elaraai/east").NullType;
+        readonly removed?: import("@elaraai/east").NullType;
+    }>> | variant<"added", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"removed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"recommended", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>> | variant<"estimated", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"confirmed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"in-progress", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"actual", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>;
+    status: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: import("@elaraai/east").VariantType<{
+            readonly success: import("@elaraai/east").NullType;
+            readonly warning: import("@elaraai/east").NullType;
+            readonly danger: import("@elaraai/east").NullType;
+            readonly info: import("@elaraai/east").NullType;
+            readonly neutral: import("@elaraai/east").NullType;
+        }>;
+    }>;
+    moved: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: IntegerType;
+    }>;
+    icon: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StructType<{
+            readonly name: StringType;
+            readonly prefix: StringType;
+            readonly label: OptionType<StringType>;
+            readonly style: OptionType<StructType<{
+                readonly size: OptionType<import("@elaraai/east").VariantType<{
+                    readonly xs: import("@elaraai/east").NullType;
+                    readonly sm: import("@elaraai/east").NullType;
+                    readonly md: import("@elaraai/east").NullType;
+                    readonly lg: import("@elaraai/east").NullType;
+                    readonly xl: import("@elaraai/east").NullType;
+                    readonly "2xl": import("@elaraai/east").NullType;
+                }>>;
+                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                    readonly solid: import("@elaraai/east").NullType;
+                }>>;
+                readonly color: OptionType<StringType>;
+                readonly background: OptionType<StringType>;
+                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                    readonly brand: import("@elaraai/east").NullType;
+                    readonly gray: import("@elaraai/east").NullType;
+                    readonly red: import("@elaraai/east").NullType;
+                    readonly orange: import("@elaraai/east").NullType;
+                    readonly yellow: import("@elaraai/east").NullType;
+                    readonly green: import("@elaraai/east").NullType;
+                    readonly teal: import("@elaraai/east").NullType;
+                    readonly blue: import("@elaraai/east").NullType;
+                    readonly cyan: import("@elaraai/east").NullType;
+                    readonly purple: import("@elaraai/east").NullType;
+                    readonly pink: import("@elaraai/east").NullType;
+                    readonly success: import("@elaraai/east").NullType;
+                    readonly warning: import("@elaraai/east").NullType;
+                    readonly danger: import("@elaraai/east").NullType;
+                    readonly info: import("@elaraai/east").NullType;
+                    readonly neutral: import("@elaraai/east").NullType;
+                }>>;
+                readonly opacity: OptionType<FloatType>;
+                readonly borderRadius: OptionType<StringType>;
+                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly width: OptionType<StringType>;
+                readonly height: OptionType<StringType>;
+                readonly minWidth: OptionType<StringType>;
+                readonly minHeight: OptionType<StringType>;
+                readonly maxWidth: OptionType<StringType>;
+                readonly maxHeight: OptionType<StringType>;
+                readonly padding: OptionType<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>;
+                }>>;
+            }>>;
+        }>;
+    }>;
+};
+/** A decision's look, resolved (#1436). @internal */
+export declare function decisionLookFields(look: PlanDecisionLook): {
+    applied: boolean | Expr<import("@elaraai/east").NeverType> | Expr<BooleanType>;
+};
+/** A port's look, resolved (#1436). @internal */
+export declare function portLookFields(look: PlanPortLook): {
+    label: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+};
+/** A tile's look, resolved (#1436). @internal */
+export declare function bucketEventLookFields(look: PlanBucketEventLook, where?: string): {
+    lane: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+    label: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+    icon: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StructType<{
+            readonly name: StringType;
+            readonly prefix: StringType;
+            readonly label: OptionType<StringType>;
+            readonly style: OptionType<StructType<{
+                readonly size: OptionType<import("@elaraai/east").VariantType<{
+                    readonly xs: import("@elaraai/east").NullType;
+                    readonly sm: import("@elaraai/east").NullType;
+                    readonly md: import("@elaraai/east").NullType;
+                    readonly lg: import("@elaraai/east").NullType;
+                    readonly xl: import("@elaraai/east").NullType;
+                    readonly "2xl": import("@elaraai/east").NullType;
+                }>>;
+                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                    readonly solid: import("@elaraai/east").NullType;
+                }>>;
+                readonly color: OptionType<StringType>;
+                readonly background: OptionType<StringType>;
+                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                    readonly brand: import("@elaraai/east").NullType;
+                    readonly gray: import("@elaraai/east").NullType;
+                    readonly red: import("@elaraai/east").NullType;
+                    readonly orange: import("@elaraai/east").NullType;
+                    readonly yellow: import("@elaraai/east").NullType;
+                    readonly green: import("@elaraai/east").NullType;
+                    readonly teal: import("@elaraai/east").NullType;
+                    readonly blue: import("@elaraai/east").NullType;
+                    readonly cyan: import("@elaraai/east").NullType;
+                    readonly purple: import("@elaraai/east").NullType;
+                    readonly pink: import("@elaraai/east").NullType;
+                    readonly success: import("@elaraai/east").NullType;
+                    readonly warning: import("@elaraai/east").NullType;
+                    readonly danger: import("@elaraai/east").NullType;
+                    readonly info: import("@elaraai/east").NullType;
+                    readonly neutral: import("@elaraai/east").NullType;
+                }>>;
+                readonly opacity: OptionType<FloatType>;
+                readonly borderRadius: OptionType<StringType>;
+                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly width: OptionType<StringType>;
+                readonly height: OptionType<StringType>;
+                readonly minWidth: OptionType<StringType>;
+                readonly minHeight: OptionType<StringType>;
+                readonly maxWidth: OptionType<StringType>;
+                readonly maxHeight: OptionType<StringType>;
+                readonly padding: OptionType<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>;
+                }>>;
+            }>>;
+        }>;
+    }>;
+    state: Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+        readonly estimated?: import("@elaraai/east").NullType;
+        readonly proposed?: import("@elaraai/east").VariantType<{
+            readonly added?: import("@elaraai/east").NullType;
+            readonly recommended?: import("@elaraai/east").NullType;
+            readonly removed?: import("@elaraai/east").NullType;
+        }>;
+        readonly confirmed?: import("@elaraai/east").NullType;
+        readonly "in-progress"?: import("@elaraai/east").NullType;
+        readonly actual?: import("@elaraai/east").NullType;
+        readonly rejected?: import("@elaraai/east").NullType;
+    }>> | variant<"rejected", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"proposed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+        readonly added?: import("@elaraai/east").NullType;
+        readonly recommended?: import("@elaraai/east").NullType;
+        readonly removed?: import("@elaraai/east").NullType;
+    }>> | variant<"added", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"removed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"recommended", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>> | variant<"estimated", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"confirmed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"in-progress", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"actual", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>;
+    tone: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: import("@elaraai/east").VariantType<{
+            readonly success: import("@elaraai/east").NullType;
+            readonly warning: import("@elaraai/east").NullType;
+            readonly danger: import("@elaraai/east").NullType;
+            readonly info: import("@elaraai/east").NullType;
+            readonly neutral: import("@elaraai/east").NullType;
+        }>;
+    }>;
+    color: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+    colorPalette: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: import("@elaraai/east").VariantType<{
+            readonly brand: import("@elaraai/east").NullType;
+            readonly gray: import("@elaraai/east").NullType;
+            readonly red: import("@elaraai/east").NullType;
+            readonly orange: import("@elaraai/east").NullType;
+            readonly yellow: import("@elaraai/east").NullType;
+            readonly green: import("@elaraai/east").NullType;
+            readonly teal: import("@elaraai/east").NullType;
+            readonly blue: import("@elaraai/east").NullType;
+            readonly cyan: import("@elaraai/east").NullType;
+            readonly purple: import("@elaraai/east").NullType;
+            readonly pink: import("@elaraai/east").NullType;
+            readonly success: import("@elaraai/east").NullType;
+            readonly warning: import("@elaraai/east").NullType;
+            readonly danger: import("@elaraai/east").NullType;
+            readonly info: import("@elaraai/east").NullType;
+            readonly neutral: import("@elaraai/east").NullType;
+        }>;
+    }>;
+    stretch: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: import("@elaraai/east").VariantType<{
+            readonly horizontal: import("@elaraai/east").NullType;
+            readonly vertical: import("@elaraai/east").NullType;
+            readonly both: import("@elaraai/east").NullType;
+        }>;
+    }>;
+    content: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StructType<{
+            readonly horizontal: OptionType<import("@elaraai/east").VariantType<{
+                readonly start: import("@elaraai/east").NullType;
+                readonly center: import("@elaraai/east").NullType;
+                readonly end: import("@elaraai/east").NullType;
+            }>>;
+            readonly vertical: OptionType<import("@elaraai/east").VariantType<{
+                readonly start: import("@elaraai/east").NullType;
+                readonly center: import("@elaraai/east").NullType;
+                readonly end: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+    }>;
+    animation: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: import("@elaraai/east").VariantType<{
+            readonly none: import("@elaraai/east").NullType;
+            readonly pulse: import("@elaraai/east").NullType;
+        }>;
+    }>;
+};
+/** A marker's look, resolved (#1436). @internal */
+export declare function cellMarkerLookFields(look: PlanCellMarkerLook): {
+    lane: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+    status: import("@elaraai/east").VariantExpr<{
+        readonly success: import("@elaraai/east").NullType;
+        readonly warning: import("@elaraai/east").NullType;
+        readonly danger: import("@elaraai/east").NullType;
+        readonly info: import("@elaraai/east").NullType;
+        readonly neutral: import("@elaraai/east").NullType;
+    }>;
+    message: string | Expr<import("@elaraai/east").NeverType> | Expr<StringType>;
+};
+/** A chip's look, resolved (#1436). @internal */
+export declare function chipLookFields(look: PlanChipLook, where?: string): {
+    label: string | Expr<import("@elaraai/east").NeverType> | Expr<StringType>;
+    state: Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+        readonly estimated?: import("@elaraai/east").NullType;
+        readonly proposed?: import("@elaraai/east").VariantType<{
+            readonly added?: import("@elaraai/east").NullType;
+            readonly recommended?: import("@elaraai/east").NullType;
+            readonly removed?: import("@elaraai/east").NullType;
+        }>;
+        readonly confirmed?: import("@elaraai/east").NullType;
+        readonly "in-progress"?: import("@elaraai/east").NullType;
+        readonly actual?: import("@elaraai/east").NullType;
+        readonly rejected?: import("@elaraai/east").NullType;
+    }>> | variant<"rejected", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"proposed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+        readonly added?: import("@elaraai/east").NullType;
+        readonly recommended?: import("@elaraai/east").NullType;
+        readonly removed?: import("@elaraai/east").NullType;
+    }>> | variant<"added", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"removed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"recommended", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>> | variant<"estimated", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"confirmed", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"in-progress", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"actual", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>;
+    icon: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StructType<{
+            readonly name: StringType;
+            readonly prefix: StringType;
+            readonly label: OptionType<StringType>;
+            readonly style: OptionType<StructType<{
+                readonly size: OptionType<import("@elaraai/east").VariantType<{
+                    readonly xs: import("@elaraai/east").NullType;
+                    readonly sm: import("@elaraai/east").NullType;
+                    readonly md: import("@elaraai/east").NullType;
+                    readonly lg: import("@elaraai/east").NullType;
+                    readonly xl: import("@elaraai/east").NullType;
+                    readonly "2xl": import("@elaraai/east").NullType;
+                }>>;
+                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                    readonly solid: import("@elaraai/east").NullType;
+                }>>;
+                readonly color: OptionType<StringType>;
+                readonly background: OptionType<StringType>;
+                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                    readonly brand: import("@elaraai/east").NullType;
+                    readonly gray: import("@elaraai/east").NullType;
+                    readonly red: import("@elaraai/east").NullType;
+                    readonly orange: import("@elaraai/east").NullType;
+                    readonly yellow: import("@elaraai/east").NullType;
+                    readonly green: import("@elaraai/east").NullType;
+                    readonly teal: import("@elaraai/east").NullType;
+                    readonly blue: import("@elaraai/east").NullType;
+                    readonly cyan: import("@elaraai/east").NullType;
+                    readonly purple: import("@elaraai/east").NullType;
+                    readonly pink: import("@elaraai/east").NullType;
+                    readonly success: import("@elaraai/east").NullType;
+                    readonly warning: import("@elaraai/east").NullType;
+                    readonly danger: import("@elaraai/east").NullType;
+                    readonly info: import("@elaraai/east").NullType;
+                    readonly neutral: import("@elaraai/east").NullType;
+                }>>;
+                readonly opacity: OptionType<FloatType>;
+                readonly borderRadius: OptionType<StringType>;
+                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly width: OptionType<StringType>;
+                readonly height: OptionType<StringType>;
+                readonly minWidth: OptionType<StringType>;
+                readonly minHeight: OptionType<StringType>;
+                readonly maxWidth: OptionType<StringType>;
+                readonly maxHeight: OptionType<StringType>;
+                readonly padding: OptionType<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>;
+                }>>;
+            }>>;
+        }>;
+    }>;
+};
+/** A mark's look, resolved (#1436). @internal */
+export declare function eventMarkLookFields(look: PlanEventMarkLook, where?: string): {
+    kind: Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+        readonly milestone?: import("@elaraai/east").NullType;
+        readonly decision?: StructType<{
+            readonly applied: BooleanType;
+        }>;
+        readonly exception?: import("@elaraai/east").NullType;
+    }>> | variant<"decision", Expr<import("@elaraai/east").NeverType> | Expr<StructType<{
+        readonly applied: BooleanType;
+    }>> | {
+        readonly applied: boolean | Expr<import("@elaraai/east").NeverType> | Expr<BooleanType>;
+    }> | variant<"milestone", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"exception", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>;
+    icon: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StructType<{
+            readonly name: StringType;
+            readonly prefix: StringType;
+            readonly label: OptionType<StringType>;
+            readonly style: OptionType<StructType<{
+                readonly size: OptionType<import("@elaraai/east").VariantType<{
+                    readonly xs: import("@elaraai/east").NullType;
+                    readonly sm: import("@elaraai/east").NullType;
+                    readonly md: import("@elaraai/east").NullType;
+                    readonly lg: import("@elaraai/east").NullType;
+                    readonly xl: import("@elaraai/east").NullType;
+                    readonly "2xl": import("@elaraai/east").NullType;
+                }>>;
+                readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                    readonly solid: import("@elaraai/east").NullType;
+                }>>;
+                readonly color: OptionType<StringType>;
+                readonly background: OptionType<StringType>;
+                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                    readonly brand: import("@elaraai/east").NullType;
+                    readonly gray: import("@elaraai/east").NullType;
+                    readonly red: import("@elaraai/east").NullType;
+                    readonly orange: import("@elaraai/east").NullType;
+                    readonly yellow: import("@elaraai/east").NullType;
+                    readonly green: import("@elaraai/east").NullType;
+                    readonly teal: import("@elaraai/east").NullType;
+                    readonly blue: import("@elaraai/east").NullType;
+                    readonly cyan: import("@elaraai/east").NullType;
+                    readonly purple: import("@elaraai/east").NullType;
+                    readonly pink: import("@elaraai/east").NullType;
+                    readonly success: import("@elaraai/east").NullType;
+                    readonly warning: import("@elaraai/east").NullType;
+                    readonly danger: import("@elaraai/east").NullType;
+                    readonly info: import("@elaraai/east").NullType;
+                    readonly neutral: import("@elaraai/east").NullType;
+                }>>;
+                readonly opacity: OptionType<FloatType>;
+                readonly borderRadius: OptionType<StringType>;
+                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                    readonly visible: import("@elaraai/east").NullType;
+                    readonly hidden: import("@elaraai/east").NullType;
+                    readonly scroll: import("@elaraai/east").NullType;
+                    readonly auto: import("@elaraai/east").NullType;
+                }>>;
+                readonly width: OptionType<StringType>;
+                readonly height: OptionType<StringType>;
+                readonly minWidth: OptionType<StringType>;
+                readonly minHeight: OptionType<StringType>;
+                readonly maxWidth: OptionType<StringType>;
+                readonly maxHeight: OptionType<StringType>;
+                readonly padding: OptionType<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>;
+                }>>;
+            }>>;
+        }>;
+    }>;
+    label: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+};
+/** A heat cell's look, resolved (#1436). @internal */
+export declare function heatCellLookFields(look: PlanHeatCellLook): {
+    value: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: FloatType;
+    }>;
+    label: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+};
+/** A weight cell's look, resolved (#1436). @internal */
+export declare function weightCellLookFields(look: PlanWeightCellLook): {
+    fraction: number | Expr<import("@elaraai/east").NeverType> | Expr<FloatType>;
+    planned: boolean | Expr<import("@elaraai/east").NeverType> | Expr<BooleanType>;
+};
+/** A segment cell's look, resolved (#1436). @internal */
+export declare function segmentCellLookFields(look: PlanSegmentCellLook): {
+    segments: Expr<import("@elaraai/east").NeverType> | Expr<ArrayType<StructType<{
+        readonly fill: import("@elaraai/east").VariantType<{
+            readonly brand: import("@elaraai/east").NullType;
+            readonly success: import("@elaraai/east").NullType;
+            readonly warning: import("@elaraai/east").NullType;
+            readonly danger: import("@elaraai/east").NullType;
+            readonly info: import("@elaraai/east").NullType;
+            readonly neutral: import("@elaraai/east").NullType;
+            readonly slack: import("@elaraai/east").NullType;
+            readonly free: import("@elaraai/east").NullType;
+        }>;
+        readonly weight: FloatType;
+        readonly label: OptionType<StringType>;
+    }>>> | (Expr<import("@elaraai/east").NeverType> | Expr<StructType<{
+        readonly fill: import("@elaraai/east").VariantType<{
+            readonly brand?: import("@elaraai/east").NullType;
+            readonly success?: import("@elaraai/east").NullType;
+            readonly warning?: import("@elaraai/east").NullType;
+            readonly danger?: import("@elaraai/east").NullType;
+            readonly info?: import("@elaraai/east").NullType;
+            readonly neutral?: import("@elaraai/east").NullType;
+            readonly slack?: import("@elaraai/east").NullType;
+            readonly free?: import("@elaraai/east").NullType;
+        }>;
+        readonly weight: FloatType;
+        readonly label: import("@elaraai/east").VariantType<{
+            none?: import("@elaraai/east").NullType;
+            some?: StringType;
+        }>;
+    }>> | {
+        readonly fill: variant<"neutral", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"success", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"warning", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"danger", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"info", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"brand", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+            readonly brand?: import("@elaraai/east").NullType;
+            readonly success?: import("@elaraai/east").NullType;
+            readonly warning?: import("@elaraai/east").NullType;
+            readonly danger?: import("@elaraai/east").NullType;
+            readonly info?: import("@elaraai/east").NullType;
+            readonly neutral?: import("@elaraai/east").NullType;
+            readonly slack?: import("@elaraai/east").NullType;
+            readonly free?: import("@elaraai/east").NullType;
+        }>> | variant<"slack", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"free", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null>;
+        readonly weight: number | Expr<import("@elaraai/east").NeverType> | Expr<FloatType>;
+        readonly label: variant<"none", Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").NullType> | null> | variant<"some", string | Expr<import("@elaraai/east").NeverType> | Expr<StringType>> | Expr<import("@elaraai/east").NeverType> | Expr<import("@elaraai/east").VariantType<{
+            none?: import("@elaraai/east").NullType;
+            some?: StringType;
+        }>>;
+    })[];
+};
+/** A table cell's look, resolved (#1436). @internal */
+export declare function tableCellLookFields(look: PlanTableCellLook): {
+    value: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: FloatType;
+    }>;
+    text: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: StringType;
+    }>;
+    tone: import("@elaraai/east").VariantExpr<{
+        none: import("@elaraai/east").NullType;
+        some: import("@elaraai/east").VariantType<{
+            readonly neg: import("@elaraai/east").NullType;
+            readonly muted: import("@elaraai/east").NullType;
+        }>;
+    }>;
+};
+/** A chart point's look, resolved (#1436). @internal */
+export declare function chartPointLookFields(look: PlanChartPointLook): {
+    y: number | Expr<import("@elaraai/east").NeverType> | Expr<FloatType>;
+};
+/** A band point's look, resolved (#1436). @internal */
+export declare function chartBandLookFields(look: PlanChartBandLook): {
+    lo: number | Expr<import("@elaraai/east").NeverType> | Expr<FloatType>;
+    hi: number | Expr<import("@elaraai/east").NeverType> | Expr<FloatType>;
+};
+/**
+ * What a named read completes (#1436): an element of a series' row or a cell
+ * of a consumer, by its kind — its East type, its key field (a thing people
+ * drag is keyed by its item's id; a value by nothing but its instant), its
+ * instant fields, and how its look resolves.
+ *
+ * @internal
+ */
+export declare const PLAN_LOOKS: {
+    readonly run: {
+        readonly type: StructType<{
+            readonly key: StringType;
+            readonly start: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly end: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly label: StringType;
+            readonly quantity: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly unit: OptionType<StringType>;
+                readonly format: OptionType<TickFormatType>;
+                readonly text: OptionType<StringType>;
+            }>>;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: import("@elaraai/east").NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: import("@elaraai/east").NullType;
+                    readonly recommended: import("@elaraai/east").NullType;
+                    readonly removed: import("@elaraai/east").NullType;
+                }>;
+                readonly confirmed: import("@elaraai/east").NullType;
+                readonly "in-progress": import("@elaraai/east").NullType;
+                readonly actual: import("@elaraai/east").NullType;
+                readonly rejected: import("@elaraai/east").NullType;
+            }>;
+            readonly status: OptionType<import("@elaraai/east").VariantType<{
+                readonly success: import("@elaraai/east").NullType;
+                readonly warning: import("@elaraai/east").NullType;
+                readonly danger: import("@elaraai/east").NullType;
+                readonly info: import("@elaraai/east").NullType;
+                readonly neutral: import("@elaraai/east").NullType;
+            }>>;
+            readonly moved: OptionType<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: import("@elaraai/east").NullType;
+                        readonly sm: import("@elaraai/east").NullType;
+                        readonly md: import("@elaraai/east").NullType;
+                        readonly lg: import("@elaraai/east").NullType;
+                        readonly xl: import("@elaraai/east").NullType;
+                        readonly "2xl": import("@elaraai/east").NullType;
+                    }>>;
+                    readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                        readonly solid: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly color: OptionType<StringType>;
+                    readonly background: OptionType<StringType>;
+                    readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                        readonly brand: import("@elaraai/east").NullType;
+                        readonly gray: import("@elaraai/east").NullType;
+                        readonly red: import("@elaraai/east").NullType;
+                        readonly orange: import("@elaraai/east").NullType;
+                        readonly yellow: import("@elaraai/east").NullType;
+                        readonly green: import("@elaraai/east").NullType;
+                        readonly teal: import("@elaraai/east").NullType;
+                        readonly blue: import("@elaraai/east").NullType;
+                        readonly cyan: import("@elaraai/east").NullType;
+                        readonly purple: import("@elaraai/east").NullType;
+                        readonly pink: import("@elaraai/east").NullType;
+                        readonly success: import("@elaraai/east").NullType;
+                        readonly warning: import("@elaraai/east").NullType;
+                        readonly danger: import("@elaraai/east").NullType;
+                        readonly info: import("@elaraai/east").NullType;
+                        readonly neutral: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly opacity: OptionType<FloatType>;
+                    readonly borderRadius: OptionType<StringType>;
+                    readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly width: OptionType<StringType>;
+                    readonly height: OptionType<StringType>;
+                    readonly minWidth: OptionType<StringType>;
+                    readonly minHeight: OptionType<StringType>;
+                    readonly maxWidth: OptionType<StringType>;
+                    readonly maxHeight: OptionType<StringType>;
+                    readonly padding: OptionType<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 key: "key";
+        readonly instants: readonly ["start", "end"];
+        readonly look: (l: never) => object;
+    };
+    readonly decision: {
+        readonly type: StructType<{
+            readonly key: StringType;
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly applied: BooleanType;
+        }>;
+        readonly key: "key";
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly port: {
+        readonly type: StructType<{
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly label: OptionType<StringType>;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly event: {
+        readonly type: StructType<{
+            readonly key: StringType;
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly lane: OptionType<StringType>;
+            readonly label: OptionType<StringType>;
+            readonly icon: OptionType<StructType<{
+                readonly name: StringType;
+                readonly prefix: StringType;
+                readonly label: OptionType<StringType>;
+                readonly style: OptionType<StructType<{
+                    readonly size: OptionType<import("@elaraai/east").VariantType<{
+                        readonly xs: import("@elaraai/east").NullType;
+                        readonly sm: import("@elaraai/east").NullType;
+                        readonly md: import("@elaraai/east").NullType;
+                        readonly lg: import("@elaraai/east").NullType;
+                        readonly xl: import("@elaraai/east").NullType;
+                        readonly "2xl": import("@elaraai/east").NullType;
+                    }>>;
+                    readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                        readonly solid: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly color: OptionType<StringType>;
+                    readonly background: OptionType<StringType>;
+                    readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                        readonly brand: import("@elaraai/east").NullType;
+                        readonly gray: import("@elaraai/east").NullType;
+                        readonly red: import("@elaraai/east").NullType;
+                        readonly orange: import("@elaraai/east").NullType;
+                        readonly yellow: import("@elaraai/east").NullType;
+                        readonly green: import("@elaraai/east").NullType;
+                        readonly teal: import("@elaraai/east").NullType;
+                        readonly blue: import("@elaraai/east").NullType;
+                        readonly cyan: import("@elaraai/east").NullType;
+                        readonly purple: import("@elaraai/east").NullType;
+                        readonly pink: import("@elaraai/east").NullType;
+                        readonly success: import("@elaraai/east").NullType;
+                        readonly warning: import("@elaraai/east").NullType;
+                        readonly danger: import("@elaraai/east").NullType;
+                        readonly info: import("@elaraai/east").NullType;
+                        readonly neutral: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly opacity: OptionType<FloatType>;
+                    readonly borderRadius: OptionType<StringType>;
+                    readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly width: OptionType<StringType>;
+                    readonly height: OptionType<StringType>;
+                    readonly minWidth: OptionType<StringType>;
+                    readonly minHeight: OptionType<StringType>;
+                    readonly maxWidth: OptionType<StringType>;
+                    readonly maxHeight: OptionType<StringType>;
+                    readonly padding: OptionType<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: import("@elaraai/east").NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: import("@elaraai/east").NullType;
+                    readonly recommended: import("@elaraai/east").NullType;
+                    readonly removed: import("@elaraai/east").NullType;
+                }>;
+                readonly confirmed: import("@elaraai/east").NullType;
+                readonly "in-progress": import("@elaraai/east").NullType;
+                readonly actual: import("@elaraai/east").NullType;
+                readonly rejected: import("@elaraai/east").NullType;
+            }>;
+            readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                readonly success: import("@elaraai/east").NullType;
+                readonly warning: import("@elaraai/east").NullType;
+                readonly danger: import("@elaraai/east").NullType;
+                readonly info: import("@elaraai/east").NullType;
+                readonly neutral: import("@elaraai/east").NullType;
+            }>>;
+            readonly color: OptionType<StringType>;
+            readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                readonly brand: import("@elaraai/east").NullType;
+                readonly gray: import("@elaraai/east").NullType;
+                readonly red: import("@elaraai/east").NullType;
+                readonly orange: import("@elaraai/east").NullType;
+                readonly yellow: import("@elaraai/east").NullType;
+                readonly green: import("@elaraai/east").NullType;
+                readonly teal: import("@elaraai/east").NullType;
+                readonly blue: import("@elaraai/east").NullType;
+                readonly cyan: import("@elaraai/east").NullType;
+                readonly purple: import("@elaraai/east").NullType;
+                readonly pink: import("@elaraai/east").NullType;
+                readonly success: import("@elaraai/east").NullType;
+                readonly warning: import("@elaraai/east").NullType;
+                readonly danger: import("@elaraai/east").NullType;
+                readonly info: import("@elaraai/east").NullType;
+                readonly neutral: import("@elaraai/east").NullType;
+            }>>;
+            readonly stretch: OptionType<import("@elaraai/east").VariantType<{
+                readonly horizontal: import("@elaraai/east").NullType;
+                readonly vertical: import("@elaraai/east").NullType;
+                readonly both: import("@elaraai/east").NullType;
+            }>>;
+            readonly content: OptionType<StructType<{
+                readonly horizontal: OptionType<import("@elaraai/east").VariantType<{
+                    readonly start: import("@elaraai/east").NullType;
+                    readonly center: import("@elaraai/east").NullType;
+                    readonly end: import("@elaraai/east").NullType;
+                }>>;
+                readonly vertical: OptionType<import("@elaraai/east").VariantType<{
+                    readonly start: import("@elaraai/east").NullType;
+                    readonly center: import("@elaraai/east").NullType;
+                    readonly end: import("@elaraai/east").NullType;
+                }>>;
+            }>>;
+            readonly animation: OptionType<import("@elaraai/east").VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly pulse: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly key: "key";
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly marker: {
+        readonly type: StructType<{
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly lane: OptionType<StringType>;
+            readonly status: import("@elaraai/east").VariantType<{
+                readonly success: import("@elaraai/east").NullType;
+                readonly warning: import("@elaraai/east").NullType;
+                readonly danger: import("@elaraai/east").NullType;
+                readonly info: import("@elaraai/east").NullType;
+                readonly neutral: import("@elaraai/east").NullType;
+            }>;
+            readonly message: StringType;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly chip: {
+        readonly type: StructType<{
+            readonly key: StringType;
+            readonly from: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly to: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly label: StringType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: import("@elaraai/east").NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: import("@elaraai/east").NullType;
+                    readonly recommended: import("@elaraai/east").NullType;
+                    readonly removed: import("@elaraai/east").NullType;
+                }>;
+                readonly confirmed: import("@elaraai/east").NullType;
+                readonly "in-progress": import("@elaraai/east").NullType;
+                readonly actual: import("@elaraai/east").NullType;
+                readonly rejected: import("@elaraai/east").NullType;
+            }>;
+            readonly icon: OptionType<StructType<{
+                readonly name: StringType;
+                readonly prefix: StringType;
+                readonly label: OptionType<StringType>;
+                readonly style: OptionType<StructType<{
+                    readonly size: OptionType<import("@elaraai/east").VariantType<{
+                        readonly xs: import("@elaraai/east").NullType;
+                        readonly sm: import("@elaraai/east").NullType;
+                        readonly md: import("@elaraai/east").NullType;
+                        readonly lg: import("@elaraai/east").NullType;
+                        readonly xl: import("@elaraai/east").NullType;
+                        readonly "2xl": import("@elaraai/east").NullType;
+                    }>>;
+                    readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                        readonly solid: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly color: OptionType<StringType>;
+                    readonly background: OptionType<StringType>;
+                    readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                        readonly brand: import("@elaraai/east").NullType;
+                        readonly gray: import("@elaraai/east").NullType;
+                        readonly red: import("@elaraai/east").NullType;
+                        readonly orange: import("@elaraai/east").NullType;
+                        readonly yellow: import("@elaraai/east").NullType;
+                        readonly green: import("@elaraai/east").NullType;
+                        readonly teal: import("@elaraai/east").NullType;
+                        readonly blue: import("@elaraai/east").NullType;
+                        readonly cyan: import("@elaraai/east").NullType;
+                        readonly purple: import("@elaraai/east").NullType;
+                        readonly pink: import("@elaraai/east").NullType;
+                        readonly success: import("@elaraai/east").NullType;
+                        readonly warning: import("@elaraai/east").NullType;
+                        readonly danger: import("@elaraai/east").NullType;
+                        readonly info: import("@elaraai/east").NullType;
+                        readonly neutral: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly opacity: OptionType<FloatType>;
+                    readonly borderRadius: OptionType<StringType>;
+                    readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly width: OptionType<StringType>;
+                    readonly height: OptionType<StringType>;
+                    readonly minWidth: OptionType<StringType>;
+                    readonly minHeight: OptionType<StringType>;
+                    readonly maxWidth: OptionType<StringType>;
+                    readonly maxHeight: OptionType<StringType>;
+                    readonly padding: OptionType<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 key: "key";
+        readonly instants: readonly ["from", "to"];
+        readonly look: (l: never) => object;
+    };
+    readonly mark: {
+        readonly type: StructType<{
+            readonly key: StringType;
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly kind: import("@elaraai/east").VariantType<{
+                readonly milestone: import("@elaraai/east").NullType;
+                readonly decision: StructType<{
+                    readonly applied: BooleanType;
+                }>;
+                readonly exception: import("@elaraai/east").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: import("@elaraai/east").NullType;
+                        readonly sm: import("@elaraai/east").NullType;
+                        readonly md: import("@elaraai/east").NullType;
+                        readonly lg: import("@elaraai/east").NullType;
+                        readonly xl: import("@elaraai/east").NullType;
+                        readonly "2xl": import("@elaraai/east").NullType;
+                    }>>;
+                    readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                        readonly solid: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly color: OptionType<StringType>;
+                    readonly background: OptionType<StringType>;
+                    readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
+                        readonly brand: import("@elaraai/east").NullType;
+                        readonly gray: import("@elaraai/east").NullType;
+                        readonly red: import("@elaraai/east").NullType;
+                        readonly orange: import("@elaraai/east").NullType;
+                        readonly yellow: import("@elaraai/east").NullType;
+                        readonly green: import("@elaraai/east").NullType;
+                        readonly teal: import("@elaraai/east").NullType;
+                        readonly blue: import("@elaraai/east").NullType;
+                        readonly cyan: import("@elaraai/east").NullType;
+                        readonly purple: import("@elaraai/east").NullType;
+                        readonly pink: import("@elaraai/east").NullType;
+                        readonly success: import("@elaraai/east").NullType;
+                        readonly warning: import("@elaraai/east").NullType;
+                        readonly danger: import("@elaraai/east").NullType;
+                        readonly info: import("@elaraai/east").NullType;
+                        readonly neutral: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly opacity: OptionType<FloatType>;
+                    readonly borderRadius: OptionType<StringType>;
+                    readonly overflow: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                        readonly visible: import("@elaraai/east").NullType;
+                        readonly hidden: import("@elaraai/east").NullType;
+                        readonly scroll: import("@elaraai/east").NullType;
+                        readonly auto: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly width: OptionType<StringType>;
+                    readonly height: OptionType<StringType>;
+                    readonly minWidth: OptionType<StringType>;
+                    readonly minHeight: OptionType<StringType>;
+                    readonly maxWidth: OptionType<StringType>;
+                    readonly maxHeight: OptionType<StringType>;
+                    readonly padding: OptionType<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 key: "key";
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly heat: {
+        readonly type: StructType<{
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly value: OptionType<FloatType>;
+            readonly label: OptionType<StringType>;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly weight: {
+        readonly type: StructType<{
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly fraction: FloatType;
+            readonly planned: BooleanType;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly segment: {
+        readonly type: StructType<{
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly segments: ArrayType<StructType<{
+                readonly fill: import("@elaraai/east").VariantType<{
+                    readonly brand: import("@elaraai/east").NullType;
+                    readonly success: import("@elaraai/east").NullType;
+                    readonly warning: import("@elaraai/east").NullType;
+                    readonly danger: import("@elaraai/east").NullType;
+                    readonly info: import("@elaraai/east").NullType;
+                    readonly neutral: import("@elaraai/east").NullType;
+                    readonly slack: import("@elaraai/east").NullType;
+                    readonly free: import("@elaraai/east").NullType;
+                }>;
+                readonly weight: FloatType;
+                readonly label: OptionType<StringType>;
+            }>>;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly table: {
+        readonly type: StructType<{
+            readonly at: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly value: OptionType<FloatType>;
+            readonly text: OptionType<StringType>;
+            readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                readonly neg: import("@elaraai/east").NullType;
+                readonly muted: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["at"];
+        readonly look: (l: never) => object;
+    };
+    readonly point: {
+        readonly type: StructType<{
+            readonly t: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly y: FloatType;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["t"];
+        readonly look: (l: never) => object;
+    };
+    readonly band: {
+        readonly type: StructType<{
+            readonly t: import("@elaraai/east").VariantType<{
+                readonly time: DateTimeType;
+                readonly number: FloatType;
+                readonly ordinal: StringType;
+            }>;
+            readonly lo: FloatType;
+            readonly hi: FloatType;
+        }>;
+        readonly key: undefined;
+        readonly instants: readonly ["t"];
+        readonly look: (l: never) => object;
+    };
+};
+/** What a named read completes. @internal */
+export type PlanLookKind = keyof typeof PLAN_LOOKS;
 /**
  * Flat input for {@link Plan.run} — one continuous state-run bar.
  *
@@ -594,6 +2063,17 @@ export declare const markKind: {
      */
     readonly decision: (applied: SubtypeExprOrValue<BooleanType> | boolean) => ExprType<PlanEventMarkKindType>;
 };
+/**
+ * The fold an options object declares, as its literal type, else the default
+ * (#1436) — what a consumer of a values read brands its subtotals with. A fold
+ * given as an East value names none the types can see.
+ *
+ * @typeParam O - The options, as written
+ * @typeParam D - The consumer's default fold
+ */
+export type PlanFoldOf<O, D extends PlanFoldLiteral> = O extends {
+    readonly fold: infer F;
+} ? (F extends PlanFoldLiteral ? F : D) : D;
 /**
  * A heat scale — the value at no depth, the value at full depth, and the warn
  * threshold ({@link PlanHeatScaleType}).
@@ -659,6 +2139,7 @@ export interface PlanHeatCellsOptions extends PlanHeatScaleInput, PlanCellsFoldO
  * @param options - Scale, warn threshold, fold and format ({@link PlanHeatCellsOptions})
  * @returns A `PlanHeatCellsType` expression, branded with the cells' kind
  */
+export declare function createHeatCells<R extends EastType, K extends PlanAxisKindLiteral, U, const O extends PlanHeatCellsOptions = PlanHeatCellsOptions>(values: PlanValuesInput<R, PlanHeatCellLook, K, U>, options?: O): PlanValuesUse<"heat", R, K, U, PlanFoldOf<O, "mean">>;
 export declare function createHeatCells<K extends PlanAxisKindLiteral = never>(cells: PlanCellsInput<PlanHeatCellType, K>, options?: PlanHeatCellsOptions): PlanHeatCellsExpr<K>;
 /**
  * Wraps per-bucket weight cells into the `weight` arm of
@@ -677,6 +2158,7 @@ export declare function createHeatCells<K extends PlanAxisKindLiteral = never>(c
  * @param options - Fold and format ({@link PlanCellsFoldOptions})
  * @returns A `PlanHeatCellsType` expression, branded with the cells' kind
  */
+export declare function createWeightCells<R extends EastType, K extends PlanAxisKindLiteral, U, const O extends PlanCellsFoldOptions = PlanCellsFoldOptions>(values: PlanValuesInput<R, PlanWeightCellLook, K, U>, options?: O): PlanValuesUse<"heat", R, K, U, PlanFoldOf<O, "mean">>;
 export declare function createWeightCells<K extends PlanAxisKindLiteral = never>(cells: PlanCellsInput<PlanWeightCellType, K>, options?: PlanCellsFoldOptions): PlanHeatCellsExpr<K>;
 /**
  * Wraps per-bucket segment cells into the `segments` arm of
@@ -694,6 +2176,7 @@ export declare function createWeightCells<K extends PlanAxisKindLiteral = never>
  * @param options - Fold and format ({@link PlanCellsFoldOptions})
  * @returns A `PlanHeatCellsType` expression, branded with the cells' kind
  */
+export declare function createSegmentCells<R extends EastType, K extends PlanAxisKindLiteral, U, const O extends PlanCellsFoldOptions = PlanCellsFoldOptions>(values: PlanValuesInput<R, PlanSegmentCellLook, K, U>, options?: O): PlanValuesUse<"heat", R, K, U, PlanFoldOf<O, "sum">>;
 export declare function createSegmentCells<K extends PlanAxisKindLiteral = never>(cells: PlanCellsInput<PlanSegmentCellType, K>, options?: PlanCellsFoldOptions): PlanHeatCellsExpr<K>;
 /**
  * Flat input for {@link Plan.segment} — one weighted slice of a segment cell.
@@ -744,6 +2227,41 @@ export interface PlanTableSeriesInput<K extends PlanAxisKindLiteral = never> {
     /** How a bucket folds this series' cells at a coarser resolution than theirs (default `"sum"`, #824). */
     fold?: PlanFoldInput;
 }
+/**
+ * Input for {@link Plan.tableSeries} over a values read (#1436) — one position
+ * of a table row, its cells a row's values (`Plan.tableCells(Plan.values(field,
+ * draw))`). Its `fold` and `rollup` are literals, since a parent's subtotal of
+ * them is what a source's index keeps (#1435).
+ *
+ * @typeParam R - The entry type
+ * @typeParam K - The cells' axis kind
+ * @typeParam U - What the cells read
+ * @typeParam FO - How a bucket folds the position's values
+ * @typeParam RO - Whether the position feeds its parent's subtotal
+ * @property cells - The position's cells, from a values read
+ * @property format - Numeral format override for this position
+ * @property tone - Default tone for its values
+ * @property strong - Semibold emphasis for its values
+ * @property rollup - `true` ⇒ it feeds the parent's subtotal (flag none ⇒ every position does)
+ * @property fold - How a bucket folds its values at a coarser resolution (default `"sum"`)
+ * @property edit - `true` ⇒ its values take typed numbers, each drawn as stored (#1436)
+ */
+export interface PlanTableSeriesOfValues<R extends EastType, K extends PlanAxisKindLiteral, U, FO extends PlanFoldLiteral, RO extends boolean> {
+    /** The position's cells — `Plan.tableCells(Plan.values(field, draw))`. */
+    cells: PlanValuesUse<"tableCells", R, K, U>;
+    /** Numeral format override for this position — a `Format.*` spec. */
+    format?: SubtypeExprOrValue<TickFormatType>;
+    /** Default tone for its values. */
+    tone?: SubtypeExprOrValue<PlanTableToneType> | PlanTableToneLiteral;
+    /** Semibold emphasis for its values. */
+    strong?: SubtypeExprOrValue<BooleanType> | boolean;
+    /** `true` ⇒ it feeds the parent's subtotal (flag none and every position does). */
+    rollup?: RO;
+    /** How a bucket folds its values at a coarser resolution than theirs (default `"sum"`). */
+    fold?: FO;
+    /** `true` ⇒ a number typed into one of its cells is written as the value at the bucket's start (#1436) — its cells' draw giving each value as stored, `value: some(v)`. */
+    edit?: PlanValuesEdit;
+}
 /**
  * Builds one table-row value series (see {@link Plan.table}'s `series`) —
  * per-position style declared once, raw cells beneath it; the result carries
@@ -753,6 +2271,7 @@ export interface PlanTableSeriesInput<K extends PlanAxisKindLiteral = never> {
  * @param input - The series configuration ({@link PlanTableSeriesInput})
  * @returns An East expression of {@link PlanTableSeriesType}, branded with the cells' kind
  */
+export declare function createTableSeries<R extends EastType, K extends PlanAxisKindLiteral, U, const FO extends PlanFoldLiteral = "sum", const RO extends boolean = false>(input: PlanTableSeriesOfValues<R, K, U, FO, RO>): PlanValuesUse<"tableSeries", R, K, U, FO, RO>;
 export declare function createTableSeries<K extends PlanAxisKindLiteral = never>(input: PlanTableSeriesInput<K>): PlanTableSeriesExpr<K>;
 /**
  * The raw table-cell record — `{ at, value }`, its `at` any
@@ -783,6 +2302,7 @@ export type PlanRawTableCellType = StructType<{
  * @returns An `ArrayType(PlanTableCellType)` expression, branded with the cells' kind
  * @throws {Error} If an East array's element `at` is not an instant-typed field
  */
+export declare function createTableCells<R extends EastType, K extends PlanAxisKindLiteral, U>(values: PlanValuesInput<R, PlanTableCellLook, K, U>): PlanValuesUse<"tableCells", R, K, U>;
 export declare function createTableCells<A extends PlanInstantInput = never>(cells: {
     at: A;
     value: SubtypeExprOrValue<OptionType<FloatType>>;