@elaraai/east-ui 1.0.4 → 1.0.5

package/dist/src/charts/spec/index.d.ts

@@ -2,8 +2,9 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import { type ExprType, type SubtypeExprOrValue, ArrayType, FloatType, OptionType, RecursiveType, StructType, VariantType } from "@elaraai/east";
-import { ChartSeriesArrayType } from "./types.js";
+import { type ExprType, type SubtypeExprOrValue, ArrayType, StringType, FloatType, BooleanType, OptionType, RecursiveType, StructType, VariantType } from "@elaraai/east";
+import { SliceChromeType } from "../../platform/slice/index.js";
+import { ChartXType, ChartDomainType, ChartSeriesArrayType, ChartBandSeriesArrayType, ChartTickFormatType, ChartCurveType, type ChartCurveLiteral, ChartStackOffsetType, type ChartStackOffsetLiteral, YAxisSideType, type YAxisSideLiteral } from "./types.js";
 export * from "./types.js";
 /**
  * `ChartSpecType` — the recursive visx-primitive chart IR. A chart value is a
@@ -12,19 +13,23 @@ export * from "./types.js";
  * them down so every mark / axis / grid aligns. Factory helpers (`Slice.Chart.*`,
  * and the migrated `Chart.*` later) assemble the tree.
  *
- * @property frame      - Sized (responsive when `width` is `none`) plotting frame; owns margins, x/y scale kinds, children
- * @property group      - A translated container (`visx` `Group`) of children
- * @property linePath   - A polyline (`visx` `LinePath`)
- * @property area       - A filled area (`visx` `AreaClosed`)
- * @property bars       - Vertical bars (`visx` `Bar`) at band positions
- * @property points     - Point markers (`visx` `Circle`)
- * @property rule       - A reference line spanning the plot at a data coordinate
- * @property text       - A free SVG text label at a data coordinate
- * @property axisBottom - X axis (`visx` `AxisBottom`) from the band/time scale
- * @property axisLeft   - Y axis (`visx` `AxisLeft`) from the linear scale
- * @property gridRows   - Horizontal gridlines (`visx` `GridRows`)
- * @property gridColumns- Vertical gridlines (`visx` `GridColumns`)
- * @property series     - Multi-series convenience: one mark per coloured series
+ * @property frame         - Sized (responsive when `width` is `none`) plotting frame; owns margins, x/y scale kinds, optional secondary y-scale, tooltip / legend, children
+ * @property group         - A translated container (`visx` `Group`) of children
+ * @property linePath      - A polyline (`visx` `LinePath`)
+ * @property area          - A filled area (`visx` `AreaClosed`)
+ * @property bandArea      - A filled band between low/high bounds per x (area-range)
+ * @property bars          - Vertical bars (`visx` `Bar`) at band positions
+ * @property points        - Point markers (`visx` `Circle`)
+ * @property rule          - A reference line spanning the plot at a data coordinate
+ * @property referenceDot  - A highlighted marker at a data coordinate
+ * @property referenceArea - A shaded region spanning a range on one or both axes
+ * @property text          - A free SVG text label at a data coordinate
+ * @property axisBottom    - X axis (`visx` `AxisBottom`) from the band/time scale
+ * @property axisLeft      - Primary y axis (`visx` `AxisLeft`) from the linear scale
+ * @property axisRight     - Secondary y axis for a dual-axis chart
+ * @property gridRows      - Horizontal gridlines (`visx` `GridRows`)
+ * @property gridColumns   - Vertical gridlines (`visx` `GridColumns`)
+ * @property series        - Multi-series layer: one mark per coloured series
  */
 export declare const ChartSpecType: RecursiveType<VariantType<{
     readonly frame: StructType<{
@@ -46,6 +51,561 @@ export declare const ChartSpecType: RecursiveType<VariantType<{
             readonly linear: import("@elaraai/east").NullType;
             readonly time: import("@elaraai/east").NullType;
         }>;
+        readonly yScale2: OptionType<VariantType<{
+            readonly band: import("@elaraai/east").NullType;
+            readonly linear: import("@elaraai/east").NullType;
+            readonly time: import("@elaraai/east").NullType;
+        }>>;
+        readonly tooltip: OptionType<StructType<{
+            readonly cursor: OptionType<VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly line: import("@elaraai/east").NullType;
+                readonly fill: import("@elaraai/east").NullType;
+            }>>;
+        }>>;
+        readonly legend: OptionType<StructType<{
+            readonly orientation: OptionType<VariantType<{
+                readonly horizontal: import("@elaraai/east").NullType;
+                readonly vertical: import("@elaraai/east").NullType;
+            }>>;
+            readonly position: OptionType<VariantType<{
+                readonly top: import("@elaraai/east").NullType;
+                readonly bottom: import("@elaraai/east").NullType;
+                readonly left: import("@elaraai/east").NullType;
+                readonly right: import("@elaraai/east").NullType;
+            }>>;
+        }>>;
+        readonly slice: OptionType<StructType<{
+            readonly slice: StructType<{
+                readonly key: StringType;
+                readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                    readonly range: OptionType<VariantType<{
+                        readonly datetime: StructType<{
+                            readonly from: import("@elaraai/east").DateTimeType;
+                            readonly to: import("@elaraai/east").DateTimeType;
+                        }>;
+                        readonly datetimePreset: VariantType<{
+                            readonly today: import("@elaraai/east").NullType;
+                            readonly last7d: import("@elaraai/east").NullType;
+                            readonly last30d: import("@elaraai/east").NullType;
+                            readonly last90d: import("@elaraai/east").NullType;
+                            readonly ytd: import("@elaraai/east").NullType;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly from: import("@elaraai/east").IntegerType;
+                            readonly to: import("@elaraai/east").IntegerType;
+                        }>;
+                        readonly float: StructType<{
+                            readonly from: FloatType;
+                            readonly to: FloatType;
+                        }>;
+                    }>>;
+                    readonly compare: OptionType<VariantType<{
+                        readonly previousPeriod: import("@elaraai/east").NullType;
+                        readonly previousYear: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly cohorts: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: import("@elaraai/east").IntegerType;
+                                    readonly neq: import("@elaraai/east").IntegerType;
+                                    readonly lt: import("@elaraai/east").IntegerType;
+                                    readonly lte: import("@elaraai/east").IntegerType;
+                                    readonly gt: import("@elaraai/east").IntegerType;
+                                    readonly gte: import("@elaraai/east").IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly before: import("@elaraai/east").DateTimeType;
+                                    readonly after: import("@elaraai/east").DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: import("@elaraai/east").DateTimeType;
+                                        readonly to: import("@elaraai/east").DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                    readonly breakdown: OptionType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                    }>>;
+                    readonly search: OptionType<StringType>;
+                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                    readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly write: import("@elaraai/east").FunctionType<[StructType<{
+                    readonly range: OptionType<VariantType<{
+                        readonly datetime: StructType<{
+                            readonly from: import("@elaraai/east").DateTimeType;
+                            readonly to: import("@elaraai/east").DateTimeType;
+                        }>;
+                        readonly datetimePreset: VariantType<{
+                            readonly today: import("@elaraai/east").NullType;
+                            readonly last7d: import("@elaraai/east").NullType;
+                            readonly last30d: import("@elaraai/east").NullType;
+                            readonly last90d: import("@elaraai/east").NullType;
+                            readonly ytd: import("@elaraai/east").NullType;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly from: import("@elaraai/east").IntegerType;
+                            readonly to: import("@elaraai/east").IntegerType;
+                        }>;
+                        readonly float: StructType<{
+                            readonly from: FloatType;
+                            readonly to: FloatType;
+                        }>;
+                    }>>;
+                    readonly compare: OptionType<VariantType<{
+                        readonly previousPeriod: import("@elaraai/east").NullType;
+                        readonly previousYear: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly cohorts: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: import("@elaraai/east").IntegerType;
+                                    readonly neq: import("@elaraai/east").IntegerType;
+                                    readonly lt: import("@elaraai/east").IntegerType;
+                                    readonly lte: import("@elaraai/east").IntegerType;
+                                    readonly gt: import("@elaraai/east").IntegerType;
+                                    readonly gte: import("@elaraai/east").IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly before: import("@elaraai/east").DateTimeType;
+                                    readonly after: import("@elaraai/east").DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: import("@elaraai/east").DateTimeType;
+                                        readonly to: import("@elaraai/east").DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                    readonly breakdown: OptionType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                    }>>;
+                    readonly search: OptionType<StringType>;
+                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                    readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                }>], import("@elaraai/east").NullType>;
+                readonly setRange: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: import("@elaraai/east").DateTimeType;
+                        readonly to: import("@elaraai/east").DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: import("@elaraai/east").NullType;
+                        readonly last7d: import("@elaraai/east").NullType;
+                        readonly last30d: import("@elaraai/east").NullType;
+                        readonly last90d: import("@elaraai/east").NullType;
+                        readonly ytd: import("@elaraai/east").NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: FloatType;
+                    }>;
+                }>>], import("@elaraai/east").NullType>;
+                readonly setCompare: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                    readonly previousPeriod: import("@elaraai/east").NullType;
+                    readonly previousYear: import("@elaraai/east").NullType;
+                }>>], import("@elaraai/east").NullType>;
+                readonly addFilter: import("@elaraai/east").FunctionType<[VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: import("@elaraai/east").DateTimeType;
+                            readonly after: import("@elaraai/east").DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>], import("@elaraai/east").NullType>;
+                readonly removeFilter: import("@elaraai/east").FunctionType<[import("@elaraai/east").IntegerType], import("@elaraai/east").NullType>;
+                readonly clearFilters: import("@elaraai/east").FunctionType<[], import("@elaraai/east").NullType>;
+                readonly defineCohort: import("@elaraai/east").FunctionType<[StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>], import("@elaraai/east").NullType>;
+                readonly updateCohort: import("@elaraai/east").FunctionType<[StringType, StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>], import("@elaraai/east").NullType>;
+                readonly removeCohort: import("@elaraai/east").FunctionType<[StringType], import("@elaraai/east").NullType>;
+                readonly toggleCohort: import("@elaraai/east").FunctionType<[StringType], import("@elaraai/east").NullType>;
+                readonly setBreakdown: import("@elaraai/east").FunctionType<[OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>], import("@elaraai/east").NullType>;
+                readonly setSearch: import("@elaraai/east").FunctionType<[OptionType<StringType>], import("@elaraai/east").NullType>;
+                readonly setVisible: import("@elaraai/east").FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], import("@elaraai/east").NullType>;
+                readonly select: import("@elaraai/east").FunctionType<[OptionType<import("@elaraai/east").IntegerType>], import("@elaraai/east").NullType>;
+                readonly isActive: import("@elaraai/east").FunctionType<[], BooleanType>;
+                readonly activeCount: import("@elaraai/east").FunctionType<[], import("@elaraai/east").IntegerType>;
+                readonly dimensions: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly label: StringType;
+                }>>>;
+                readonly fields: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly label: StringType;
+                    readonly kind: StringType;
+                }>>>;
+                readonly searchFieldIds: import("@elaraai/east").FunctionType<[], ArrayType<StringType>>;
+                readonly rangeFieldId: import("@elaraai/east").FunctionType<[], OptionType<StringType>>;
+                readonly totalCount: import("@elaraai/east").FunctionType<[], import("@elaraai/east").IntegerType>;
+                readonly resultCount: import("@elaraai/east").FunctionType<[], import("@elaraai/east").IntegerType>;
+                readonly groups: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly count: import("@elaraai/east").IntegerType;
+                    readonly color: StringType;
+                }>>>;
+                readonly series: import("@elaraai/east").FunctionType<[StringType, StringType], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly color: StringType;
+                    readonly points: ArrayType<StructType<{
+                        readonly x: VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: import("@elaraai/east").DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                    }>>;
+                }>>>;
+                readonly matches: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly label: StringType;
+                    readonly meta: OptionType<StringType>;
+                }>>>;
+                readonly cohortCounts: import("@elaraai/east").FunctionType<[], import("@elaraai/east").DictType<StringType, import("@elaraai/east").IntegerType>>;
+            }>;
+            readonly affordances: ArrayType<VariantType<{
+                readonly filter: import("@elaraai/east").NullType;
+                readonly search: import("@elaraai/east").NullType;
+                readonly breakdown: import("@elaraai/east").NullType;
+                readonly range: import("@elaraai/east").NullType;
+                readonly cohort: import("@elaraai/east").NullType;
+                readonly brush: import("@elaraai/east").NullType;
+            }>>;
+        }>>;
         readonly children: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
     }>;
     readonly group: StructType<{
@@ -55,10 +615,15 @@ export declare const ChartSpecType: RecursiveType<VariantType<{
     }>;
     readonly linePath: StructType<{
         readonly points: ArrayType<StructType<{
-            readonly x: import("@elaraai/east").StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>>;
-        readonly stroke: import("@elaraai/east").StringType;
+        readonly stroke: StringType;
         readonly strokeWidth: OptionType<FloatType>;
         readonly curve: OptionType<VariantType<{
             readonly monotoneX: import("@elaraai/east").NullType;
@@ -66,17 +631,22 @@ export declare const ChartSpecType: RecursiveType<VariantType<{
             readonly natural: import("@elaraai/east").NullType;
             readonly step: import("@elaraai/east").NullType;
         }>>;
-        readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+        readonly dashArray: OptionType<StringType>;
         readonly opacity: OptionType<FloatType>;
     }>;
     readonly area: StructType<{
         readonly points: ArrayType<StructType<{
-            readonly x: import("@elaraai/east").StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>>;
-        readonly fill: import("@elaraai/east").StringType;
+        readonly fill: StringType;
         readonly fillOpacity: OptionType<FloatType>;
-        readonly stroke: OptionType<import("@elaraai/east").StringType>;
+        readonly stroke: OptionType<StringType>;
         readonly strokeWidth: OptionType<FloatType>;
         readonly curve: OptionType<VariantType<{
             readonly monotoneX: import("@elaraai/east").NullType;
@@ -85,23 +655,55 @@ export declare const ChartSpecType: RecursiveType<VariantType<{
             readonly step: import("@elaraai/east").NullType;
         }>>;
     }>;
+    readonly bandArea: StructType<{
+        readonly data: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly color: StringType;
+            readonly points: ArrayType<StructType<{
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly low: FloatType;
+                readonly high: FloatType;
+            }>>;
+        }>>;
+        readonly curve: OptionType<VariantType<{
+            readonly monotoneX: import("@elaraai/east").NullType;
+            readonly linear: import("@elaraai/east").NullType;
+            readonly natural: import("@elaraai/east").NullType;
+            readonly step: import("@elaraai/east").NullType;
+        }>>;
+        readonly fillOpacity: OptionType<FloatType>;
+    }>;
     readonly bars: StructType<{
         readonly points: ArrayType<StructType<{
-            readonly x: import("@elaraai/east").StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>>;
-        readonly fill: import("@elaraai/east").StringType;
+        readonly fill: StringType;
         readonly fillOpacity: OptionType<FloatType>;
         readonly radius: OptionType<FloatType>;
     }>;
     readonly points: StructType<{
         readonly points: ArrayType<StructType<{
-            readonly x: import("@elaraai/east").StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>>;
-        readonly fill: import("@elaraai/east").StringType;
+        readonly fill: StringType;
         readonly radius: OptionType<FloatType>;
-        readonly stroke: OptionType<import("@elaraai/east").StringType>;
+        readonly stroke: OptionType<StringType>;
         readonly strokeWidth: OptionType<FloatType>;
     }>;
     readonly rule: StructType<{
@@ -109,52 +711,165 @@ export declare const ChartSpecType: RecursiveType<VariantType<{
             readonly x: import("@elaraai/east").NullType;
             readonly y: import("@elaraai/east").NullType;
         }>;
-        readonly at: import("@elaraai/east").StringType;
-        readonly stroke: import("@elaraai/east").StringType;
-        readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+        readonly at: StringType;
+        readonly stroke: StringType;
+        readonly dashArray: OptionType<StringType>;
+    }>;
+    readonly referenceDot: StructType<{
+        readonly x: VariantType<{
+            readonly category: StringType;
+            readonly number: FloatType;
+            readonly time: import("@elaraai/east").DateTimeType;
+        }>;
+        readonly y: FloatType;
+        readonly fill: OptionType<StringType>;
+        readonly radius: OptionType<FloatType>;
+        readonly stroke: OptionType<StringType>;
+        readonly strokeWidth: OptionType<FloatType>;
+        readonly label: OptionType<StringType>;
+    }>;
+    readonly referenceArea: StructType<{
+        readonly x1: OptionType<VariantType<{
+            readonly category: StringType;
+            readonly number: FloatType;
+            readonly time: import("@elaraai/east").DateTimeType;
+        }>>;
+        readonly x2: OptionType<VariantType<{
+            readonly category: StringType;
+            readonly number: FloatType;
+            readonly time: import("@elaraai/east").DateTimeType;
+        }>>;
+        readonly y1: OptionType<FloatType>;
+        readonly y2: OptionType<FloatType>;
+        readonly fill: OptionType<StringType>;
+        readonly fillOpacity: OptionType<FloatType>;
+        readonly stroke: OptionType<StringType>;
+        readonly label: OptionType<StringType>;
     }>;
     readonly text: StructType<{
         readonly point: StructType<{
-            readonly x: import("@elaraai/east").StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>;
-        readonly text: import("@elaraai/east").StringType;
+        readonly text: StringType;
         readonly anchor: OptionType<VariantType<{
             readonly start: import("@elaraai/east").NullType;
             readonly middle: import("@elaraai/east").NullType;
             readonly end: import("@elaraai/east").NullType;
         }>>;
-        readonly fill: OptionType<import("@elaraai/east").StringType>;
+        readonly fill: OptionType<StringType>;
         readonly fontSize: OptionType<FloatType>;
         readonly fontWeight: OptionType<FloatType>;
     }>;
     readonly axisBottom: StructType<{
-        readonly label: OptionType<import("@elaraai/east").StringType>;
+        readonly label: OptionType<StringType>;
         readonly numTicks: OptionType<FloatType>;
-        readonly hideTicks: OptionType<import("@elaraai/east").BooleanType>;
-        readonly hideLine: OptionType<import("@elaraai/east").BooleanType>;
+        readonly hideTicks: OptionType<BooleanType>;
+        readonly hideLine: OptionType<BooleanType>;
+        readonly domain: OptionType<VariantType<{
+            readonly number: StructType<{
+                readonly min: FloatType;
+                readonly max: FloatType;
+            }>;
+            readonly time: StructType<{
+                readonly min: import("@elaraai/east").DateTimeType;
+                readonly max: import("@elaraai/east").DateTimeType;
+            }>;
+        }>>;
+        readonly tickFormat: OptionType<VariantType<{
+            readonly number: import("@elaraai/east").NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: import("@elaraai/east").NullType;
+            readonly compact: import("@elaraai/east").NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
     }>;
     readonly axisLeft: StructType<{
-        readonly label: OptionType<import("@elaraai/east").StringType>;
+        readonly label: OptionType<StringType>;
+        readonly numTicks: OptionType<FloatType>;
+        readonly hideTicks: OptionType<BooleanType>;
+        readonly hideLine: OptionType<BooleanType>;
+        readonly domain: OptionType<VariantType<{
+            readonly number: StructType<{
+                readonly min: FloatType;
+                readonly max: FloatType;
+            }>;
+            readonly time: StructType<{
+                readonly min: import("@elaraai/east").DateTimeType;
+                readonly max: import("@elaraai/east").DateTimeType;
+            }>;
+        }>>;
+        readonly tickFormat: OptionType<VariantType<{
+            readonly number: import("@elaraai/east").NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: import("@elaraai/east").NullType;
+            readonly compact: import("@elaraai/east").NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
+    }>;
+    readonly axisRight: StructType<{
+        readonly label: OptionType<StringType>;
         readonly numTicks: OptionType<FloatType>;
-        readonly hideTicks: OptionType<import("@elaraai/east").BooleanType>;
-        readonly hideLine: OptionType<import("@elaraai/east").BooleanType>;
+        readonly hideTicks: OptionType<BooleanType>;
+        readonly hideLine: OptionType<BooleanType>;
+        readonly domain: OptionType<VariantType<{
+            readonly number: StructType<{
+                readonly min: FloatType;
+                readonly max: FloatType;
+            }>;
+            readonly time: StructType<{
+                readonly min: import("@elaraai/east").DateTimeType;
+                readonly max: import("@elaraai/east").DateTimeType;
+            }>;
+        }>>;
+        readonly tickFormat: OptionType<VariantType<{
+            readonly number: import("@elaraai/east").NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: import("@elaraai/east").NullType;
+            readonly compact: import("@elaraai/east").NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
     }>;
     readonly gridRows: StructType<{
         readonly numTicks: OptionType<FloatType>;
-        readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+        readonly dashArray: OptionType<StringType>;
     }>;
     readonly gridColumns: StructType<{
         readonly numTicks: OptionType<FloatType>;
-        readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+        readonly dashArray: OptionType<StringType>;
     }>;
     readonly series: StructType<{
         readonly data: ArrayType<StructType<{
-            readonly key: import("@elaraai/east").StringType;
-            readonly color: import("@elaraai/east").StringType;
+            readonly key: StringType;
+            readonly color: StringType;
             readonly points: ArrayType<StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
         }>>;
         readonly mark: VariantType<{
@@ -163,17 +878,52 @@ export declare const ChartSpecType: RecursiveType<VariantType<{
             readonly area: import("@elaraai/east").NullType;
             readonly scatter: import("@elaraai/east").NullType;
         }>;
+        readonly curve: OptionType<VariantType<{
+            readonly monotoneX: import("@elaraai/east").NullType;
+            readonly linear: import("@elaraai/east").NullType;
+            readonly natural: import("@elaraai/east").NullType;
+            readonly step: import("@elaraai/east").NullType;
+        }>>;
+        readonly stackId: OptionType<StringType>;
+        readonly stackOffset: OptionType<VariantType<{
+            readonly none: import("@elaraai/east").NullType;
+            readonly expand: import("@elaraai/east").NullType;
+        }>>;
+        readonly axis: OptionType<VariantType<{
+            readonly left: import("@elaraai/east").NullType;
+            readonly right: import("@elaraai/east").NullType;
+        }>>;
+        readonly strokeWidth: OptionType<FloatType>;
+        readonly dashArray: OptionType<StringType>;
+        readonly dots: OptionType<BooleanType>;
+        readonly fillOpacity: OptionType<FloatType>;
+        readonly radius: OptionType<FloatType>;
     }>;
 }>>;
 export type ChartSpecType = typeof ChartSpecType;
 /** A `ChartSpec` node value (one arm of {@link ChartSpecType}). */
 export type ChartSpecValue = ExprType<ChartSpecType>;
-/** Options for {@link chartFrame}. */
+/**
+ * Options for {@link chartFrame}.
+ *
+ * @remarks
+ * The x/y scale kinds default to `band` / `linear`; the high-level mark builders
+ * set `xScale` to match the data's coordinate type ({@link ChartXType}).
+ *
+ * @property height  - Plot height in px
+ * @property width   - Plot width in px; omit for responsive (fills the container)
+ * @property margin  - Margins around the plotting area; defaults reserve axis room
+ * @property xScale  - X-scale kind
+ * @property yScale  - Y-scale kind
+ * @property yScale2 - Secondary (right) y-scale kind; omit for a single y-axis
+ * @property tooltip - Enable the in-chart tooltip
+ * @property legend  - Enable the in-chart legend
+ */
 export interface ChartFrameOptions {
     /** Plot height in px. */
-    height: number;
+    height: SubtypeExprOrValue<FloatType>;
     /** Plot width in px; omit for responsive (fills the container). */
-    width?: number;
+    width?: SubtypeExprOrValue<FloatType>;
     /** Margins around the plotting area; sensible defaults reserve axis room. */
     margin?: {
         top: number;
@@ -185,52 +935,414 @@ export interface ChartFrameOptions {
     xScale?: "band" | "linear" | "time";
     /** Y-scale kind (default `linear`). */
     yScale?: "band" | "linear" | "time";
+    /** Secondary (right) y-scale kind; omit for a single y-axis. */
+    yScale2?: "band" | "linear" | "time";
+    /** Enable the in-chart tooltip. */
+    tooltip?: boolean;
+    /** Enable the in-chart legend. */
+    legend?: boolean;
+    /** Slice chrome — the bound handle + rail affordances (set by `Chart.Root`'s `slice` option). */
+    slice?: SubtypeExprOrValue<SliceChromeType>;
 }
-/** A sized plotting frame owning the x/y scale kinds + child marks. */
+/**
+ * Creates a sized plotting `frame` node — the root of a chart tree.
+ *
+ * @param children - The marks / axes / grids drawn inside the frame
+ * @param options  - Sizing, scale kinds, and tooltip / legend toggles (see {@link ChartFrameOptions})
+ * @returns A `frame` {@link ChartSpecValue}
+ *
+ * @remarks
+ * Owns the x/y scale kinds and child nodes; the renderer derives each scale's
+ * domain from the descendant points. A secondary `yScale2` enables a right axis
+ * that series bound with `axis: "right"` scale against.
+ */
 export declare function chartFrame(children: Array<ChartSpecValue>, options: ChartFrameOptions): ChartSpecValue;
-/** Multi-series marks (one `mark` per series) over the coloured `data`. */
-export declare function chartSeries(data: SubtypeExprOrValue<ChartSeriesArrayType>, mark: "line" | "bar" | "area" | "scatter"): ChartSpecValue;
-/** Mono-uppercase x axis (band/time scale). */
-export declare function chartAxisBottom(options?: {
-    label?: string;
-    numTicks?: number;
+/**
+ * Options for {@link chartSeries} — the styling that applies to a whole layer.
+ *
+ * @remarks
+ * Mirrors the optional fields of {@link ChartSeriesMarkType}. Per-series colours
+ * live on each series in `data`; these apply across the layer.
+ *
+ * @property curve       - Line/area interpolation
+ * @property stackId     - Group id; layers sharing one stack accumulate together
+ * @property stackOffset - Stacking offset for the group (`none` or `expand`)
+ * @property axis        - Which y-axis the layer scales against
+ * @property strokeWidth - Stroke width for line marks and mark outlines
+ * @property dashArray   - SVG dash pattern for line marks
+ * @property dots        - Draw point markers on line marks
+ * @property fillOpacity - Fill opacity for area and bar marks
+ * @property radius      - Marker radius for scatter marks
+ */
+export interface ChartSeriesOptions {
+    /** Line/area interpolation. */
+    curve?: SubtypeExprOrValue<ChartCurveType> | ChartCurveLiteral;
+    /** Group id; layers sharing one stack accumulate together. */
+    stackId?: SubtypeExprOrValue<StringType>;
+    /** Stacking offset for the group. */
+    stackOffset?: SubtypeExprOrValue<ChartStackOffsetType> | ChartStackOffsetLiteral;
+    /** Which y-axis the layer scales against. */
+    axis?: SubtypeExprOrValue<YAxisSideType> | YAxisSideLiteral;
+    /** Stroke width for line marks and mark outlines. */
+    strokeWidth?: SubtypeExprOrValue<FloatType>;
+    /** SVG dash pattern for line marks. */
+    dashArray?: SubtypeExprOrValue<StringType>;
+    /** Draw point markers on line marks. */
+    dots?: SubtypeExprOrValue<BooleanType>;
+    /** Fill opacity for area and bar marks. */
+    fillOpacity?: SubtypeExprOrValue<FloatType>;
+    /** Marker radius for scatter marks. */
+    radius?: SubtypeExprOrValue<FloatType>;
+}
+/**
+ * Creates a multi-series `series` node — one `mark` per coloured series in `data`.
+ *
+ * @param data    - The coloured series to draw
+ * @param mark    - The mark drawn per series (`line` / `bar` / `area` / `scatter`)
+ * @param options - Layer styling (see {@link ChartSeriesOptions})
+ * @returns A `series` {@link ChartSpecValue}
+ *
+ * @remarks
+ * A homogeneous layer is one node; a composed chart places several `series`
+ * nodes (with differing marks) in the same frame. Stacking, interpolation and
+ * the y-axis binding ride on the node.
+ */
+export declare function chartSeries(data: SubtypeExprOrValue<ChartSeriesArrayType>, mark: "line" | "bar" | "area" | "scatter", options?: ChartSeriesOptions): ChartSpecValue;
+/**
+ * Creates a filled `bandArea` node — one band per series in `data`.
+ *
+ * @param data    - The coloured band series to draw (low/high per x)
+ * @param options - Edge interpolation and fill opacity
+ * @returns A `bandArea` {@link ChartSpecValue}
+ *
+ * @remarks
+ * The area-range analogue of {@link chartSeries}; backs `Chart.Band`.
+ */
+export declare function chartBandArea(data: SubtypeExprOrValue<ChartBandSeriesArrayType>, options?: {
+    curve?: SubtypeExprOrValue<ChartCurveType> | ChartCurveLiteral;
+    fillOpacity?: SubtypeExprOrValue<FloatType>;
 }): ChartSpecValue;
-/** Mono y axis (linear scale). */
-export declare function chartAxisLeft(options?: {
-    label?: string;
-    numTicks?: number;
+/** Options shared by {@link chartAxisBottom} / {@link chartAxisLeft} / {@link chartAxisRight}. */
+export interface AxisNodeOptions {
+    /** Optional axis caption. */
+    label?: SubtypeExprOrValue<StringType>;
+    /** Suggested tick count (a hint; the scale chooses nice ticks). */
+    numTicks?: SubtypeExprOrValue<FloatType>;
+    /** Explicit `[min, max]` domain for a linear/time axis (see {@link ChartDomainType}). */
+    domain?: SubtypeExprOrValue<ChartDomainType>;
+    /** Tick-label format (see {@link ChartTickFormatType}). */
+    tickFormat?: SubtypeExprOrValue<ChartTickFormatType>;
+}
+/**
+ * Creates the x (bottom) axis from the frame's x scale.
+ *
+ * @param options - Caption, tick count hint, explicit domain, and tick format
+ * @returns An `axisBottom` {@link ChartSpecValue}
+ *
+ * @remarks
+ * The renderer derives ticks from the scale's domain, so a `time` axis chooses
+ * range-appropriate ticks itself; `numTicks` is only a hint and `domain` an
+ * optional override.
+ */
+export declare function chartAxisBottom(options?: AxisNodeOptions): ChartSpecValue;
+/**
+ * Creates the primary (left) y axis from the frame's y scale.
+ *
+ * @param options - Caption, tick count hint, explicit domain, and tick format
+ * @returns An `axisLeft` {@link ChartSpecValue}
+ */
+export declare function chartAxisLeft(options?: AxisNodeOptions): ChartSpecValue;
+/**
+ * Creates the secondary (right) y axis for a dual-axis chart.
+ *
+ * @param options - Caption, tick count hint, explicit domain, and tick format
+ * @returns An `axisRight` {@link ChartSpecValue}
+ *
+ * @remarks
+ * Pair with `frame.yScale2` and series bound via `axis: "right"`.
+ */
+export declare function chartAxisRight(options?: AxisNodeOptions): ChartSpecValue;
+/**
+ * Creates a reference-dot node — a highlighted marker at a data coordinate.
+ *
+ * @param options - The `x` ({@link ChartXType}) / `y` coordinate and marker styling
+ * @returns A `referenceDot` {@link ChartSpecValue}
+ */
+export declare function chartReferenceDot(options: {
+    x: SubtypeExprOrValue<ChartXType>;
+    y: SubtypeExprOrValue<FloatType>;
+    fill?: SubtypeExprOrValue<StringType>;
+    radius?: SubtypeExprOrValue<FloatType>;
+    stroke?: SubtypeExprOrValue<StringType>;
+    strokeWidth?: SubtypeExprOrValue<FloatType>;
+    label?: SubtypeExprOrValue<StringType>;
+}): ChartSpecValue;
+/**
+ * Creates a reference-area node — a shaded region spanning a range on one or both axes.
+ *
+ * @param options - Optional `x1`/`x2` ({@link ChartXType}) and `y1`/`y2` bounds, plus styling
+ * @returns A `referenceArea` {@link ChartSpecValue}
+ *
+ * @remarks
+ * A bound left unset extends to the plot edge.
+ */
+export declare function chartReferenceArea(options: {
+    x1?: SubtypeExprOrValue<ChartXType>;
+    x2?: SubtypeExprOrValue<ChartXType>;
+    y1?: SubtypeExprOrValue<FloatType>;
+    y2?: SubtypeExprOrValue<FloatType>;
+    fill?: SubtypeExprOrValue<StringType>;
+    fillOpacity?: SubtypeExprOrValue<FloatType>;
+    stroke?: SubtypeExprOrValue<StringType>;
+    label?: SubtypeExprOrValue<StringType>;
 }): ChartSpecValue;
-/** Horizontal paper gridlines at the y ticks. */
+/**
+ * Creates horizontal gridlines at the y ticks.
+ *
+ * @param options - Suggested gridline count and dash pattern
+ * @returns A `gridRows` {@link ChartSpecValue}
+ */
 export declare function chartGridRows(options?: {
     numTicks?: number;
     dashArray?: string;
 }): ChartSpecValue;
-/** Vertical paper gridlines at the x band positions. */
+/**
+ * Creates vertical gridlines at the x positions.
+ *
+ * @param options - Suggested gridline count and dash pattern
+ * @returns A `gridColumns` {@link ChartSpecValue}
+ */
 export declare function chartGridColumns(options?: {
     numTicks?: number;
     dashArray?: string;
 }): ChartSpecValue;
 /**
- * `Chart.Spec` — the recursive visx-primitive chart layer. Assemble a chart
- * from `frame` / `series` / `axisBottom` / `axisLeft` / `gridRows` (and the
- * leaf marks via `Types`); the renderer derives scales from the data. All East
- * types live under `Chart.Spec.Types.*`.
+ * `Chart.Spec` — the recursive visx-primitive chart layer, and the escape hatch
+ * beneath the high-level `Chart.*` builders.
+ *
+ * @remarks
+ * Assemble a chart by nesting node constructors inside a `frame`
+ * (`series` / `bandArea` / `axisBottom` / `axisLeft` / `gridRows` / annotations);
+ * the renderer derives each scale's domain from the descendant points, so the
+ * scale kind follows the data's {@link ChartXType} coordinate. Every East type is
+ * reachable via `Chart.Spec.Types.*`.
  */
 export declare const ChartSpec: {
-    /** A sized plotting frame owning the x/y scale kinds + child marks. */
+    /**
+     * Creates the sized plotting frame — the root of a chart tree.
+     *
+     * @param children - The marks / axes / grids drawn inside the frame
+     * @param options  - Sizing, scale kinds, and tooltip / legend toggles (see {@link ChartFrameOptions})
+     * @returns A `frame` {@link ChartSpecValue}
+     *
+     * @remarks
+     * Owns the x/y scale kinds and child nodes; the renderer derives each scale's
+     * domain from the descendant points. A secondary `yScale2` enables a right
+     * axis that series bound with `axis: "right"` scale against.
+     *
+     * @example
+     * ```ts
+     * import { East, variant } from "@elaraai/east";
+     * import { Chart, UIComponentType } from "@elaraai/east-ui";
+     *
+     * const example = East.function([], UIComponentType, (_$) =>
+     *     East.value(variant("VisxChart", Chart.Spec.frame([
+     *         Chart.Spec.series(
+     *             [{ key: "Sales", color: "teal.solid", points: [{ x: variant("category", "Jan"), value: 10 }] }],
+     *             "line",
+     *         ),
+     *         Chart.Spec.axisBottom(),
+     *         Chart.Spec.axisLeft(),
+     *     ], { height: 240 })), UIComponentType));
+     * ```
+     */
     readonly frame: typeof chartFrame;
-    /** Multi-series marks (one mark per coloured series). */
+    /**
+     * Creates a multi-series mark layer — one `mark` per coloured series in `data`.
+     *
+     * @param data    - The coloured series to draw
+     * @param mark    - The mark drawn per series (`line` / `bar` / `area` / `scatter`)
+     * @param options - Layer styling (see {@link ChartSeriesOptions})
+     * @returns A `series` {@link ChartSpecValue}
+     *
+     * @remarks
+     * A homogeneous layer is one node; a composed chart places several `series`
+     * nodes with differing marks in the same frame.
+     *
+     * @example
+     * ```ts
+     * import { East, variant } from "@elaraai/east";
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const layer = Chart.Spec.series(
+     *     [
+     *         { key: "iOS",     color: "purple.solid", points: [{ x: variant("category", "Jan"), value: 12 }] },
+     *         { key: "Android", color: "blue.solid",   points: [{ x: variant("category", "Jan"), value: 9 }] },
+     *     ],
+     *     "bar",
+     *     { stackId: "platform" },
+     * );
+     * ```
+     */
     readonly series: typeof chartSeries;
-    /** Mono-uppercase x axis. */
+    /**
+     * Creates a filled band (area-range) layer — one band per series in `data`.
+     *
+     * @param data    - The coloured band series to draw (low/high per x)
+     * @param options - Edge interpolation and fill opacity
+     * @returns A `bandArea` {@link ChartSpecValue}
+     *
+     * @remarks
+     * The area-range analogue of {@link ChartSpec.series}; backs `Chart.Band`.
+     *
+     * @example
+     * ```ts
+     * import { variant } from "@elaraai/east";
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const band = Chart.Spec.bandArea(
+     *     [{ key: "Confidence", color: "blue.200", points: [{ x: variant("category", "Mon"), low: 80, high: 120 }] }],
+     *     { fillOpacity: 0.3 },
+     * );
+     * ```
+     */
+    readonly bandArea: typeof chartBandArea;
+    /**
+     * Creates the x (bottom) axis from the frame's x scale.
+     *
+     * @param options - Caption, tick count hint, and explicit domain (see {@link ChartDomainType})
+     * @returns An `axisBottom` {@link ChartSpecValue}
+     *
+     * @remarks
+     * The renderer derives ticks from the scale's domain, so a `time` axis picks
+     * range-appropriate ticks itself; `numTicks` is only a hint.
+     *
+     * @example
+     * ```ts
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const axis = Chart.Spec.axisBottom({ label: "Month" });
+     * ```
+     */
     readonly axisBottom: typeof chartAxisBottom;
-    /** Mono y axis. */
+    /**
+     * Creates the primary (left) y axis from the frame's y scale.
+     *
+     * @param options - Caption, tick count hint, and explicit domain (see {@link ChartDomainType})
+     * @returns An `axisLeft` {@link ChartSpecValue}
+     *
+     * @example
+     * ```ts
+     * import { variant } from "@elaraai/east";
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const axis = Chart.Spec.axisLeft({ label: "Revenue", domain: variant("number", { min: 0, max: 100 }) });
+     * ```
+     */
     readonly axisLeft: typeof chartAxisLeft;
-    /** Horizontal paper gridlines. */
+    /**
+     * Creates the secondary (right) y axis for a dual-axis chart.
+     *
+     * @param options - Caption, tick count hint, and explicit domain (see {@link ChartDomainType})
+     * @returns An `axisRight` {@link ChartSpecValue}
+     *
+     * @remarks
+     * Pair with `frame.yScale2` and series bound via `axis: "right"`.
+     *
+     * @example
+     * ```ts
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const axis = Chart.Spec.axisRight({ label: "Trend" });
+     * ```
+     */
+    readonly axisRight: typeof chartAxisRight;
+    /**
+     * Creates horizontal gridlines at the y ticks.
+     *
+     * @param options - Suggested gridline count and dash pattern
+     * @returns A `gridRows` {@link ChartSpecValue}
+     *
+     * @example
+     * ```ts
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const grid = Chart.Spec.gridRows({ dashArray: "2 4" });
+     * ```
+     */
     readonly gridRows: typeof chartGridRows;
-    /** Vertical paper gridlines. */
+    /**
+     * Creates vertical gridlines at the x positions.
+     *
+     * @param options - Suggested gridline count and dash pattern
+     * @returns A `gridColumns` {@link ChartSpecValue}
+     *
+     * @example
+     * ```ts
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const grid = Chart.Spec.gridColumns({ dashArray: "2 4" });
+     * ```
+     */
     readonly gridColumns: typeof chartGridColumns;
+    /**
+     * Creates a reference-dot annotation — a highlighted marker at a data coordinate.
+     *
+     * @param options - The `x` ({@link ChartXType}) / `y` coordinate and marker styling
+     * @returns A `referenceDot` {@link ChartSpecValue}
+     *
+     * @example
+     * ```ts
+     * import { variant } from "@elaraai/east";
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const dot = Chart.Spec.referenceDot({ x: variant("category", "Mar"), y: 237, label: "Peak" });
+     * ```
+     */
+    readonly referenceDot: typeof chartReferenceDot;
+    /**
+     * Creates a reference-area annotation — a shaded region spanning a range.
+     *
+     * @param options - Optional `x1`/`x2` ({@link ChartXType}) and `y1`/`y2` bounds, plus styling
+     * @returns A `referenceArea` {@link ChartSpecValue}
+     *
+     * @remarks
+     * A bound left unset extends to the plot edge.
+     *
+     * @example
+     * ```ts
+     * import { Chart } from "@elaraai/east-ui";
+     *
+     * const zone = Chart.Spec.referenceArea({ y1: 80, y2: 120, label: "Normal" });
+     * ```
+     */
+    readonly referenceArea: typeof chartReferenceArea;
     readonly Types: {
-        /** The recursive ChartSpec IR. */
+        /**
+         * The recursive visx-primitive chart IR.
+         *
+         * @remarks
+         * A chart value is a tree of these variant nodes; see {@link ChartSpecType}.
+         * The single arm everything funnels into is `UIComponentType.VisxChart`.
+         *
+         * @property frame         - Sized plotting frame; owns scales, tooltip / legend, children
+         * @property group         - A translated container of children
+         * @property linePath      - A polyline mark
+         * @property area          - A filled-area mark
+         * @property bandArea      - A filled band (area-range) layer
+         * @property bars          - Vertical bars
+         * @property points        - Point markers
+         * @property rule          - A reference line at a data coordinate
+         * @property referenceDot  - A highlighted marker at a data coordinate
+         * @property referenceArea - A shaded region on one or both axes
+         * @property text          - A free SVG text label
+         * @property axisBottom    - X axis
+         * @property axisLeft      - Primary y axis
+         * @property axisRight     - Secondary y axis (dual-axis)
+         * @property gridRows      - Horizontal gridlines
+         * @property gridColumns   - Vertical gridlines
+         * @property series        - Multi-series mark layer
+         */
         readonly Spec: RecursiveType<VariantType<{
             readonly frame: StructType<{
                 readonly height: FloatType;
@@ -251,6 +1363,561 @@ export declare const ChartSpec: {
                     readonly linear: import("@elaraai/east").NullType;
                     readonly time: import("@elaraai/east").NullType;
                 }>;
+                readonly yScale2: OptionType<VariantType<{
+                    readonly band: import("@elaraai/east").NullType;
+                    readonly linear: import("@elaraai/east").NullType;
+                    readonly time: import("@elaraai/east").NullType;
+                }>>;
+                readonly tooltip: OptionType<StructType<{
+                    readonly cursor: OptionType<VariantType<{
+                        readonly none: import("@elaraai/east").NullType;
+                        readonly line: import("@elaraai/east").NullType;
+                        readonly fill: import("@elaraai/east").NullType;
+                    }>>;
+                }>>;
+                readonly legend: OptionType<StructType<{
+                    readonly orientation: OptionType<VariantType<{
+                        readonly horizontal: import("@elaraai/east").NullType;
+                        readonly vertical: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly position: OptionType<VariantType<{
+                        readonly top: import("@elaraai/east").NullType;
+                        readonly bottom: import("@elaraai/east").NullType;
+                        readonly left: import("@elaraai/east").NullType;
+                        readonly right: import("@elaraai/east").NullType;
+                    }>>;
+                }>>;
+                readonly slice: OptionType<StructType<{
+                    readonly slice: StructType<{
+                        readonly key: StringType;
+                        readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                            readonly range: OptionType<VariantType<{
+                                readonly datetime: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                                readonly datetimePreset: VariantType<{
+                                    readonly today: import("@elaraai/east").NullType;
+                                    readonly last7d: import("@elaraai/east").NullType;
+                                    readonly last30d: import("@elaraai/east").NullType;
+                                    readonly last90d: import("@elaraai/east").NullType;
+                                    readonly ytd: import("@elaraai/east").NullType;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly from: import("@elaraai/east").IntegerType;
+                                    readonly to: import("@elaraai/east").IntegerType;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly from: FloatType;
+                                    readonly to: FloatType;
+                                }>;
+                            }>>;
+                            readonly compare: OptionType<VariantType<{
+                                readonly previousPeriod: import("@elaraai/east").NullType;
+                                readonly previousYear: import("@elaraai/east").NullType;
+                            }>>;
+                            readonly filters: ArrayType<VariantType<{
+                                readonly string: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: StringType;
+                                        readonly neq: StringType;
+                                        readonly in: import("@elaraai/east").SetType<StringType>;
+                                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                        readonly contains: StringType;
+                                        readonly matches: StringType;
+                                    }>;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: import("@elaraai/east").IntegerType;
+                                        readonly neq: import("@elaraai/east").IntegerType;
+                                        readonly lt: import("@elaraai/east").IntegerType;
+                                        readonly lte: import("@elaraai/east").IntegerType;
+                                        readonly gt: import("@elaraai/east").IntegerType;
+                                        readonly gte: import("@elaraai/east").IntegerType;
+                                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                    }>;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly lt: FloatType;
+                                        readonly lte: FloatType;
+                                        readonly gt: FloatType;
+                                        readonly gte: FloatType;
+                                    }>;
+                                }>;
+                                readonly datetime: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly before: import("@elaraai/east").DateTimeType;
+                                        readonly after: import("@elaraai/east").DateTimeType;
+                                        readonly between: StructType<{
+                                            readonly from: import("@elaraai/east").DateTimeType;
+                                            readonly to: import("@elaraai/east").DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                readonly boolean: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly is: BooleanType;
+                                    }>;
+                                }>;
+                            }>>;
+                            readonly cohorts: ArrayType<StructType<{
+                                readonly id: StringType;
+                                readonly name: StringType;
+                                readonly filters: ArrayType<VariantType<{
+                                    readonly string: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly eq: StringType;
+                                            readonly neq: StringType;
+                                            readonly in: import("@elaraai/east").SetType<StringType>;
+                                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                            readonly contains: StringType;
+                                            readonly matches: StringType;
+                                        }>;
+                                    }>;
+                                    readonly integer: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly eq: import("@elaraai/east").IntegerType;
+                                            readonly neq: import("@elaraai/east").IntegerType;
+                                            readonly lt: import("@elaraai/east").IntegerType;
+                                            readonly lte: import("@elaraai/east").IntegerType;
+                                            readonly gt: import("@elaraai/east").IntegerType;
+                                            readonly gte: import("@elaraai/east").IntegerType;
+                                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                        }>;
+                                    }>;
+                                    readonly float: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly lt: FloatType;
+                                            readonly lte: FloatType;
+                                            readonly gt: FloatType;
+                                            readonly gte: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly datetime: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly before: import("@elaraai/east").DateTimeType;
+                                            readonly after: import("@elaraai/east").DateTimeType;
+                                            readonly between: StructType<{
+                                                readonly from: import("@elaraai/east").DateTimeType;
+                                                readonly to: import("@elaraai/east").DateTimeType;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly boolean: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly is: BooleanType;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>>;
+                            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                            readonly breakdown: OptionType<StructType<{
+                                readonly fieldId: StringType;
+                                readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                            }>>;
+                            readonly search: OptionType<StringType>;
+                            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                            readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                        }>>;
+                        readonly write: import("@elaraai/east").FunctionType<[StructType<{
+                            readonly range: OptionType<VariantType<{
+                                readonly datetime: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                                readonly datetimePreset: VariantType<{
+                                    readonly today: import("@elaraai/east").NullType;
+                                    readonly last7d: import("@elaraai/east").NullType;
+                                    readonly last30d: import("@elaraai/east").NullType;
+                                    readonly last90d: import("@elaraai/east").NullType;
+                                    readonly ytd: import("@elaraai/east").NullType;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly from: import("@elaraai/east").IntegerType;
+                                    readonly to: import("@elaraai/east").IntegerType;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly from: FloatType;
+                                    readonly to: FloatType;
+                                }>;
+                            }>>;
+                            readonly compare: OptionType<VariantType<{
+                                readonly previousPeriod: import("@elaraai/east").NullType;
+                                readonly previousYear: import("@elaraai/east").NullType;
+                            }>>;
+                            readonly filters: ArrayType<VariantType<{
+                                readonly string: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: StringType;
+                                        readonly neq: StringType;
+                                        readonly in: import("@elaraai/east").SetType<StringType>;
+                                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                        readonly contains: StringType;
+                                        readonly matches: StringType;
+                                    }>;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: import("@elaraai/east").IntegerType;
+                                        readonly neq: import("@elaraai/east").IntegerType;
+                                        readonly lt: import("@elaraai/east").IntegerType;
+                                        readonly lte: import("@elaraai/east").IntegerType;
+                                        readonly gt: import("@elaraai/east").IntegerType;
+                                        readonly gte: import("@elaraai/east").IntegerType;
+                                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                    }>;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly lt: FloatType;
+                                        readonly lte: FloatType;
+                                        readonly gt: FloatType;
+                                        readonly gte: FloatType;
+                                    }>;
+                                }>;
+                                readonly datetime: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly before: import("@elaraai/east").DateTimeType;
+                                        readonly after: import("@elaraai/east").DateTimeType;
+                                        readonly between: StructType<{
+                                            readonly from: import("@elaraai/east").DateTimeType;
+                                            readonly to: import("@elaraai/east").DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                readonly boolean: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly is: BooleanType;
+                                    }>;
+                                }>;
+                            }>>;
+                            readonly cohorts: ArrayType<StructType<{
+                                readonly id: StringType;
+                                readonly name: StringType;
+                                readonly filters: ArrayType<VariantType<{
+                                    readonly string: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly eq: StringType;
+                                            readonly neq: StringType;
+                                            readonly in: import("@elaraai/east").SetType<StringType>;
+                                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                            readonly contains: StringType;
+                                            readonly matches: StringType;
+                                        }>;
+                                    }>;
+                                    readonly integer: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly eq: import("@elaraai/east").IntegerType;
+                                            readonly neq: import("@elaraai/east").IntegerType;
+                                            readonly lt: import("@elaraai/east").IntegerType;
+                                            readonly lte: import("@elaraai/east").IntegerType;
+                                            readonly gt: import("@elaraai/east").IntegerType;
+                                            readonly gte: import("@elaraai/east").IntegerType;
+                                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                        }>;
+                                    }>;
+                                    readonly float: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly lt: FloatType;
+                                            readonly lte: FloatType;
+                                            readonly gt: FloatType;
+                                            readonly gte: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly datetime: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly before: import("@elaraai/east").DateTimeType;
+                                            readonly after: import("@elaraai/east").DateTimeType;
+                                            readonly between: StructType<{
+                                                readonly from: import("@elaraai/east").DateTimeType;
+                                                readonly to: import("@elaraai/east").DateTimeType;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly boolean: StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: VariantType<{
+                                            readonly is: BooleanType;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>>;
+                            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                            readonly breakdown: OptionType<StructType<{
+                                readonly fieldId: StringType;
+                                readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                            }>>;
+                            readonly search: OptionType<StringType>;
+                            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                            readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                        }>], import("@elaraai/east").NullType>;
+                        readonly setRange: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                            readonly datetime: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                            readonly datetimePreset: VariantType<{
+                                readonly today: import("@elaraai/east").NullType;
+                                readonly last7d: import("@elaraai/east").NullType;
+                                readonly last30d: import("@elaraai/east").NullType;
+                                readonly last90d: import("@elaraai/east").NullType;
+                                readonly ytd: import("@elaraai/east").NullType;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly from: import("@elaraai/east").IntegerType;
+                                readonly to: import("@elaraai/east").IntegerType;
+                            }>;
+                            readonly float: StructType<{
+                                readonly from: FloatType;
+                                readonly to: FloatType;
+                            }>;
+                        }>>], import("@elaraai/east").NullType>;
+                        readonly setCompare: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                            readonly previousPeriod: import("@elaraai/east").NullType;
+                            readonly previousYear: import("@elaraai/east").NullType;
+                        }>>], import("@elaraai/east").NullType>;
+                        readonly addFilter: import("@elaraai/east").FunctionType<[VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: import("@elaraai/east").IntegerType;
+                                    readonly neq: import("@elaraai/east").IntegerType;
+                                    readonly lt: import("@elaraai/east").IntegerType;
+                                    readonly lte: import("@elaraai/east").IntegerType;
+                                    readonly gt: import("@elaraai/east").IntegerType;
+                                    readonly gte: import("@elaraai/east").IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly before: import("@elaraai/east").DateTimeType;
+                                    readonly after: import("@elaraai/east").DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: import("@elaraai/east").DateTimeType;
+                                        readonly to: import("@elaraai/east").DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>], import("@elaraai/east").NullType>;
+                        readonly removeFilter: import("@elaraai/east").FunctionType<[import("@elaraai/east").IntegerType], import("@elaraai/east").NullType>;
+                        readonly clearFilters: import("@elaraai/east").FunctionType<[], import("@elaraai/east").NullType>;
+                        readonly defineCohort: import("@elaraai/east").FunctionType<[StructType<{
+                            readonly id: StringType;
+                            readonly name: StringType;
+                            readonly filters: ArrayType<VariantType<{
+                                readonly string: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: StringType;
+                                        readonly neq: StringType;
+                                        readonly in: import("@elaraai/east").SetType<StringType>;
+                                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                        readonly contains: StringType;
+                                        readonly matches: StringType;
+                                    }>;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: import("@elaraai/east").IntegerType;
+                                        readonly neq: import("@elaraai/east").IntegerType;
+                                        readonly lt: import("@elaraai/east").IntegerType;
+                                        readonly lte: import("@elaraai/east").IntegerType;
+                                        readonly gt: import("@elaraai/east").IntegerType;
+                                        readonly gte: import("@elaraai/east").IntegerType;
+                                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                    }>;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly lt: FloatType;
+                                        readonly lte: FloatType;
+                                        readonly gt: FloatType;
+                                        readonly gte: FloatType;
+                                    }>;
+                                }>;
+                                readonly datetime: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly before: import("@elaraai/east").DateTimeType;
+                                        readonly after: import("@elaraai/east").DateTimeType;
+                                        readonly between: StructType<{
+                                            readonly from: import("@elaraai/east").DateTimeType;
+                                            readonly to: import("@elaraai/east").DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                readonly boolean: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly is: BooleanType;
+                                    }>;
+                                }>;
+                            }>>;
+                        }>], import("@elaraai/east").NullType>;
+                        readonly updateCohort: import("@elaraai/east").FunctionType<[StringType, StructType<{
+                            readonly id: StringType;
+                            readonly name: StringType;
+                            readonly filters: ArrayType<VariantType<{
+                                readonly string: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: StringType;
+                                        readonly neq: StringType;
+                                        readonly in: import("@elaraai/east").SetType<StringType>;
+                                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                        readonly contains: StringType;
+                                        readonly matches: StringType;
+                                    }>;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly eq: import("@elaraai/east").IntegerType;
+                                        readonly neq: import("@elaraai/east").IntegerType;
+                                        readonly lt: import("@elaraai/east").IntegerType;
+                                        readonly lte: import("@elaraai/east").IntegerType;
+                                        readonly gt: import("@elaraai/east").IntegerType;
+                                        readonly gte: import("@elaraai/east").IntegerType;
+                                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                    }>;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly lt: FloatType;
+                                        readonly lte: FloatType;
+                                        readonly gt: FloatType;
+                                        readonly gte: FloatType;
+                                    }>;
+                                }>;
+                                readonly datetime: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly before: import("@elaraai/east").DateTimeType;
+                                        readonly after: import("@elaraai/east").DateTimeType;
+                                        readonly between: StructType<{
+                                            readonly from: import("@elaraai/east").DateTimeType;
+                                            readonly to: import("@elaraai/east").DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                readonly boolean: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: VariantType<{
+                                        readonly is: BooleanType;
+                                    }>;
+                                }>;
+                            }>>;
+                        }>], import("@elaraai/east").NullType>;
+                        readonly removeCohort: import("@elaraai/east").FunctionType<[StringType], import("@elaraai/east").NullType>;
+                        readonly toggleCohort: import("@elaraai/east").FunctionType<[StringType], import("@elaraai/east").NullType>;
+                        readonly setBreakdown: import("@elaraai/east").FunctionType<[OptionType<StructType<{
+                            readonly fieldId: StringType;
+                            readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                        }>>], import("@elaraai/east").NullType>;
+                        readonly setSearch: import("@elaraai/east").FunctionType<[OptionType<StringType>], import("@elaraai/east").NullType>;
+                        readonly setVisible: import("@elaraai/east").FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], import("@elaraai/east").NullType>;
+                        readonly select: import("@elaraai/east").FunctionType<[OptionType<import("@elaraai/east").IntegerType>], import("@elaraai/east").NullType>;
+                        readonly isActive: import("@elaraai/east").FunctionType<[], BooleanType>;
+                        readonly activeCount: import("@elaraai/east").FunctionType<[], import("@elaraai/east").IntegerType>;
+                        readonly dimensions: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                            readonly fieldId: StringType;
+                            readonly label: StringType;
+                        }>>>;
+                        readonly fields: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                            readonly fieldId: StringType;
+                            readonly label: StringType;
+                            readonly kind: StringType;
+                        }>>>;
+                        readonly searchFieldIds: import("@elaraai/east").FunctionType<[], ArrayType<StringType>>;
+                        readonly rangeFieldId: import("@elaraai/east").FunctionType<[], OptionType<StringType>>;
+                        readonly totalCount: import("@elaraai/east").FunctionType<[], import("@elaraai/east").IntegerType>;
+                        readonly resultCount: import("@elaraai/east").FunctionType<[], import("@elaraai/east").IntegerType>;
+                        readonly groups: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly count: import("@elaraai/east").IntegerType;
+                            readonly color: StringType;
+                        }>>>;
+                        readonly series: import("@elaraai/east").FunctionType<[StringType, StringType], ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly color: StringType;
+                            readonly points: ArrayType<StructType<{
+                                readonly x: VariantType<{
+                                    readonly category: StringType;
+                                    readonly number: FloatType;
+                                    readonly time: import("@elaraai/east").DateTimeType;
+                                }>;
+                                readonly value: FloatType;
+                                readonly size: OptionType<FloatType>;
+                            }>>;
+                        }>>>;
+                        readonly matches: import("@elaraai/east").FunctionType<[], ArrayType<StructType<{
+                            readonly id: StringType;
+                            readonly label: StringType;
+                            readonly meta: OptionType<StringType>;
+                        }>>>;
+                        readonly cohortCounts: import("@elaraai/east").FunctionType<[], import("@elaraai/east").DictType<StringType, import("@elaraai/east").IntegerType>>;
+                    }>;
+                    readonly affordances: ArrayType<VariantType<{
+                        readonly filter: import("@elaraai/east").NullType;
+                        readonly search: import("@elaraai/east").NullType;
+                        readonly breakdown: import("@elaraai/east").NullType;
+                        readonly range: import("@elaraai/east").NullType;
+                        readonly cohort: import("@elaraai/east").NullType;
+                        readonly brush: import("@elaraai/east").NullType;
+                    }>>;
+                }>>;
                 readonly children: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
             }>;
             readonly group: StructType<{
@@ -260,10 +1927,15 @@ export declare const ChartSpec: {
             }>;
             readonly linePath: StructType<{
                 readonly points: ArrayType<StructType<{
-                    readonly x: import("@elaraai/east").StringType;
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
                     readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
                 }>>;
-                readonly stroke: import("@elaraai/east").StringType;
+                readonly stroke: StringType;
                 readonly strokeWidth: OptionType<FloatType>;
                 readonly curve: OptionType<VariantType<{
                     readonly monotoneX: import("@elaraai/east").NullType;
@@ -271,17 +1943,22 @@ export declare const ChartSpec: {
                     readonly natural: import("@elaraai/east").NullType;
                     readonly step: import("@elaraai/east").NullType;
                 }>>;
-                readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+                readonly dashArray: OptionType<StringType>;
                 readonly opacity: OptionType<FloatType>;
             }>;
             readonly area: StructType<{
                 readonly points: ArrayType<StructType<{
-                    readonly x: import("@elaraai/east").StringType;
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
                     readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
                 }>>;
-                readonly fill: import("@elaraai/east").StringType;
+                readonly fill: StringType;
                 readonly fillOpacity: OptionType<FloatType>;
-                readonly stroke: OptionType<import("@elaraai/east").StringType>;
+                readonly stroke: OptionType<StringType>;
                 readonly strokeWidth: OptionType<FloatType>;
                 readonly curve: OptionType<VariantType<{
                     readonly monotoneX: import("@elaraai/east").NullType;
@@ -290,23 +1967,55 @@ export declare const ChartSpec: {
                     readonly step: import("@elaraai/east").NullType;
                 }>>;
             }>;
+            readonly bandArea: StructType<{
+                readonly data: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly color: StringType;
+                    readonly points: ArrayType<StructType<{
+                        readonly x: VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: import("@elaraai/east").DateTimeType;
+                        }>;
+                        readonly low: FloatType;
+                        readonly high: FloatType;
+                    }>>;
+                }>>;
+                readonly curve: OptionType<VariantType<{
+                    readonly monotoneX: import("@elaraai/east").NullType;
+                    readonly linear: import("@elaraai/east").NullType;
+                    readonly natural: import("@elaraai/east").NullType;
+                    readonly step: import("@elaraai/east").NullType;
+                }>>;
+                readonly fillOpacity: OptionType<FloatType>;
+            }>;
             readonly bars: StructType<{
                 readonly points: ArrayType<StructType<{
-                    readonly x: import("@elaraai/east").StringType;
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
                     readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
                 }>>;
-                readonly fill: import("@elaraai/east").StringType;
+                readonly fill: StringType;
                 readonly fillOpacity: OptionType<FloatType>;
                 readonly radius: OptionType<FloatType>;
             }>;
             readonly points: StructType<{
                 readonly points: ArrayType<StructType<{
-                    readonly x: import("@elaraai/east").StringType;
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
                     readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
                 }>>;
-                readonly fill: import("@elaraai/east").StringType;
+                readonly fill: StringType;
                 readonly radius: OptionType<FloatType>;
-                readonly stroke: OptionType<import("@elaraai/east").StringType>;
+                readonly stroke: OptionType<StringType>;
                 readonly strokeWidth: OptionType<FloatType>;
             }>;
             readonly rule: StructType<{
@@ -314,52 +2023,165 @@ export declare const ChartSpec: {
                     readonly x: import("@elaraai/east").NullType;
                     readonly y: import("@elaraai/east").NullType;
                 }>;
-                readonly at: import("@elaraai/east").StringType;
-                readonly stroke: import("@elaraai/east").StringType;
-                readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+                readonly at: StringType;
+                readonly stroke: StringType;
+                readonly dashArray: OptionType<StringType>;
+            }>;
+            readonly referenceDot: StructType<{
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly y: FloatType;
+                readonly fill: OptionType<StringType>;
+                readonly radius: OptionType<FloatType>;
+                readonly stroke: OptionType<StringType>;
+                readonly strokeWidth: OptionType<FloatType>;
+                readonly label: OptionType<StringType>;
+            }>;
+            readonly referenceArea: StructType<{
+                readonly x1: OptionType<VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>>;
+                readonly x2: OptionType<VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>>;
+                readonly y1: OptionType<FloatType>;
+                readonly y2: OptionType<FloatType>;
+                readonly fill: OptionType<StringType>;
+                readonly fillOpacity: OptionType<FloatType>;
+                readonly stroke: OptionType<StringType>;
+                readonly label: OptionType<StringType>;
             }>;
             readonly text: StructType<{
                 readonly point: StructType<{
-                    readonly x: import("@elaraai/east").StringType;
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
                     readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
                 }>;
-                readonly text: import("@elaraai/east").StringType;
+                readonly text: StringType;
                 readonly anchor: OptionType<VariantType<{
                     readonly start: import("@elaraai/east").NullType;
                     readonly middle: import("@elaraai/east").NullType;
                     readonly end: import("@elaraai/east").NullType;
                 }>>;
-                readonly fill: OptionType<import("@elaraai/east").StringType>;
+                readonly fill: OptionType<StringType>;
                 readonly fontSize: OptionType<FloatType>;
                 readonly fontWeight: OptionType<FloatType>;
             }>;
             readonly axisBottom: StructType<{
-                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly label: OptionType<StringType>;
                 readonly numTicks: OptionType<FloatType>;
-                readonly hideTicks: OptionType<import("@elaraai/east").BooleanType>;
-                readonly hideLine: OptionType<import("@elaraai/east").BooleanType>;
+                readonly hideTicks: OptionType<BooleanType>;
+                readonly hideLine: OptionType<BooleanType>;
+                readonly domain: OptionType<VariantType<{
+                    readonly number: StructType<{
+                        readonly min: FloatType;
+                        readonly max: FloatType;
+                    }>;
+                    readonly time: StructType<{
+                        readonly min: import("@elaraai/east").DateTimeType;
+                        readonly max: import("@elaraai/east").DateTimeType;
+                    }>;
+                }>>;
+                readonly tickFormat: OptionType<VariantType<{
+                    readonly number: import("@elaraai/east").NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: import("@elaraai/east").NullType;
+                    readonly compact: import("@elaraai/east").NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
             }>;
             readonly axisLeft: StructType<{
-                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly label: OptionType<StringType>;
+                readonly numTicks: OptionType<FloatType>;
+                readonly hideTicks: OptionType<BooleanType>;
+                readonly hideLine: OptionType<BooleanType>;
+                readonly domain: OptionType<VariantType<{
+                    readonly number: StructType<{
+                        readonly min: FloatType;
+                        readonly max: FloatType;
+                    }>;
+                    readonly time: StructType<{
+                        readonly min: import("@elaraai/east").DateTimeType;
+                        readonly max: import("@elaraai/east").DateTimeType;
+                    }>;
+                }>>;
+                readonly tickFormat: OptionType<VariantType<{
+                    readonly number: import("@elaraai/east").NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: import("@elaraai/east").NullType;
+                    readonly compact: import("@elaraai/east").NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+            }>;
+            readonly axisRight: StructType<{
+                readonly label: OptionType<StringType>;
                 readonly numTicks: OptionType<FloatType>;
-                readonly hideTicks: OptionType<import("@elaraai/east").BooleanType>;
-                readonly hideLine: OptionType<import("@elaraai/east").BooleanType>;
+                readonly hideTicks: OptionType<BooleanType>;
+                readonly hideLine: OptionType<BooleanType>;
+                readonly domain: OptionType<VariantType<{
+                    readonly number: StructType<{
+                        readonly min: FloatType;
+                        readonly max: FloatType;
+                    }>;
+                    readonly time: StructType<{
+                        readonly min: import("@elaraai/east").DateTimeType;
+                        readonly max: import("@elaraai/east").DateTimeType;
+                    }>;
+                }>>;
+                readonly tickFormat: OptionType<VariantType<{
+                    readonly number: import("@elaraai/east").NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: import("@elaraai/east").NullType;
+                    readonly compact: import("@elaraai/east").NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
             }>;
             readonly gridRows: StructType<{
                 readonly numTicks: OptionType<FloatType>;
-                readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+                readonly dashArray: OptionType<StringType>;
             }>;
             readonly gridColumns: StructType<{
                 readonly numTicks: OptionType<FloatType>;
-                readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+                readonly dashArray: OptionType<StringType>;
             }>;
             readonly series: StructType<{
                 readonly data: ArrayType<StructType<{
-                    readonly key: import("@elaraai/east").StringType;
-                    readonly color: import("@elaraai/east").StringType;
+                    readonly key: StringType;
+                    readonly color: StringType;
                     readonly points: ArrayType<StructType<{
-                        readonly x: import("@elaraai/east").StringType;
+                        readonly x: VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: import("@elaraai/east").DateTimeType;
+                        }>;
                         readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
                     }>>;
                 }>>;
                 readonly mark: VariantType<{
@@ -368,83 +2190,394 @@ export declare const ChartSpec: {
                     readonly area: import("@elaraai/east").NullType;
                     readonly scatter: import("@elaraai/east").NullType;
                 }>;
+                readonly curve: OptionType<VariantType<{
+                    readonly monotoneX: import("@elaraai/east").NullType;
+                    readonly linear: import("@elaraai/east").NullType;
+                    readonly natural: import("@elaraai/east").NullType;
+                    readonly step: import("@elaraai/east").NullType;
+                }>>;
+                readonly stackId: OptionType<StringType>;
+                readonly stackOffset: OptionType<VariantType<{
+                    readonly none: import("@elaraai/east").NullType;
+                    readonly expand: import("@elaraai/east").NullType;
+                }>>;
+                readonly axis: OptionType<VariantType<{
+                    readonly left: import("@elaraai/east").NullType;
+                    readonly right: import("@elaraai/east").NullType;
+                }>>;
+                readonly strokeWidth: OptionType<FloatType>;
+                readonly dashArray: OptionType<StringType>;
+                readonly dots: OptionType<BooleanType>;
+                readonly fillOpacity: OptionType<FloatType>;
+                readonly radius: OptionType<FloatType>;
             }>;
         }>>;
-        /** One point `{ x, value }`. */
+        /**
+         * A typed x-axis coordinate; the arm chooses the scale.
+         *
+         * @remarks
+         * Mirror of {@link ChartXType}.
+         *
+         * @property category - Ordinal label (band scale)
+         * @property number   - Continuous numeric position (linear scale)
+         * @property time     - Temporal position (time scale)
+         */
+        readonly XCoord: VariantType<{
+            readonly category: StringType;
+            readonly number: FloatType;
+            readonly time: import("@elaraai/east").DateTimeType;
+        }>;
+        /**
+         * An explicit axis domain, typed to the axis's coordinate kind.
+         *
+         * @remarks
+         * Mirror of {@link ChartDomainType}.
+         *
+         * @property number - Numeric `{ min, max }` for a linear axis
+         * @property time   - Temporal `{ min, max }` for a time axis
+         */
+        readonly Domain: VariantType<{
+            readonly number: StructType<{
+                readonly min: FloatType;
+                readonly max: FloatType;
+            }>;
+            readonly time: StructType<{
+                readonly min: import("@elaraai/east").DateTimeType;
+                readonly max: import("@elaraai/east").DateTimeType;
+            }>;
+        }>;
+        /**
+         * One point along a series.
+         *
+         * @remarks
+         * Mirror of {@link ChartPointType}.
+         *
+         * @property x     - The point's typed x coordinate
+         * @property value - Numeric y value at this point
+         */
         readonly Point: StructType<{
-            readonly x: import("@elaraai/east").StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>;
-        /** One coloured series `{ key, color, points }`. */
+        /**
+         * One coloured series of points.
+         *
+         * @remarks
+         * Mirror of {@link ChartSeriesType}; field-identical to the slice's series
+         * type so the shared pivot feeds it directly.
+         *
+         * @property key    - Series identity (legend label)
+         * @property color  - Series colour (theme token or CSS)
+         * @property points - The series' points in draw order
+         */
         readonly Series: StructType<{
-            readonly key: import("@elaraai/east").StringType;
-            readonly color: import("@elaraai/east").StringType;
+            readonly key: StringType;
+            readonly color: StringType;
             readonly points: ArrayType<StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
         }>;
-        /** Array of series. */
+        /**
+         * An array of {@link ChartSeriesType}.
+         *
+         * @remarks
+         * The shape a layer's pivot produces; mirror of {@link ChartSeriesArrayType}.
+         */
         readonly SeriesArray: ArrayType<StructType<{
-            readonly key: import("@elaraai/east").StringType;
-            readonly color: import("@elaraai/east").StringType;
+            readonly key: StringType;
+            readonly color: StringType;
             readonly points: ArrayType<StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
+            }>>;
+        }>>;
+        /**
+         * One point of a band (area-range) series.
+         *
+         * @remarks
+         * Mirror of {@link ChartBandPointType}.
+         *
+         * @property x    - The point's typed x coordinate
+         * @property low  - Lower bound at this x
+         * @property high - Upper bound at this x
+         */
+        readonly BandPoint: StructType<{
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
+            readonly low: FloatType;
+            readonly high: FloatType;
+        }>;
+        /**
+         * One coloured band series.
+         *
+         * @remarks
+         * Mirror of {@link ChartBandSeriesType}.
+         *
+         * @property key    - Series identity (legend label)
+         * @property color  - Series colour (theme token or CSS)
+         * @property points - The band's points in draw order
+         */
+        readonly BandSeries: StructType<{
+            readonly key: StringType;
+            readonly color: StringType;
+            readonly points: ArrayType<StructType<{
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly low: FloatType;
+                readonly high: FloatType;
+            }>>;
+        }>;
+        /**
+         * An array of {@link ChartBandSeriesType}.
+         *
+         * @remarks
+         * Mirror of {@link ChartBandSeriesArrayType}.
+         */
+        readonly BandSeriesArray: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly color: StringType;
+            readonly points: ArrayType<StructType<{
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly low: FloatType;
+                readonly high: FloatType;
             }>>;
         }>>;
-        /** Axis-scale kind (`band` / `linear` / `time`). */
+        /**
+         * Axis-scale kind.
+         *
+         * @remarks
+         * Mirror of {@link ChartScaleType}; usually derived from the data's coordinate.
+         *
+         * @property band   - Discrete categorical axis
+         * @property linear - Continuous numeric axis
+         * @property time   - Continuous temporal axis
+         */
         readonly Scale: VariantType<{
             readonly band: import("@elaraai/east").NullType;
             readonly linear: import("@elaraai/east").NullType;
             readonly time: import("@elaraai/east").NullType;
         }>;
-        /** Line/area curve interpolation. */
+        /**
+         * Axis tick-label format.
+         *
+         * @remarks
+         * Mirror of {@link ChartTickFormatType}; built with the `Chart.format.*` helpers.
+         *
+         * @property number   - Plain number formatting
+         * @property currency - Currency formatting (`code` + `compact`)
+         * @property percent  - Percentage formatting
+         * @property compact  - Compact magnitude formatting
+         * @property date     - Date pattern
+         * @property time     - Time pattern
+         * @property datetime - Datetime pattern
+         */
+        readonly TickFormat: VariantType<{
+            readonly number: import("@elaraai/east").NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: import("@elaraai/east").NullType;
+            readonly compact: import("@elaraai/east").NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>;
+        /**
+         * Line/area curve interpolation.
+         *
+         * @remarks
+         * Mirror of {@link ChartCurveType}.
+         *
+         * @property monotoneX - Smooth monotone-in-x
+         * @property linear    - Straight segments
+         * @property natural   - Natural cubic spline
+         * @property step      - Step interpolation
+         */
         readonly Curve: VariantType<{
             readonly monotoneX: import("@elaraai/east").NullType;
             readonly linear: import("@elaraai/east").NullType;
             readonly natural: import("@elaraai/east").NullType;
             readonly step: import("@elaraai/east").NullType;
         }>;
-        /** Per-series mark kind (`line` / `bar` / `area`). */
+        /**
+         * Per-layer mark kind.
+         *
+         * @remarks
+         * Mirror of {@link ChartMarkType}.
+         *
+         * @property line    - Polyline
+         * @property bar     - Vertical bars
+         * @property area    - Filled area
+         * @property scatter - Point markers
+         */
         readonly Mark: VariantType<{
             readonly line: import("@elaraai/east").NullType;
             readonly bar: import("@elaraai/east").NullType;
             readonly area: import("@elaraai/east").NullType;
             readonly scatter: import("@elaraai/east").NullType;
         }>;
-        /** SVG text anchor. */
+        /**
+         * Stack accumulation offset for marks sharing a `stackId`.
+         *
+         * @remarks
+         * Mirror of {@link ChartStackOffsetType}.
+         *
+         * @property none   - Raw cumulative stacking
+         * @property expand - Proportional (100%) stacking
+         */
+        readonly StackOffset: VariantType<{
+            readonly none: import("@elaraai/east").NullType;
+            readonly expand: import("@elaraai/east").NullType;
+        }>;
+        /**
+         * Which y-axis a layer scales against.
+         *
+         * @remarks
+         * Mirror of {@link YAxisSideType}.
+         *
+         * @property left  - Primary (left) y-axis
+         * @property right - Secondary (right) y-axis
+         */
+        readonly YAxisSide: VariantType<{
+            readonly left: import("@elaraai/east").NullType;
+            readonly right: import("@elaraai/east").NullType;
+        }>;
+        /**
+         * SVG text anchor.
+         *
+         * @remarks
+         * Mirror of {@link ChartAnchorType}.
+         *
+         * @property start  - Anchor at the start of the text
+         * @property middle - Anchor at the middle
+         * @property end    - Anchor at the end
+         */
         readonly Anchor: VariantType<{
             readonly start: import("@elaraai/east").NullType;
             readonly middle: import("@elaraai/east").NullType;
             readonly end: import("@elaraai/east").NullType;
         }>;
-        /** Frame margins. */
+        /**
+         * Frame margins reserved for axes / labels.
+         *
+         * @remarks
+         * Mirror of {@link ChartMarginType}.
+         *
+         * @property top    - Top margin
+         * @property right  - Right margin
+         * @property bottom - Bottom margin
+         * @property left   - Left margin
+         */
         readonly Margin: StructType<{
             readonly top: FloatType;
             readonly right: FloatType;
             readonly bottom: FloatType;
             readonly left: FloatType;
         }>;
-        /** Axis config. */
+        /**
+         * An axis config.
+         *
+         * @remarks
+         * Mirror of {@link ChartAxisType}; shared by the bottom / left / right axes.
+         *
+         * @property label     - Optional caption
+         * @property numTicks  - Suggested tick count hint
+         * @property hideTicks - Hide the tick marks
+         * @property hideLine  - Hide the baseline rule
+         * @property domain    - Explicit extent for a linear/time axis
+         */
         readonly Axis: StructType<{
-            readonly label: OptionType<import("@elaraai/east").StringType>;
+            readonly label: OptionType<StringType>;
             readonly numTicks: OptionType<FloatType>;
-            readonly hideTicks: OptionType<import("@elaraai/east").BooleanType>;
-            readonly hideLine: OptionType<import("@elaraai/east").BooleanType>;
+            readonly hideTicks: OptionType<BooleanType>;
+            readonly hideLine: OptionType<BooleanType>;
+            readonly domain: OptionType<VariantType<{
+                readonly number: StructType<{
+                    readonly min: FloatType;
+                    readonly max: FloatType;
+                }>;
+                readonly time: StructType<{
+                    readonly min: import("@elaraai/east").DateTimeType;
+                    readonly max: import("@elaraai/east").DateTimeType;
+                }>;
+            }>>;
+            readonly tickFormat: OptionType<VariantType<{
+                readonly number: import("@elaraai/east").NullType;
+                readonly currency: StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: import("@elaraai/east").NullType;
+                readonly compact: import("@elaraai/east").NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>>;
         }>;
-        /** Grid config. */
+        /**
+         * A gridlines config.
+         *
+         * @remarks
+         * Mirror of {@link ChartGridType}.
+         *
+         * @property numTicks  - Suggested gridline count
+         * @property dashArray - SVG dash pattern; solid when omitted
+         */
         readonly Grid: StructType<{
             readonly numTicks: OptionType<FloatType>;
-            readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+            readonly dashArray: OptionType<StringType>;
         }>;
-        /** `LinePath` mark. */
+        /**
+         * A polyline mark.
+         *
+         * @remarks
+         * Mirror of {@link ChartLinePathType}.
+         *
+         * @property points      - The line's points
+         * @property stroke      - Stroke colour
+         * @property strokeWidth - Stroke width
+         * @property curve       - Interpolation
+         * @property dashArray   - SVG dash pattern
+         * @property opacity     - Stroke opacity
+         */
         readonly LinePath: StructType<{
             readonly points: ArrayType<StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
-            readonly stroke: import("@elaraai/east").StringType;
+            readonly stroke: StringType;
             readonly strokeWidth: OptionType<FloatType>;
             readonly curve: OptionType<VariantType<{
                 readonly monotoneX: import("@elaraai/east").NullType;
@@ -452,18 +2585,35 @@ export declare const ChartSpec: {
                 readonly natural: import("@elaraai/east").NullType;
                 readonly step: import("@elaraai/east").NullType;
             }>>;
-            readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+            readonly dashArray: OptionType<StringType>;
             readonly opacity: OptionType<FloatType>;
         }>;
-        /** `AreaClosed` mark. */
+        /**
+         * A filled-area mark.
+         *
+         * @remarks
+         * Mirror of {@link ChartAreaType}.
+         *
+         * @property points      - The area's points
+         * @property fill        - Fill colour
+         * @property fillOpacity - Fill opacity
+         * @property stroke      - Optional top-edge stroke colour
+         * @property strokeWidth - Top-edge stroke width
+         * @property curve       - Interpolation
+         */
         readonly Area: StructType<{
             readonly points: ArrayType<StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
-            readonly fill: import("@elaraai/east").StringType;
+            readonly fill: StringType;
             readonly fillOpacity: OptionType<FloatType>;
-            readonly stroke: OptionType<import("@elaraai/east").StringType>;
+            readonly stroke: OptionType<StringType>;
             readonly strokeWidth: OptionType<FloatType>;
             readonly curve: OptionType<VariantType<{
                 readonly monotoneX: import("@elaraai/east").NullType;
@@ -472,61 +2622,232 @@ export declare const ChartSpec: {
                 readonly step: import("@elaraai/east").NullType;
             }>>;
         }>;
-        /** `Bar`s mark. */
+        /**
+         * A filled band (area-range) layer.
+         *
+         * @remarks
+         * Mirror of {@link ChartBandAreaType}.
+         *
+         * @property data        - The coloured band series
+         * @property curve       - Edge interpolation
+         * @property fillOpacity - Band fill opacity
+         */
+        readonly BandArea: StructType<{
+            readonly data: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<StructType<{
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
+                    readonly low: FloatType;
+                    readonly high: FloatType;
+                }>>;
+            }>>;
+            readonly curve: OptionType<VariantType<{
+                readonly monotoneX: import("@elaraai/east").NullType;
+                readonly linear: import("@elaraai/east").NullType;
+                readonly natural: import("@elaraai/east").NullType;
+                readonly step: import("@elaraai/east").NullType;
+            }>>;
+            readonly fillOpacity: OptionType<FloatType>;
+        }>;
+        /**
+         * A vertical-bars mark.
+         *
+         * @remarks
+         * Mirror of {@link ChartBarsType}.
+         *
+         * @property points      - The bars' points
+         * @property fill        - Bar fill colour
+         * @property fillOpacity - Fill opacity
+         * @property radius      - Corner radius
+         */
         readonly Bars: StructType<{
             readonly points: ArrayType<StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
-            readonly fill: import("@elaraai/east").StringType;
+            readonly fill: StringType;
             readonly fillOpacity: OptionType<FloatType>;
             readonly radius: OptionType<FloatType>;
         }>;
-        /** `Circle` markers. */
+        /**
+         * Point markers.
+         *
+         * @remarks
+         * Mirror of {@link ChartPointsType}.
+         *
+         * @property points      - The points to mark
+         * @property fill        - Marker fill colour
+         * @property radius      - Marker radius
+         * @property stroke      - Optional ring colour
+         * @property strokeWidth - Ring width
+         */
         readonly Points: StructType<{
             readonly points: ArrayType<StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
-            readonly fill: import("@elaraai/east").StringType;
+            readonly fill: StringType;
             readonly radius: OptionType<FloatType>;
-            readonly stroke: OptionType<import("@elaraai/east").StringType>;
+            readonly stroke: OptionType<StringType>;
             readonly strokeWidth: OptionType<FloatType>;
         }>;
-        /** Reference rule. */
+        /**
+         * A reference rule spanning the plot at a data coordinate.
+         *
+         * @remarks
+         * Mirror of {@link ChartRuleType}.
+         *
+         * @property axis      - Which axis `at` is measured on
+         * @property at        - The data coordinate to place the rule at
+         * @property stroke    - Rule colour
+         * @property dashArray - SVG dash pattern
+         */
         readonly Rule: StructType<{
             readonly axis: VariantType<{
                 readonly x: import("@elaraai/east").NullType;
                 readonly y: import("@elaraai/east").NullType;
             }>;
-            readonly at: import("@elaraai/east").StringType;
-            readonly stroke: import("@elaraai/east").StringType;
-            readonly dashArray: OptionType<import("@elaraai/east").StringType>;
+            readonly at: StringType;
+            readonly stroke: StringType;
+            readonly dashArray: OptionType<StringType>;
+        }>;
+        /**
+         * A highlighted reference marker at a data coordinate.
+         *
+         * @remarks
+         * Mirror of {@link ChartReferenceDotType}.
+         *
+         * @property x           - The marker's typed x coordinate
+         * @property y           - Value on the y-axis
+         * @property fill        - Marker fill colour
+         * @property radius      - Marker radius
+         * @property stroke      - Optional ring colour
+         * @property strokeWidth - Ring width
+         * @property label       - Optional caption
+         */
+        readonly ReferenceDot: StructType<{
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>;
+            readonly y: FloatType;
+            readonly fill: OptionType<StringType>;
+            readonly radius: OptionType<FloatType>;
+            readonly stroke: OptionType<StringType>;
+            readonly strokeWidth: OptionType<FloatType>;
+            readonly label: OptionType<StringType>;
+        }>;
+        /**
+         * A shaded reference region spanning a range on one or both axes.
+         *
+         * @remarks
+         * Mirror of {@link ChartReferenceAreaType}.
+         *
+         * @property x1          - Optional start x coordinate
+         * @property x2          - Optional end x coordinate
+         * @property y1          - Optional lower y value
+         * @property y2          - Optional upper y value
+         * @property fill        - Fill colour
+         * @property fillOpacity - Fill opacity
+         * @property stroke      - Optional border colour
+         * @property label       - Optional caption
+         */
+        readonly ReferenceArea: StructType<{
+            readonly x1: OptionType<VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>>;
+            readonly x2: OptionType<VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: import("@elaraai/east").DateTimeType;
+            }>>;
+            readonly y1: OptionType<FloatType>;
+            readonly y2: OptionType<FloatType>;
+            readonly fill: OptionType<StringType>;
+            readonly fillOpacity: OptionType<FloatType>;
+            readonly stroke: OptionType<StringType>;
+            readonly label: OptionType<StringType>;
         }>;
-        /** Free text label. */
+        /**
+         * A free SVG text label at a data coordinate.
+         *
+         * @remarks
+         * Mirror of {@link ChartTextType}.
+         *
+         * @property point      - The data coordinate to anchor the text at
+         * @property text       - The label string
+         * @property anchor     - Horizontal anchor
+         * @property fill       - Text colour
+         * @property fontSize   - Font size
+         * @property fontWeight - Font weight
+         */
         readonly Text: StructType<{
             readonly point: StructType<{
-                readonly x: import("@elaraai/east").StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>;
-            readonly text: import("@elaraai/east").StringType;
+            readonly text: StringType;
             readonly anchor: OptionType<VariantType<{
                 readonly start: import("@elaraai/east").NullType;
                 readonly middle: import("@elaraai/east").NullType;
                 readonly end: import("@elaraai/east").NullType;
             }>>;
-            readonly fill: OptionType<import("@elaraai/east").StringType>;
+            readonly fill: OptionType<StringType>;
             readonly fontSize: OptionType<FloatType>;
             readonly fontWeight: OptionType<FloatType>;
         }>;
-        /** Multi-series convenience node. */
+        /**
+         * A multi-series mark layer.
+         *
+         * @remarks
+         * Mirror of {@link ChartSeriesMarkType}.
+         *
+         * @property data        - The coloured series to draw
+         * @property mark        - The mark drawn per series
+         * @property curve       - Line/area interpolation
+         * @property stackId     - Stack group id
+         * @property stackOffset - Stacking offset for the group
+         * @property axis        - Which y-axis the layer scales against
+         * @property strokeWidth - Stroke width for line marks
+         * @property dashArray   - SVG dash pattern for line marks
+         * @property dots        - Draw point markers on line marks
+         * @property fillOpacity - Fill opacity for area / bar marks
+         */
         readonly SeriesMark: StructType<{
             readonly data: ArrayType<StructType<{
-                readonly key: import("@elaraai/east").StringType;
-                readonly color: import("@elaraai/east").StringType;
+                readonly key: StringType;
+                readonly color: StringType;
                 readonly points: ArrayType<StructType<{
-                    readonly x: import("@elaraai/east").StringType;
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
                     readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
                 }>>;
             }>>;
             readonly mark: VariantType<{
@@ -535,6 +2856,107 @@ export declare const ChartSpec: {
                 readonly area: import("@elaraai/east").NullType;
                 readonly scatter: import("@elaraai/east").NullType;
             }>;
+            readonly curve: OptionType<VariantType<{
+                readonly monotoneX: import("@elaraai/east").NullType;
+                readonly linear: import("@elaraai/east").NullType;
+                readonly natural: import("@elaraai/east").NullType;
+                readonly step: import("@elaraai/east").NullType;
+            }>>;
+            readonly stackId: OptionType<StringType>;
+            readonly stackOffset: OptionType<VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly expand: import("@elaraai/east").NullType;
+            }>>;
+            readonly axis: OptionType<VariantType<{
+                readonly left: import("@elaraai/east").NullType;
+                readonly right: import("@elaraai/east").NullType;
+            }>>;
+            readonly strokeWidth: OptionType<FloatType>;
+            readonly dashArray: OptionType<StringType>;
+            readonly dots: OptionType<BooleanType>;
+            readonly fillOpacity: OptionType<FloatType>;
+            readonly radius: OptionType<FloatType>;
+        }>;
+        /**
+         * In-chart legend configuration.
+         *
+         * @remarks
+         * Mirror of {@link ChartLegendType}.
+         *
+         * @property orientation - Row or column layout of the swatches
+         * @property position    - Placement relative to the plot
+         */
+        readonly Legend: StructType<{
+            readonly orientation: OptionType<VariantType<{
+                readonly horizontal: import("@elaraai/east").NullType;
+                readonly vertical: import("@elaraai/east").NullType;
+            }>>;
+            readonly position: OptionType<VariantType<{
+                readonly top: import("@elaraai/east").NullType;
+                readonly bottom: import("@elaraai/east").NullType;
+                readonly left: import("@elaraai/east").NullType;
+                readonly right: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        /**
+         * Legend orientation.
+         *
+         * @remarks
+         * Mirror of {@link ChartLegendOrientationType}.
+         *
+         * @property horizontal - Swatches in a row
+         * @property vertical   - Swatches in a column
+         */
+        readonly LegendOrientation: VariantType<{
+            readonly horizontal: import("@elaraai/east").NullType;
+            readonly vertical: import("@elaraai/east").NullType;
+        }>;
+        /**
+         * Legend placement relative to the plot.
+         *
+         * @remarks
+         * Mirror of {@link ChartLegendPositionType}.
+         *
+         * @property top    - Above the plot
+         * @property bottom - Below the plot
+         * @property left   - Left of the plot
+         * @property right  - Right of the plot
+         */
+        readonly LegendPosition: VariantType<{
+            readonly top: import("@elaraai/east").NullType;
+            readonly bottom: import("@elaraai/east").NullType;
+            readonly left: import("@elaraai/east").NullType;
+            readonly right: import("@elaraai/east").NullType;
+        }>;
+        /**
+         * In-chart tooltip configuration.
+         *
+         * @remarks
+         * Mirror of {@link ChartTooltipType}.
+         *
+         * @property cursor - The cursor indicator drawn at the hovered position
+         */
+        readonly Tooltip: StructType<{
+            readonly cursor: OptionType<VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly line: import("@elaraai/east").NullType;
+                readonly fill: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        /**
+         * Tooltip hover cursor.
+         *
+         * @remarks
+         * Mirror of {@link ChartTooltipCursorType}.
+         *
+         * @property none - No cursor indicator
+         * @property line - A vertical guide at the hovered x
+         * @property fill - A filled band over the hovered category
+         */
+        readonly TooltipCursor: VariantType<{
+            readonly none: import("@elaraai/east").NullType;
+            readonly line: import("@elaraai/east").NullType;
+            readonly fill: import("@elaraai/east").NullType;
         }>;
     };
 };