@elaraai/east-ui 1.0.4 → 1.0.5

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

@@ -0,0 +1,1615 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `Chart` — the high-level, declarative chart authoring API. A chart is a
+ * container of layers (`Chart.Root([...])`); each layer is a mark
+ * (`Chart.Line` / `Bar` / `Area` / `Scatter` / `Band`) over a typed-accessor
+ * encoding, plus annotation layers (`Chart.refLine` / `refBand` / `refDot`).
+ *
+ * @remarks
+ * The builders compile down to the visx-primitive `Chart.Spec` tree (the
+ * `VisxChart` arm of `UIComponentType`) — the same core `Slice.Chart.*` uses.
+ * Encodings bind data by typed accessor closures (`r => r.field`); the
+ * coordinate kind (and therefore the x scale) is inferred from the accessor's
+ * East type. The renderer derives domains and range-appropriate ticks, so dates
+ * are never pre-formatted.
+ *
+ * @packageDocumentation
+ */
+import { type ExprType, type SubtypeExprOrValue, type EastType, ArrayType, OptionType, StringType, IntegerType, FloatType, DateTimeType, BooleanType, DictType } from "@elaraai/east";
+import { UIComponentType } from "../../component.js";
+import { SliceBindType } from "../../platform/slice/index.js";
+import { type SliceAffordanceLiteral } from "../../contracts/slice-affordances.js";
+import { ChartTickFormatType, ChartCurveType, type ChartCurveLiteral, ChartSeriesArrayType, ChartBandSeriesArrayType, chartFrame, chartSeries, chartBandArea, chartAxisBottom, chartAxisLeft, chartAxisRight, chartGridRows, chartGridColumns, chartReferenceDot, chartReferenceArea, type ChartSpecValue } from "../spec/index.js";
+/** Scale kind a coordinate implies; derived from the encoding's x accessor. */
+type ScaleKind = "band" | "linear" | "time";
+/**
+ * Reads an x-coordinate field off a typed row (e.g. `r => r.month`). The field's
+ * East type chooses the scale: `String` → band, `Integer`/`Float` → linear,
+ * `DateTime` → time.
+ */
+type XAccessor<Row extends EastType> = (row: ExprType<Row>) => SubtypeExprOrValue<StringType | IntegerType | FloatType | DateTimeType>;
+/** Reads a numeric value field off a typed row (e.g. `r => r.sessions`). */
+type ValueAccessor<Row extends EastType> = (row: ExprType<Row>) => SubtypeExprOrValue<IntegerType | FloatType>;
+/** Reads a category field off a typed row, used to split into series (e.g. `r => r.platform`). */
+type CategoryAccessor<Row extends EastType> = (row: ExprType<Row>) => SubtypeExprOrValue<StringType | IntegerType | BooleanType | DateTimeType>;
+/**
+ * Per-mark styling applied across a whole layer.
+ *
+ * @property key         - Series key (legend label) for a single-series layer
+ * @property color       - Series colour (theme token); defaults to the palette
+ * @property curve       - Line/area interpolation
+ * @property width       - Stroke width (line marks)
+ * @property dash        - SVG dash pattern (line marks)
+ * @property dots        - Draw point markers on line marks
+ * @property fillOpacity - Fill opacity (area / bar marks)
+ * @property stack       - Stack group id; layers sharing one stack accumulate
+ * @property axis        - Which y-axis the layer scales against
+ * @property order       - Draw order among sibling layers (higher draws later)
+ *
+ * @remarks
+ * Scatter marks take {@link ScatterStyle} instead, which adds marker sizing.
+ */
+export interface MarkStyle {
+    /** Series key (legend label) for a single-series layer. */
+    key?: SubtypeExprOrValue<StringType>;
+    /** Series colour (theme token); defaults to the palette. */
+    color?: SubtypeExprOrValue<StringType>;
+    /** Line/area interpolation. */
+    curve?: SubtypeExprOrValue<ChartCurveType> | ChartCurveLiteral;
+    /** Stroke width (line marks). */
+    width?: SubtypeExprOrValue<FloatType>;
+    /** SVG dash pattern (line marks). */
+    dash?: SubtypeExprOrValue<StringType>;
+    /** Draw point markers on line marks. */
+    dots?: SubtypeExprOrValue<BooleanType>;
+    /** Fill opacity (area / bar marks). */
+    fillOpacity?: SubtypeExprOrValue<FloatType>;
+    /** Stack group id; layers sharing one stack accumulate together. */
+    stack?: SubtypeExprOrValue<StringType>;
+    /** Which y-axis the layer scales against (structural — picks the axis node). */
+    axis?: "left" | "right";
+    /** Draw order among sibling layers (higher draws later; a build-time sort key). */
+    order?: number;
+}
+/**
+ * Scatter styling — {@link MarkStyle} plus a uniform marker radius. Bubble sizing
+ * (per-point) comes from the encoding's `size` accessor and overrides this.
+ *
+ * @property size - Uniform marker radius in px; omit to use the default radius
+ */
+export interface ScatterStyle extends MarkStyle {
+    /** Uniform marker radius in px; a per-point `size` accessor in the encoding overrides it. */
+    size?: SubtypeExprOrValue<FloatType>;
+}
+/**
+ * Encoding producing a single series — one point per row.
+ *
+ * @typeParam Row - The row struct; accessors are checked against its fields
+ * @property x - Field placed on the x-axis (its East type chooses the scale)
+ * @property y - Numeric field summed into each point's value
+ */
+export interface PointEncoding<Row extends EastType> {
+    /** Field placed on the x-axis (its East type chooses the scale). */
+    x: XAccessor<Row>;
+    /** Numeric field summed into each point's value. */
+    y: ValueAccessor<Row>;
+}
+/**
+ * Encoding splitting rows into one series per distinct `by` value (the slice pivot).
+ *
+ * @typeParam Row - The row struct; accessors are checked against its fields
+ * @property x      - Field placed on the x-axis
+ * @property y      - Numeric field aggregated per point
+ * @property by     - Category field; one coloured series per distinct value
+ * @property colors - Explicit per-value colours (theme tokens); palette by order otherwise
+ */
+export interface SplitEncoding<Row extends EastType> {
+    /** Field placed on the x-axis. */
+    x: XAccessor<Row>;
+    /** Numeric field aggregated per point. */
+    y: ValueAccessor<Row>;
+    /** Category field; one coloured series per distinct value. */
+    by: CategoryAccessor<Row>;
+    /** Explicit per-value colours (theme tokens); palette by order otherwise. */
+    colors?: Record<string, string>;
+}
+/**
+ * Encoding fanning wide rows into one series per named value column.
+ *
+ * @typeParam Row - The row struct; accessors are checked against its fields
+ * @property x       - Field placed on the x-axis
+ * @property columns - Named value columns; each becomes a coloured series keyed by its name
+ */
+export interface ColumnsEncoding<Row extends EastType> {
+    /** Field placed on the x-axis. */
+    x: XAccessor<Row>;
+    /** Named value columns; each becomes a coloured series keyed by its name. */
+    columns: Record<string, ValueAccessor<Row>>;
+}
+/**
+ * Encoding for a band (area-range) layer — a low/high pair per row.
+ *
+ * @typeParam Row - The row struct; accessors are checked against its fields
+ * @property x    - Field placed on the x-axis
+ * @property low  - Lower-bound numeric field
+ * @property high - Upper-bound numeric field
+ */
+export interface BandEncoding<Row extends EastType> {
+    /** Field placed on the x-axis. */
+    x: XAccessor<Row>;
+    /** Lower-bound numeric field. */
+    low: ValueAccessor<Row>;
+    /** Upper-bound numeric field. */
+    high: ValueAccessor<Row>;
+}
+/** Any cartesian-mark encoding (line / bar / area / scatter) over a row struct. */
+export type MarkEncoding<Row extends EastType> = PointEncoding<Row> | SplitEncoding<Row> | ColumnsEncoding<Row>;
+/**
+ * A scatter encoding — any cartesian-mark encoding plus an optional per-point
+ * `size` accessor that drives bubble sizing (area-proportional). Only
+ * `Chart.Scatter` accepts this; other marks never expose `size`.
+ *
+ * @typeParam Row - The row struct; accessors are checked against its fields
+ */
+export type ScatterEncoding<Row extends EastType> = MarkEncoding<Row> & {
+    /** Numeric field mapped to each marker's area (bubble sizing); uniform when omitted. */
+    size?: ValueAccessor<Row>;
+};
+/** Rows feeding a mark — an East array of row structs of type `Row`. */
+export type ChartRows<Row extends EastType> = SubtypeExprOrValue<ArrayType<Row>>;
+type MarkKind = "line" | "bar" | "area" | "scatter";
+/** A deferred chart layer; `Chart.Root` finalizes it into `Chart.Spec` nodes. */
+interface SeriesLayer {
+    kind: "series";
+    mark: MarkKind;
+    data: ExprType<ChartSeriesArrayType>;
+    xScale: ScaleKind;
+    style: MarkStyle;
+    /** Uniform scatter marker radius (scatter layers only). */
+    radius?: SubtypeExprOrValue<FloatType>;
+}
+interface BandLayer {
+    kind: "band";
+    data: ExprType<ChartBandSeriesArrayType>;
+    xScale: ScaleKind;
+    style: MarkStyle;
+}
+interface RefLayer {
+    kind: "ref";
+    node: ChartSpecValue;
+}
+/** A layer accepted by {@link createChartRoot}. */
+export type ChartLayer = SeriesLayer | BandLayer | RefLayer;
+/**
+ * An x position for a reference annotation — a literal (`string` category /
+ * `number` / `Date`) or an East expression. The coordinate arm is inferred from
+ * the literal's JS type, or from the expression's East type (see {@link xCoord}).
+ */
+type CoordValue = string | number | Date | SubtypeExprOrValue<EastType>;
+/** Options for {@link createRefLine}. */
+export interface RefLineOptions {
+    /** Horizontal line at this y value (literal or expression). */
+    y?: SubtypeExprOrValue<FloatType>;
+    /** Vertical line at this x position (literal or expression). */
+    x?: CoordValue;
+    /** Optional caption. */
+    label?: SubtypeExprOrValue<StringType>;
+    /** SVG dash pattern; solid when omitted. */
+    dash?: SubtypeExprOrValue<StringType>;
+}
+/** Build a reference-line layer (a `rule` node). */
+declare function createRefLine(options: RefLineOptions): RefLayer;
+/** Options for {@link createRefBand}. */
+export interface RefBandOptions {
+    /** Horizontal band between `[low, high]` y values (literals or expressions). */
+    y?: [SubtypeExprOrValue<FloatType>, SubtypeExprOrValue<FloatType>];
+    /** Vertical band between `[low, high]` x positions (literals or expressions). */
+    x?: [CoordValue, CoordValue];
+    /** Optional caption. */
+    label?: SubtypeExprOrValue<StringType>;
+}
+/** Build a reference-band layer (a `referenceArea` node). */
+declare function createRefBand(options: RefBandOptions): RefLayer;
+/** Options for {@link createRefDot}. */
+export interface RefDotOptions {
+    /** Marker x position (literal or expression). */
+    x: CoordValue;
+    /** Marker y value (literal or expression). */
+    y: SubtypeExprOrValue<FloatType>;
+    /** Optional caption. */
+    label?: SubtypeExprOrValue<StringType>;
+}
+/** Build a reference-dot layer (a `referenceDot` node). */
+declare function createRefDot(options: RefDotOptions): RefLayer;
+/** Axis configuration for one of `Chart.Root`'s axes. */
+export interface AxisOptions {
+    /** Axis caption. */
+    label?: SubtypeExprOrValue<StringType>;
+    /** Tick-label format (see {@link Chart.format}). */
+    format?: SubtypeExprOrValue<ChartTickFormatType>;
+    /** Explicit `[min, max]` extent (numbers or dates). */
+    domain?: [number, number] | [Date, Date];
+    /** Force the x-scale kind instead of inferring it from the data. */
+    scale?: ScaleKind;
+}
+/** Options for {@link createChartRoot}. */
+export interface ChartOptions {
+    /** Plot height in px. */
+    height?: SubtypeExprOrValue<FloatType>;
+    /** Plot width in px; omit for responsive. */
+    width?: SubtypeExprOrValue<FloatType>;
+    /** X-axis configuration. */
+    x?: AxisOptions;
+    /** Primary (left) y-axis configuration. */
+    y?: AxisOptions;
+    /** Secondary (right) y-axis configuration; presence enables a dual axis. */
+    y2?: AxisOptions;
+    /** Show background gridlines. Default `true`. */
+    grid?: boolean;
+    /** Show the colour-matched legend. */
+    legend?: boolean;
+    /** Show the hover tooltip. */
+    tooltip?: boolean;
+    /** Stacking offset for stacked layers (`expand` = percent stacking). */
+    stackOffset?: "none" | "expand";
+    /**
+     * Slice chrome — pass the bound handle and the chart renders its own
+     * header rail mounting the `affordances` (default
+     * `["breakdown", "range"]`). With `"brush"` listed (and a continuous x)
+     * dragging the plot writes the slice's range; with a breakdown active the
+     * colour-matched legend renders below the plot. Chrome only: layer data
+     * is fed explicitly (`Slice.rows` / `Chart.Series`).
+     */
+    slice?: SubtypeExprOrValue<SliceBindType>;
+    /** Rail affordances when `slice` is set. Default `["breakdown", "range"]`. */
+    affordances?: SliceAffordanceLiteral[];
+}
+declare function createChartRoot(layers: ChartLayer | ChartLayer[], options?: ChartOptions): ExprType<UIComponentType>;
+/** Options for {@link Chart.Series} — the slice-parameterized layer. */
+export interface ChartSliceSeriesOptions {
+    /** Field id whose value positions each point on the x-axis. */
+    x: string;
+    /** Numeric field id summed into each series point. */
+    value: string;
+    /** The mark drawn per series. Default `"line"`. */
+    mark?: "line" | "bar" | "area" | "scatter";
+}
+/**
+ * The slice-parameterized layer: pivots the narrowed rows by the slice's
+ * active breakdown into one coloured series per dimension value (colours
+ * assigned by the slice, matching the legend) and draws them as `mark`.
+ * Compose it with ordinary layers in the same `Chart`:
+ *
+ * ```tsx
+ * <Chart layers={[Chart.Series(slice, { x: "month", value: "sessions" })]} slice={slice} />
+ * ```
+ */
+declare function createSliceSeries(slice: SubtypeExprOrValue<SliceBindType>, options: ChartSliceSeriesOptions): SeriesLayer;
+/** `Chart` — declarative chart authoring (see the module overview). */
+export declare const Chart: {
+    /** Assembles layers into a chart value (the `VisxChart` arm). */
+    readonly Root: typeof createChartRoot;
+    /** Line-mark layer over a cartesian-mark encoding. */
+    readonly Line: <Row extends EastType>(rows: ChartRows<Row>, encoding: MarkEncoding<Row>, style?: MarkStyle) => SeriesLayer;
+    /** Bar-mark layer over a cartesian-mark encoding. */
+    readonly Bar: <Row extends EastType>(rows: ChartRows<Row>, encoding: MarkEncoding<Row>, style?: MarkStyle) => SeriesLayer;
+    /** Area-mark layer over a cartesian-mark encoding. */
+    readonly Area: <Row extends EastType>(rows: ChartRows<Row>, encoding: MarkEncoding<Row>, style?: MarkStyle) => SeriesLayer;
+    /** Scatter-mark layer; the encoding may add a per-point `size` for bubbles. */
+    readonly Scatter: <Row extends EastType>(rows: ChartRows<Row>, encoding: ScatterEncoding<Row>, style?: ScatterStyle) => SeriesLayer;
+    /** Band (area-range) layer over a `{ x, low, high }` encoding. */
+    readonly Band: <Row extends EastType>(rows: ChartRows<Row>, encoding: BandEncoding<Row>, style?: MarkStyle) => BandLayer;
+    /** Slice-parameterized layer — one coloured series per active-breakdown value (see {@link createSliceSeries}). */
+    readonly Series: typeof createSliceSeries;
+    /** Reference-line annotation layer. */
+    readonly refLine: typeof createRefLine;
+    /** Reference-band annotation layer. */
+    readonly refBand: typeof createRefBand;
+    /** Reference-dot annotation layer. */
+    readonly refDot: typeof createRefDot;
+    /** Axis tick-format builders. */
+    readonly format: {
+        /** Plain number tick formatting. */
+        readonly number: () => ExprType<ChartTickFormatType>;
+        /** Currency tick formatting. */
+        readonly currency: (opts?: {
+            code?: SubtypeExprOrValue<StringType>;
+            compact?: SubtypeExprOrValue<BooleanType>;
+        }) => ExprType<ChartTickFormatType>;
+        /** Percentage tick formatting. */
+        readonly percent: () => ExprType<ChartTickFormatType>;
+        /** Compact magnitude tick formatting (e.g. `1.2k`). */
+        readonly compact: () => ExprType<ChartTickFormatType>;
+        /** Date tick formatting with a pattern (e.g. `"MMM YYYY"`). */
+        readonly date: (pattern: SubtypeExprOrValue<StringType>) => ExprType<ChartTickFormatType>;
+        /** Time tick formatting with a pattern. */
+        readonly time: (pattern: SubtypeExprOrValue<StringType>) => ExprType<ChartTickFormatType>;
+        /** Datetime tick formatting with a pattern. */
+        readonly datetime: (pattern: SubtypeExprOrValue<StringType>) => ExprType<ChartTickFormatType>;
+    };
+    /**
+     * The low-level visx-primitive escape hatch (`Chart.Spec.{frame,series,…}`
+     * + `Chart.Spec.Types.*`); the high-level builders compile down to it.
+     */
+    readonly Spec: {
+        readonly frame: typeof chartFrame;
+        readonly series: typeof chartSeries;
+        readonly bandArea: typeof chartBandArea;
+        readonly axisBottom: typeof chartAxisBottom;
+        readonly axisLeft: typeof chartAxisLeft;
+        readonly axisRight: typeof chartAxisRight;
+        readonly gridRows: typeof chartGridRows;
+        readonly gridColumns: typeof chartGridColumns;
+        readonly referenceDot: typeof chartReferenceDot;
+        readonly referenceArea: typeof chartReferenceArea;
+        readonly Types: {
+            readonly Spec: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                readonly frame: import("@elaraai/east").StructType<{
+                    readonly height: FloatType;
+                    readonly width: OptionType<FloatType>;
+                    readonly margin: OptionType<import("@elaraai/east").StructType<{
+                        readonly top: FloatType;
+                        readonly right: FloatType;
+                        readonly bottom: FloatType;
+                        readonly left: FloatType;
+                    }>>;
+                    readonly xScale: import("@elaraai/east").VariantType<{
+                        readonly band: import("@elaraai/east").NullType;
+                        readonly linear: import("@elaraai/east").NullType;
+                        readonly time: import("@elaraai/east").NullType;
+                    }>;
+                    readonly yScale: import("@elaraai/east").VariantType<{
+                        readonly band: import("@elaraai/east").NullType;
+                        readonly linear: import("@elaraai/east").NullType;
+                        readonly time: import("@elaraai/east").NullType;
+                    }>;
+                    readonly yScale2: OptionType<import("@elaraai/east").VariantType<{
+                        readonly band: import("@elaraai/east").NullType;
+                        readonly linear: import("@elaraai/east").NullType;
+                        readonly time: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly tooltip: OptionType<import("@elaraai/east").StructType<{
+                        readonly cursor: OptionType<import("@elaraai/east").VariantType<{
+                            readonly none: import("@elaraai/east").NullType;
+                            readonly line: import("@elaraai/east").NullType;
+                            readonly fill: import("@elaraai/east").NullType;
+                        }>>;
+                    }>>;
+                    readonly legend: OptionType<import("@elaraai/east").StructType<{
+                        readonly orientation: OptionType<import("@elaraai/east").VariantType<{
+                            readonly horizontal: import("@elaraai/east").NullType;
+                            readonly vertical: import("@elaraai/east").NullType;
+                        }>>;
+                        readonly position: OptionType<import("@elaraai/east").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<import("@elaraai/east").StructType<{
+                        readonly slice: import("@elaraai/east").StructType<{
+                            readonly key: StringType;
+                            readonly read: import("@elaraai/east").FunctionType<[], import("@elaraai/east").StructType<{
+                                readonly range: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly datetime: import("@elaraai/east").StructType<{
+                                        readonly from: DateTimeType;
+                                        readonly to: DateTimeType;
+                                    }>;
+                                    readonly datetimePreset: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                        readonly from: IntegerType;
+                                        readonly to: IntegerType;
+                                    }>;
+                                    readonly float: import("@elaraai/east").StructType<{
+                                        readonly from: FloatType;
+                                        readonly to: FloatType;
+                                    }>;
+                                }>>;
+                                readonly compare: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly previousPeriod: import("@elaraai/east").NullType;
+                                    readonly previousYear: import("@elaraai/east").NullType;
+                                }>>;
+                                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                    readonly string: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly eq: IntegerType;
+                                            readonly neq: IntegerType;
+                                            readonly lt: IntegerType;
+                                            readonly lte: IntegerType;
+                                            readonly gt: IntegerType;
+                                            readonly gte: IntegerType;
+                                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                        }>;
+                                    }>;
+                                    readonly float: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly lt: FloatType;
+                                            readonly lte: FloatType;
+                                            readonly gt: FloatType;
+                                            readonly gte: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly datetime: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly before: DateTimeType;
+                                            readonly after: DateTimeType;
+                                            readonly between: import("@elaraai/east").StructType<{
+                                                readonly from: DateTimeType;
+                                                readonly to: DateTimeType;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly boolean: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly is: BooleanType;
+                                        }>;
+                                    }>;
+                                }>>;
+                                readonly cohorts: ArrayType<import("@elaraai/east").StructType<{
+                                    readonly id: StringType;
+                                    readonly name: StringType;
+                                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly string: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly eq: IntegerType;
+                                                readonly neq: IntegerType;
+                                                readonly lt: IntegerType;
+                                                readonly lte: IntegerType;
+                                                readonly gt: IntegerType;
+                                                readonly gte: IntegerType;
+                                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                            }>;
+                                        }>;
+                                        readonly float: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly lt: FloatType;
+                                                readonly lte: FloatType;
+                                                readonly gt: FloatType;
+                                                readonly gte: FloatType;
+                                            }>;
+                                        }>;
+                                        readonly datetime: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly before: DateTimeType;
+                                                readonly after: DateTimeType;
+                                                readonly between: import("@elaraai/east").StructType<{
+                                                    readonly from: DateTimeType;
+                                                    readonly to: DateTimeType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                        readonly boolean: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly is: BooleanType;
+                                            }>;
+                                        }>;
+                                    }>>;
+                                }>>;
+                                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                                readonly breakdown: OptionType<import("@elaraai/east").StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly limit: OptionType<IntegerType>;
+                                }>>;
+                                readonly search: OptionType<StringType>;
+                                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                                readonly selectedIndex: OptionType<IntegerType>;
+                            }>>;
+                            readonly write: import("@elaraai/east").FunctionType<[import("@elaraai/east").StructType<{
+                                readonly range: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly datetime: import("@elaraai/east").StructType<{
+                                        readonly from: DateTimeType;
+                                        readonly to: DateTimeType;
+                                    }>;
+                                    readonly datetimePreset: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                        readonly from: IntegerType;
+                                        readonly to: IntegerType;
+                                    }>;
+                                    readonly float: import("@elaraai/east").StructType<{
+                                        readonly from: FloatType;
+                                        readonly to: FloatType;
+                                    }>;
+                                }>>;
+                                readonly compare: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly previousPeriod: import("@elaraai/east").NullType;
+                                    readonly previousYear: import("@elaraai/east").NullType;
+                                }>>;
+                                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                    readonly string: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly eq: IntegerType;
+                                            readonly neq: IntegerType;
+                                            readonly lt: IntegerType;
+                                            readonly lte: IntegerType;
+                                            readonly gt: IntegerType;
+                                            readonly gte: IntegerType;
+                                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                        }>;
+                                    }>;
+                                    readonly float: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly lt: FloatType;
+                                            readonly lte: FloatType;
+                                            readonly gt: FloatType;
+                                            readonly gte: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly datetime: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly before: DateTimeType;
+                                            readonly after: DateTimeType;
+                                            readonly between: import("@elaraai/east").StructType<{
+                                                readonly from: DateTimeType;
+                                                readonly to: DateTimeType;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly boolean: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly is: BooleanType;
+                                        }>;
+                                    }>;
+                                }>>;
+                                readonly cohorts: ArrayType<import("@elaraai/east").StructType<{
+                                    readonly id: StringType;
+                                    readonly name: StringType;
+                                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                        readonly string: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly eq: IntegerType;
+                                                readonly neq: IntegerType;
+                                                readonly lt: IntegerType;
+                                                readonly lte: IntegerType;
+                                                readonly gt: IntegerType;
+                                                readonly gte: IntegerType;
+                                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                            }>;
+                                        }>;
+                                        readonly float: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly lt: FloatType;
+                                                readonly lte: FloatType;
+                                                readonly gt: FloatType;
+                                                readonly gte: FloatType;
+                                            }>;
+                                        }>;
+                                        readonly datetime: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly before: DateTimeType;
+                                                readonly after: DateTimeType;
+                                                readonly between: import("@elaraai/east").StructType<{
+                                                    readonly from: DateTimeType;
+                                                    readonly to: DateTimeType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                        readonly boolean: import("@elaraai/east").StructType<{
+                                            readonly fieldId: StringType;
+                                            readonly op: import("@elaraai/east").VariantType<{
+                                                readonly is: BooleanType;
+                                            }>;
+                                        }>;
+                                    }>>;
+                                }>>;
+                                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                                readonly breakdown: OptionType<import("@elaraai/east").StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly limit: OptionType<IntegerType>;
+                                }>>;
+                                readonly search: OptionType<StringType>;
+                                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                                readonly selectedIndex: OptionType<IntegerType>;
+                            }>], import("@elaraai/east").NullType>;
+                            readonly setRange: import("@elaraai/east").FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                                readonly datetime: import("@elaraai/east").StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                                readonly datetimePreset: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                    readonly from: IntegerType;
+                                    readonly to: IntegerType;
+                                }>;
+                                readonly float: import("@elaraai/east").StructType<{
+                                    readonly from: FloatType;
+                                    readonly to: FloatType;
+                                }>;
+                            }>>], import("@elaraai/east").NullType>;
+                            readonly setCompare: import("@elaraai/east").FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                                readonly previousPeriod: import("@elaraai/east").NullType;
+                                readonly previousYear: import("@elaraai/east").NullType;
+                            }>>], import("@elaraai/east").NullType>;
+                            readonly addFilter: import("@elaraai/east").FunctionType<[import("@elaraai/east").VariantType<{
+                                readonly string: import("@elaraai/east").StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly eq: IntegerType;
+                                        readonly neq: IntegerType;
+                                        readonly lt: IntegerType;
+                                        readonly lte: IntegerType;
+                                        readonly gt: IntegerType;
+                                        readonly gte: IntegerType;
+                                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                    }>;
+                                }>;
+                                readonly float: import("@elaraai/east").StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly lt: FloatType;
+                                        readonly lte: FloatType;
+                                        readonly gt: FloatType;
+                                        readonly gte: FloatType;
+                                    }>;
+                                }>;
+                                readonly datetime: import("@elaraai/east").StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly before: DateTimeType;
+                                        readonly after: DateTimeType;
+                                        readonly between: import("@elaraai/east").StructType<{
+                                            readonly from: DateTimeType;
+                                            readonly to: DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                readonly boolean: import("@elaraai/east").StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly is: BooleanType;
+                                    }>;
+                                }>;
+                            }>], import("@elaraai/east").NullType>;
+                            readonly removeFilter: import("@elaraai/east").FunctionType<[IntegerType], import("@elaraai/east").NullType>;
+                            readonly clearFilters: import("@elaraai/east").FunctionType<[], import("@elaraai/east").NullType>;
+                            readonly defineCohort: import("@elaraai/east").FunctionType<[import("@elaraai/east").StructType<{
+                                readonly id: StringType;
+                                readonly name: StringType;
+                                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                    readonly string: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly eq: IntegerType;
+                                            readonly neq: IntegerType;
+                                            readonly lt: IntegerType;
+                                            readonly lte: IntegerType;
+                                            readonly gt: IntegerType;
+                                            readonly gte: IntegerType;
+                                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                        }>;
+                                    }>;
+                                    readonly float: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly lt: FloatType;
+                                            readonly lte: FloatType;
+                                            readonly gt: FloatType;
+                                            readonly gte: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly datetime: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly before: DateTimeType;
+                                            readonly after: DateTimeType;
+                                            readonly between: import("@elaraai/east").StructType<{
+                                                readonly from: DateTimeType;
+                                                readonly to: DateTimeType;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly boolean: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly is: BooleanType;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>], import("@elaraai/east").NullType>;
+                            readonly updateCohort: import("@elaraai/east").FunctionType<[StringType, import("@elaraai/east").StructType<{
+                                readonly id: StringType;
+                                readonly name: StringType;
+                                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                    readonly string: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly eq: IntegerType;
+                                            readonly neq: IntegerType;
+                                            readonly lt: IntegerType;
+                                            readonly lte: IntegerType;
+                                            readonly gt: IntegerType;
+                                            readonly gte: IntegerType;
+                                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                        }>;
+                                    }>;
+                                    readonly float: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly lt: FloatType;
+                                            readonly lte: FloatType;
+                                            readonly gt: FloatType;
+                                            readonly gte: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly datetime: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").VariantType<{
+                                            readonly before: DateTimeType;
+                                            readonly after: DateTimeType;
+                                            readonly between: import("@elaraai/east").StructType<{
+                                                readonly from: DateTimeType;
+                                                readonly to: DateTimeType;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly boolean: import("@elaraai/east").StructType<{
+                                        readonly fieldId: StringType;
+                                        readonly op: import("@elaraai/east").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<import("@elaraai/east").StructType<{
+                                readonly fieldId: StringType;
+                                readonly limit: OptionType<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<IntegerType>], import("@elaraai/east").NullType>;
+                            readonly isActive: import("@elaraai/east").FunctionType<[], BooleanType>;
+                            readonly activeCount: import("@elaraai/east").FunctionType<[], IntegerType>;
+                            readonly dimensions: import("@elaraai/east").FunctionType<[], ArrayType<import("@elaraai/east").StructType<{
+                                readonly fieldId: StringType;
+                                readonly label: StringType;
+                            }>>>;
+                            readonly fields: import("@elaraai/east").FunctionType<[], ArrayType<import("@elaraai/east").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<[], IntegerType>;
+                            readonly resultCount: import("@elaraai/east").FunctionType<[], IntegerType>;
+                            readonly groups: import("@elaraai/east").FunctionType<[], ArrayType<import("@elaraai/east").StructType<{
+                                readonly key: StringType;
+                                readonly count: IntegerType;
+                                readonly color: StringType;
+                            }>>>;
+                            readonly series: import("@elaraai/east").FunctionType<[StringType, StringType], ArrayType<import("@elaraai/east").StructType<{
+                                readonly key: StringType;
+                                readonly color: StringType;
+                                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                                    readonly x: import("@elaraai/east").VariantType<{
+                                        readonly category: StringType;
+                                        readonly number: FloatType;
+                                        readonly time: DateTimeType;
+                                    }>;
+                                    readonly value: FloatType;
+                                    readonly size: OptionType<FloatType>;
+                                }>>;
+                            }>>>;
+                            readonly matches: import("@elaraai/east").FunctionType<[], ArrayType<import("@elaraai/east").StructType<{
+                                readonly id: StringType;
+                                readonly label: StringType;
+                                readonly meta: OptionType<StringType>;
+                            }>>>;
+                            readonly cohortCounts: import("@elaraai/east").FunctionType<[], DictType<StringType, IntegerType>>;
+                        }>;
+                        readonly affordances: ArrayType<import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                    readonly left: FloatType;
+                    readonly top: FloatType;
+                    readonly children: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly linePath: import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
+                        readonly x: import("@elaraai/east").VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                    }>>;
+                    readonly stroke: StringType;
+                    readonly strokeWidth: OptionType<FloatType>;
+                    readonly curve: OptionType<import("@elaraai/east").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 dashArray: OptionType<StringType>;
+                    readonly opacity: OptionType<FloatType>;
+                }>;
+                readonly area: import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
+                        readonly x: import("@elaraai/east").VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                    }>>;
+                    readonly fill: StringType;
+                    readonly fillOpacity: OptionType<FloatType>;
+                    readonly stroke: OptionType<StringType>;
+                    readonly strokeWidth: OptionType<FloatType>;
+                    readonly curve: OptionType<import("@elaraai/east").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 bandArea: import("@elaraai/east").StructType<{
+                    readonly data: ArrayType<import("@elaraai/east").StructType<{
+                        readonly key: StringType;
+                        readonly color: StringType;
+                        readonly points: ArrayType<import("@elaraai/east").StructType<{
+                            readonly x: import("@elaraai/east").VariantType<{
+                                readonly category: StringType;
+                                readonly number: FloatType;
+                                readonly time: DateTimeType;
+                            }>;
+                            readonly low: FloatType;
+                            readonly high: FloatType;
+                        }>>;
+                    }>>;
+                    readonly curve: OptionType<import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
+                        readonly x: import("@elaraai/east").VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                    }>>;
+                    readonly fill: StringType;
+                    readonly fillOpacity: OptionType<FloatType>;
+                    readonly radius: OptionType<FloatType>;
+                }>;
+                readonly points: import("@elaraai/east").StructType<{
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
+                        readonly x: import("@elaraai/east").VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                    }>>;
+                    readonly fill: StringType;
+                    readonly radius: OptionType<FloatType>;
+                    readonly stroke: OptionType<StringType>;
+                    readonly strokeWidth: OptionType<FloatType>;
+                }>;
+                readonly rule: import("@elaraai/east").StructType<{
+                    readonly axis: import("@elaraai/east").VariantType<{
+                        readonly x: import("@elaraai/east").NullType;
+                        readonly y: import("@elaraai/east").NullType;
+                    }>;
+                    readonly at: StringType;
+                    readonly stroke: StringType;
+                    readonly dashArray: OptionType<StringType>;
+                }>;
+                readonly referenceDot: import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: 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: import("@elaraai/east").StructType<{
+                    readonly x1: OptionType<import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>>;
+                    readonly x2: OptionType<import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: 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: import("@elaraai/east").StructType<{
+                    readonly point: import("@elaraai/east").StructType<{
+                        readonly x: import("@elaraai/east").VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                    }>;
+                    readonly text: StringType;
+                    readonly anchor: OptionType<import("@elaraai/east").VariantType<{
+                        readonly start: import("@elaraai/east").NullType;
+                        readonly middle: import("@elaraai/east").NullType;
+                        readonly end: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly fill: OptionType<StringType>;
+                    readonly fontSize: OptionType<FloatType>;
+                    readonly fontWeight: OptionType<FloatType>;
+                }>;
+                readonly axisBottom: import("@elaraai/east").StructType<{
+                    readonly label: OptionType<StringType>;
+                    readonly numTicks: OptionType<FloatType>;
+                    readonly hideTicks: OptionType<BooleanType>;
+                    readonly hideLine: OptionType<BooleanType>;
+                    readonly domain: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: import("@elaraai/east").StructType<{
+                            readonly min: FloatType;
+                            readonly max: FloatType;
+                        }>;
+                        readonly time: import("@elaraai/east").StructType<{
+                            readonly min: DateTimeType;
+                            readonly max: DateTimeType;
+                        }>;
+                    }>>;
+                    readonly tickFormat: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: import("@elaraai/east").NullType;
+                        readonly currency: import("@elaraai/east").StructType<{
+                            readonly code: StringType;
+                            readonly compact: BooleanType;
+                        }>;
+                        readonly percent: import("@elaraai/east").NullType;
+                        readonly compact: import("@elaraai/east").NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>;
+                readonly axisLeft: import("@elaraai/east").StructType<{
+                    readonly label: OptionType<StringType>;
+                    readonly numTicks: OptionType<FloatType>;
+                    readonly hideTicks: OptionType<BooleanType>;
+                    readonly hideLine: OptionType<BooleanType>;
+                    readonly domain: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: import("@elaraai/east").StructType<{
+                            readonly min: FloatType;
+                            readonly max: FloatType;
+                        }>;
+                        readonly time: import("@elaraai/east").StructType<{
+                            readonly min: DateTimeType;
+                            readonly max: DateTimeType;
+                        }>;
+                    }>>;
+                    readonly tickFormat: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: import("@elaraai/east").NullType;
+                        readonly currency: import("@elaraai/east").StructType<{
+                            readonly code: StringType;
+                            readonly compact: BooleanType;
+                        }>;
+                        readonly percent: import("@elaraai/east").NullType;
+                        readonly compact: import("@elaraai/east").NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>;
+                readonly axisRight: import("@elaraai/east").StructType<{
+                    readonly label: OptionType<StringType>;
+                    readonly numTicks: OptionType<FloatType>;
+                    readonly hideTicks: OptionType<BooleanType>;
+                    readonly hideLine: OptionType<BooleanType>;
+                    readonly domain: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: import("@elaraai/east").StructType<{
+                            readonly min: FloatType;
+                            readonly max: FloatType;
+                        }>;
+                        readonly time: import("@elaraai/east").StructType<{
+                            readonly min: DateTimeType;
+                            readonly max: DateTimeType;
+                        }>;
+                    }>>;
+                    readonly tickFormat: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: import("@elaraai/east").NullType;
+                        readonly currency: import("@elaraai/east").StructType<{
+                            readonly code: StringType;
+                            readonly compact: BooleanType;
+                        }>;
+                        readonly percent: import("@elaraai/east").NullType;
+                        readonly compact: import("@elaraai/east").NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>;
+                readonly gridRows: import("@elaraai/east").StructType<{
+                    readonly numTicks: OptionType<FloatType>;
+                    readonly dashArray: OptionType<StringType>;
+                }>;
+                readonly gridColumns: import("@elaraai/east").StructType<{
+                    readonly numTicks: OptionType<FloatType>;
+                    readonly dashArray: OptionType<StringType>;
+                }>;
+                readonly series: import("@elaraai/east").StructType<{
+                    readonly data: ArrayType<import("@elaraai/east").StructType<{
+                        readonly key: StringType;
+                        readonly color: StringType;
+                        readonly points: ArrayType<import("@elaraai/east").StructType<{
+                            readonly x: import("@elaraai/east").VariantType<{
+                                readonly category: StringType;
+                                readonly number: FloatType;
+                                readonly time: DateTimeType;
+                            }>;
+                            readonly value: FloatType;
+                            readonly size: OptionType<FloatType>;
+                        }>>;
+                    }>>;
+                    readonly mark: import("@elaraai/east").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;
+                    }>;
+                    readonly curve: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                        readonly none: import("@elaraai/east").NullType;
+                        readonly expand: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly axis: OptionType<import("@elaraai/east").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>;
+                }>;
+            }>>;
+            readonly XCoord: import("@elaraai/east").VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: DateTimeType;
+            }>;
+            readonly Domain: import("@elaraai/east").VariantType<{
+                readonly number: import("@elaraai/east").StructType<{
+                    readonly min: FloatType;
+                    readonly max: FloatType;
+                }>;
+                readonly time: import("@elaraai/east").StructType<{
+                    readonly min: DateTimeType;
+                    readonly max: DateTimeType;
+                }>;
+            }>;
+            readonly Point: import("@elaraai/east").StructType<{
+                readonly x: import("@elaraai/east").VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: DateTimeType;
+                }>;
+                readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
+            }>;
+            readonly Series: import("@elaraai/east").StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                }>>;
+            }>;
+            readonly SeriesArray: ArrayType<import("@elaraai/east").StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                }>>;
+            }>>;
+            readonly BandPoint: import("@elaraai/east").StructType<{
+                readonly x: import("@elaraai/east").VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: DateTimeType;
+                }>;
+                readonly low: FloatType;
+                readonly high: FloatType;
+            }>;
+            readonly BandSeries: import("@elaraai/east").StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly low: FloatType;
+                    readonly high: FloatType;
+                }>>;
+            }>;
+            readonly BandSeriesArray: ArrayType<import("@elaraai/east").StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly low: FloatType;
+                    readonly high: FloatType;
+                }>>;
+            }>>;
+            readonly Scale: import("@elaraai/east").VariantType<{
+                readonly band: import("@elaraai/east").NullType;
+                readonly linear: import("@elaraai/east").NullType;
+                readonly time: import("@elaraai/east").NullType;
+            }>;
+            readonly TickFormat: import("@elaraai/east").VariantType<{
+                readonly number: import("@elaraai/east").NullType;
+                readonly currency: import("@elaraai/east").StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: import("@elaraai/east").NullType;
+                readonly compact: import("@elaraai/east").NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>;
+            readonly Curve: import("@elaraai/east").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 Mark: import("@elaraai/east").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;
+            }>;
+            readonly StackOffset: import("@elaraai/east").VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly expand: import("@elaraai/east").NullType;
+            }>;
+            readonly YAxisSide: import("@elaraai/east").VariantType<{
+                readonly left: import("@elaraai/east").NullType;
+                readonly right: import("@elaraai/east").NullType;
+            }>;
+            readonly Anchor: import("@elaraai/east").VariantType<{
+                readonly start: import("@elaraai/east").NullType;
+                readonly middle: import("@elaraai/east").NullType;
+                readonly end: import("@elaraai/east").NullType;
+            }>;
+            readonly Margin: import("@elaraai/east").StructType<{
+                readonly top: FloatType;
+                readonly right: FloatType;
+                readonly bottom: FloatType;
+                readonly left: FloatType;
+            }>;
+            readonly Axis: import("@elaraai/east").StructType<{
+                readonly label: OptionType<StringType>;
+                readonly numTicks: OptionType<FloatType>;
+                readonly hideTicks: OptionType<BooleanType>;
+                readonly hideLine: OptionType<BooleanType>;
+                readonly domain: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: import("@elaraai/east").StructType<{
+                        readonly min: FloatType;
+                        readonly max: FloatType;
+                    }>;
+                    readonly time: import("@elaraai/east").StructType<{
+                        readonly min: DateTimeType;
+                        readonly max: DateTimeType;
+                    }>;
+                }>>;
+                readonly tickFormat: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: import("@elaraai/east").NullType;
+                    readonly currency: import("@elaraai/east").StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: import("@elaraai/east").NullType;
+                    readonly compact: import("@elaraai/east").NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+            }>;
+            readonly Grid: import("@elaraai/east").StructType<{
+                readonly numTicks: OptionType<FloatType>;
+                readonly dashArray: OptionType<StringType>;
+            }>;
+            readonly LinePath: import("@elaraai/east").StructType<{
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                }>>;
+                readonly stroke: StringType;
+                readonly strokeWidth: OptionType<FloatType>;
+                readonly curve: OptionType<import("@elaraai/east").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 dashArray: OptionType<StringType>;
+                readonly opacity: OptionType<FloatType>;
+            }>;
+            readonly Area: import("@elaraai/east").StructType<{
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                }>>;
+                readonly fill: StringType;
+                readonly fillOpacity: OptionType<FloatType>;
+                readonly stroke: OptionType<StringType>;
+                readonly strokeWidth: OptionType<FloatType>;
+                readonly curve: OptionType<import("@elaraai/east").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 BandArea: import("@elaraai/east").StructType<{
+                readonly data: ArrayType<import("@elaraai/east").StructType<{
+                    readonly key: StringType;
+                    readonly color: StringType;
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
+                        readonly x: import("@elaraai/east").VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly low: FloatType;
+                        readonly high: FloatType;
+                    }>>;
+                }>>;
+                readonly curve: OptionType<import("@elaraai/east").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: import("@elaraai/east").StructType<{
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                }>>;
+                readonly fill: StringType;
+                readonly fillOpacity: OptionType<FloatType>;
+                readonly radius: OptionType<FloatType>;
+            }>;
+            readonly Points: import("@elaraai/east").StructType<{
+                readonly points: ArrayType<import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                }>>;
+                readonly fill: StringType;
+                readonly radius: OptionType<FloatType>;
+                readonly stroke: OptionType<StringType>;
+                readonly strokeWidth: OptionType<FloatType>;
+            }>;
+            readonly Rule: import("@elaraai/east").StructType<{
+                readonly axis: import("@elaraai/east").VariantType<{
+                    readonly x: import("@elaraai/east").NullType;
+                    readonly y: import("@elaraai/east").NullType;
+                }>;
+                readonly at: StringType;
+                readonly stroke: StringType;
+                readonly dashArray: OptionType<StringType>;
+            }>;
+            readonly ReferenceDot: import("@elaraai/east").StructType<{
+                readonly x: import("@elaraai/east").VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: 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: import("@elaraai/east").StructType<{
+                readonly x1: OptionType<import("@elaraai/east").VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: DateTimeType;
+                }>>;
+                readonly x2: OptionType<import("@elaraai/east").VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: 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: import("@elaraai/east").StructType<{
+                readonly point: import("@elaraai/east").StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                }>;
+                readonly text: StringType;
+                readonly anchor: OptionType<import("@elaraai/east").VariantType<{
+                    readonly start: import("@elaraai/east").NullType;
+                    readonly middle: import("@elaraai/east").NullType;
+                    readonly end: import("@elaraai/east").NullType;
+                }>>;
+                readonly fill: OptionType<StringType>;
+                readonly fontSize: OptionType<FloatType>;
+                readonly fontWeight: OptionType<FloatType>;
+            }>;
+            readonly SeriesMark: import("@elaraai/east").StructType<{
+                readonly data: ArrayType<import("@elaraai/east").StructType<{
+                    readonly key: StringType;
+                    readonly color: StringType;
+                    readonly points: ArrayType<import("@elaraai/east").StructType<{
+                        readonly x: import("@elaraai/east").VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                    }>>;
+                }>>;
+                readonly mark: import("@elaraai/east").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;
+                }>;
+                readonly curve: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                    readonly none: import("@elaraai/east").NullType;
+                    readonly expand: import("@elaraai/east").NullType;
+                }>>;
+                readonly axis: OptionType<import("@elaraai/east").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>;
+            }>;
+            readonly Legend: import("@elaraai/east").StructType<{
+                readonly orientation: OptionType<import("@elaraai/east").VariantType<{
+                    readonly horizontal: import("@elaraai/east").NullType;
+                    readonly vertical: import("@elaraai/east").NullType;
+                }>>;
+                readonly position: OptionType<import("@elaraai/east").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 LegendOrientation: import("@elaraai/east").VariantType<{
+                readonly horizontal: import("@elaraai/east").NullType;
+                readonly vertical: import("@elaraai/east").NullType;
+            }>;
+            readonly LegendPosition: import("@elaraai/east").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 Tooltip: import("@elaraai/east").StructType<{
+                readonly cursor: OptionType<import("@elaraai/east").VariantType<{
+                    readonly none: import("@elaraai/east").NullType;
+                    readonly line: import("@elaraai/east").NullType;
+                    readonly fill: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly TooltipCursor: import("@elaraai/east").VariantType<{
+                readonly none: import("@elaraai/east").NullType;
+                readonly line: import("@elaraai/east").NullType;
+                readonly fill: import("@elaraai/east").NullType;
+            }>;
+        };
+    };
+};
+export {};
+//# sourceMappingURL=index.d.ts.map