@elaraai/east-ui 1.0.85 → 1.0.87

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

@@ -1,2490 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/**
- * The Plan's resolved UIComponent-coupled IR — since the data-interface
- * redesign only the ROOT and the review config touch `UIComponentType`; the
- * whole row vocabulary (elements, kinds, rows) is pure data in `./types.ts`.
- * These are the named twins of the `Plan` arm in `component.ts`, which spells
- * the SAME shapes inline with the recursion `node`. The renderer decodes the
- * arm's values through {@link PlanRootType}, so the two must be one East
- * type: `test/collections/plan.spec.ts` compares them as East type values,
- * and a field (or a field type) on only one side fails it.
- *
- * @packageDocumentation
- */
-import { ArrayType, FunctionType, NullType, OptionType, StringType, StructType } from "@elaraai/east";
-import { PlanEditingType } from "./types.js";
-/**
- * The Plan's review chrome (#880) — the decision column's header, the foot's
- * summary and its Rerun.
- *
- * @remarks
- * A verdict is a GESTURE of the root's editing session: the series whose rows
- * are reviewed names the field it writes (`review.verdict`), Approve / Reject
- * on a row and Approve all / Reject all over the canvas draft the entries,
- * and Apply sends them as one checked batch. So the chrome carries no verdict
- * callbacks — the shared contract's (`reviewType`) stay with Table, Roster
- * and Board until they adopt a session. Rerun changes no data, so it stays a
- * callback.
- *
- * @property columnLabel - The decision column's header (`"Decision"` by default)
- * @property summary - The foot's eyebrow — a host-composed component
- * @property onRerun - The Rerun verb (absent ⇒ no Rerun button)
- * @property rerunLabel - The Rerun button's label (`"Rerun"` by default)
- */
-export declare const PlanReviewType: StructType<{
-    readonly columnLabel: StringType;
-    readonly summary: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
-    readonly onRerun: OptionType<FunctionType<[], NullType>>;
-    readonly rerunLabel: StringType;
-}>;
-/** Type alias for {@link PlanReviewType}. */
-export type PlanReviewType = typeof PlanReviewType;
-/**
- * The Plan root IR — the whole canvas.
- *
- * @remarks
- * Window and resolution deliberately have **no callbacks**: they are slice
- * writes (`setRange` / `setResolution`) — hosts observe the slice. Row
- * order is data (no sort callback), and element detail lives in the root
- * RESOLVERS: `popover` / `hover` over {@link PlanElementRefType} (a `none`
- * result opens nothing) and `expandRender` over the row ref (the R2
- * developer render for rows declaring `expand`, over the row's id) — one stored function per
- * surface instead of UI embedded per element. A click on any element reports
- * to ONE callback over the same ref (`onElementClick`, #824), and the
- * interaction state a host wants to hold — selection, collapse, charts, a row
- * to bring into view — rides a bound `ui` state.
- */
-export declare const PlanRootType: StructType<{
-    readonly rows: import("../../index.js").RowSourceType<ArrayType<StructType<{
-        readonly fixed: import("@elaraai/east").BooleanType;
-        readonly parent: OptionType<import("@elaraai/east").VariantType<{
-            readonly entry: StructType<{
-                readonly series: StringType;
-                readonly path: ArrayType<StringType>;
-            }>;
-            readonly section: StructType<{
-                readonly series: StringType;
-                readonly path: ArrayType<StringType>;
-            }>;
-        }>>;
-        readonly rows: ArrayType<StructType<{
-            readonly id: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly parent: OptionType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly gutter: StructType<{
-                readonly label: StringType;
-                readonly id: import("@elaraai/east").BooleanType;
-                readonly sub: OptionType<StringType>;
-                readonly value: OptionType<StringType>;
-                readonly meta: OptionType<StringType>;
-                readonly stacked: import("@elaraai/east").BooleanType;
-                readonly swatches: ArrayType<StructType<{
-                    readonly color: StringType;
-                    readonly label: StringType;
-                }>>;
-            }>;
-            readonly kind: import("@elaraai/east").VariantType<{
-                readonly group: StructType<{
-                    readonly summary: import("@elaraai/east").VariantType<{
-                        readonly none: NullType;
-                        readonly cells: import("@elaraai/east").VariantType<{
-                            readonly heat: StructType<{
-                                readonly cells: ArrayType<StructType<{
-                                    readonly at: import("@elaraai/east").VariantType<{
-                                        readonly time: import("@elaraai/east").DateTimeType;
-                                        readonly number: import("@elaraai/east").FloatType;
-                                        readonly ordinal: StringType;
-                                    }>;
-                                    readonly value: OptionType<import("@elaraai/east").FloatType>;
-                                    readonly label: OptionType<StringType>;
-                                }>>;
-                                readonly scale: StructType<{
-                                    readonly min: OptionType<import("@elaraai/east").FloatType>;
-                                    readonly max: OptionType<import("@elaraai/east").FloatType>;
-                                    readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                                }>;
-                                readonly fold: import("@elaraai/east").VariantType<{
-                                    readonly sum: NullType;
-                                    readonly mean: NullType;
-                                    readonly min: NullType;
-                                    readonly max: NullType;
-                                    readonly last: NullType;
-                                    readonly count: NullType;
-                                }>;
-                                readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                            }>;
-                            readonly weight: StructType<{
-                                readonly cells: ArrayType<StructType<{
-                                    readonly at: import("@elaraai/east").VariantType<{
-                                        readonly time: import("@elaraai/east").DateTimeType;
-                                        readonly number: import("@elaraai/east").FloatType;
-                                        readonly ordinal: StringType;
-                                    }>;
-                                    readonly fraction: import("@elaraai/east").FloatType;
-                                    readonly planned: import("@elaraai/east").BooleanType;
-                                }>>;
-                                readonly fold: import("@elaraai/east").VariantType<{
-                                    readonly sum: NullType;
-                                    readonly mean: NullType;
-                                    readonly min: NullType;
-                                    readonly max: NullType;
-                                    readonly last: NullType;
-                                    readonly count: NullType;
-                                }>;
-                                readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                            }>;
-                            readonly segments: StructType<{
-                                readonly cells: ArrayType<StructType<{
-                                    readonly at: import("@elaraai/east").VariantType<{
-                                        readonly time: import("@elaraai/east").DateTimeType;
-                                        readonly number: import("@elaraai/east").FloatType;
-                                        readonly ordinal: StringType;
-                                    }>;
-                                    readonly segments: ArrayType<StructType<{
-                                        readonly fill: import("@elaraai/east").VariantType<{
-                                            readonly brand: NullType;
-                                            readonly success: NullType;
-                                            readonly warning: NullType;
-                                            readonly danger: NullType;
-                                            readonly info: NullType;
-                                            readonly neutral: NullType;
-                                            readonly slack: NullType;
-                                            readonly free: NullType;
-                                        }>;
-                                        readonly weight: import("@elaraai/east").FloatType;
-                                        readonly label: OptionType<StringType>;
-                                    }>>;
-                                }>>;
-                                readonly fold: import("@elaraai/east").VariantType<{
-                                    readonly sum: NullType;
-                                    readonly mean: NullType;
-                                    readonly min: NullType;
-                                    readonly max: NullType;
-                                    readonly last: NullType;
-                                    readonly count: NullType;
-                                }>;
-                                readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                            }>;
-                        }>;
-                        readonly aggregate: import("@elaraai/east").VariantType<{
-                            readonly mean: NullType;
-                            readonly max: NullType;
-                            readonly sum: NullType;
-                        }>;
-                    }>;
-                }>;
-                readonly span: StructType<{
-                    readonly runs: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly start: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly end: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly label: StringType;
-                        readonly quantity: OptionType<StructType<{
-                            readonly value: import("@elaraai/east").FloatType;
-                            readonly unit: OptionType<StringType>;
-                            readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                            readonly text: OptionType<StringType>;
-                        }>>;
-                        readonly state: import("@elaraai/east").VariantType<{
-                            readonly estimated: NullType;
-                            readonly proposed: import("@elaraai/east").VariantType<{
-                                readonly added: NullType;
-                                readonly recommended: NullType;
-                                readonly removed: NullType;
-                            }>;
-                            readonly confirmed: NullType;
-                            readonly "in-progress": NullType;
-                            readonly actual: NullType;
-                            readonly rejected: NullType;
-                        }>;
-                        readonly status: OptionType<import("@elaraai/east").VariantType<{
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                            readonly info: NullType;
-                            readonly neutral: NullType;
-                        }>>;
-                        readonly moved: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly icon: OptionType<StructType<{
-                            readonly name: StringType;
-                            readonly prefix: StringType;
-                            readonly label: OptionType<StringType>;
-                            readonly style: OptionType<StructType<{
-                                readonly size: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly xs: NullType;
-                                    readonly sm: NullType;
-                                    readonly md: NullType;
-                                    readonly lg: NullType;
-                                    readonly xl: NullType;
-                                    readonly "2xl": NullType;
-                                }>>;
-                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly solid: NullType;
-                                    readonly regular: NullType;
-                                    readonly light: NullType;
-                                    readonly thin: NullType;
-                                    readonly brands: NullType;
-                                }>>;
-                                readonly color: OptionType<StringType>;
-                                readonly background: OptionType<StringType>;
-                                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly brand: NullType;
-                                    readonly gray: NullType;
-                                    readonly red: NullType;
-                                    readonly orange: NullType;
-                                    readonly yellow: NullType;
-                                    readonly green: NullType;
-                                    readonly teal: NullType;
-                                    readonly blue: NullType;
-                                    readonly cyan: NullType;
-                                    readonly purple: NullType;
-                                    readonly pink: NullType;
-                                    readonly success: NullType;
-                                    readonly warning: NullType;
-                                    readonly danger: NullType;
-                                    readonly info: NullType;
-                                    readonly neutral: NullType;
-                                }>>;
-                                readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                                readonly borderRadius: OptionType<StringType>;
-                                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly width: OptionType<StringType>;
-                                readonly height: OptionType<StringType>;
-                                readonly minWidth: OptionType<StringType>;
-                                readonly minHeight: OptionType<StringType>;
-                                readonly maxWidth: OptionType<StringType>;
-                                readonly maxHeight: OptionType<StringType>;
-                                readonly padding: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                                readonly margin: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                            }>>;
-                        }>>;
-                    }>>;
-                    readonly decisions: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly applied: import("@elaraai/east").BooleanType;
-                    }>>;
-                    readonly ports: ArrayType<StructType<{
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                    readonly rollup: OptionType<import("@elaraai/east").VariantType<{
-                        readonly union: NullType;
-                        readonly byStatus: NullType;
-                        readonly sum: NullType;
-                    }>>;
-                }>;
-                readonly buckets: StructType<{
-                    readonly lanes: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                    readonly events: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly lane: OptionType<StringType>;
-                        readonly label: OptionType<StringType>;
-                        readonly icon: OptionType<StructType<{
-                            readonly name: StringType;
-                            readonly prefix: StringType;
-                            readonly label: OptionType<StringType>;
-                            readonly style: OptionType<StructType<{
-                                readonly size: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly xs: NullType;
-                                    readonly sm: NullType;
-                                    readonly md: NullType;
-                                    readonly lg: NullType;
-                                    readonly xl: NullType;
-                                    readonly "2xl": NullType;
-                                }>>;
-                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly solid: NullType;
-                                    readonly regular: NullType;
-                                    readonly light: NullType;
-                                    readonly thin: NullType;
-                                    readonly brands: NullType;
-                                }>>;
-                                readonly color: OptionType<StringType>;
-                                readonly background: OptionType<StringType>;
-                                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly brand: NullType;
-                                    readonly gray: NullType;
-                                    readonly red: NullType;
-                                    readonly orange: NullType;
-                                    readonly yellow: NullType;
-                                    readonly green: NullType;
-                                    readonly teal: NullType;
-                                    readonly blue: NullType;
-                                    readonly cyan: NullType;
-                                    readonly purple: NullType;
-                                    readonly pink: NullType;
-                                    readonly success: NullType;
-                                    readonly warning: NullType;
-                                    readonly danger: NullType;
-                                    readonly info: NullType;
-                                    readonly neutral: NullType;
-                                }>>;
-                                readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                                readonly borderRadius: OptionType<StringType>;
-                                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly width: OptionType<StringType>;
-                                readonly height: OptionType<StringType>;
-                                readonly minWidth: OptionType<StringType>;
-                                readonly minHeight: OptionType<StringType>;
-                                readonly maxWidth: OptionType<StringType>;
-                                readonly maxHeight: OptionType<StringType>;
-                                readonly padding: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                                readonly margin: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                            }>>;
-                        }>>;
-                        readonly state: import("@elaraai/east").VariantType<{
-                            readonly estimated: NullType;
-                            readonly proposed: import("@elaraai/east").VariantType<{
-                                readonly added: NullType;
-                                readonly recommended: NullType;
-                                readonly removed: NullType;
-                            }>;
-                            readonly confirmed: NullType;
-                            readonly "in-progress": NullType;
-                            readonly actual: NullType;
-                            readonly rejected: NullType;
-                        }>;
-                        readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                            readonly info: NullType;
-                            readonly neutral: NullType;
-                        }>>;
-                        readonly color: OptionType<StringType>;
-                        readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: NullType;
-                            readonly gray: NullType;
-                            readonly red: NullType;
-                            readonly orange: NullType;
-                            readonly yellow: NullType;
-                            readonly green: NullType;
-                            readonly teal: NullType;
-                            readonly blue: NullType;
-                            readonly cyan: NullType;
-                            readonly purple: NullType;
-                            readonly pink: NullType;
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                            readonly info: NullType;
-                            readonly neutral: NullType;
-                        }>>;
-                        readonly stretch: OptionType<import("@elaraai/east").VariantType<{
-                            readonly horizontal: NullType;
-                            readonly vertical: NullType;
-                            readonly both: NullType;
-                        }>>;
-                        readonly content: OptionType<StructType<{
-                            readonly horizontal: OptionType<import("@elaraai/east").VariantType<{
-                                readonly start: NullType;
-                                readonly center: NullType;
-                                readonly end: NullType;
-                            }>>;
-                            readonly vertical: OptionType<import("@elaraai/east").VariantType<{
-                                readonly start: NullType;
-                                readonly center: NullType;
-                                readonly end: NullType;
-                            }>>;
-                        }>>;
-                        readonly animation: OptionType<import("@elaraai/east").VariantType<{
-                            readonly none: NullType;
-                            readonly pulse: NullType;
-                        }>>;
-                    }>>;
-                    readonly markers: ArrayType<StructType<{
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly lane: OptionType<StringType>;
-                        readonly status: import("@elaraai/east").VariantType<{
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                            readonly info: NullType;
-                            readonly neutral: NullType;
-                        }>;
-                        readonly message: StringType;
-                    }>>;
-                }>;
-                readonly chart: StructType<{
-                    readonly layers: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly line: StructType<{
-                            readonly points: ArrayType<StructType<{
-                                readonly t: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly y: import("@elaraai/east").FloatType;
-                            }>>;
-                            readonly axis: import("@elaraai/east").VariantType<{
-                                readonly left: NullType;
-                                readonly right: NullType;
-                            }>;
-                            readonly breach: OptionType<import("@elaraai/east").VariantType<{
-                                readonly above: import("@elaraai/east").FloatType;
-                                readonly below: import("@elaraai/east").FloatType;
-                            }>>;
-                            readonly fold: import("@elaraai/east").VariantType<{
-                                readonly sum: NullType;
-                                readonly mean: NullType;
-                                readonly min: NullType;
-                                readonly max: NullType;
-                                readonly last: NullType;
-                                readonly count: NullType;
-                            }>;
-                        }>;
-                        readonly area: StructType<{
-                            readonly points: ArrayType<StructType<{
-                                readonly t: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly y: import("@elaraai/east").FloatType;
-                            }>>;
-                            readonly axis: import("@elaraai/east").VariantType<{
-                                readonly left: NullType;
-                                readonly right: NullType;
-                            }>;
-                            readonly fold: import("@elaraai/east").VariantType<{
-                                readonly sum: NullType;
-                                readonly mean: NullType;
-                                readonly min: NullType;
-                                readonly max: NullType;
-                                readonly last: NullType;
-                                readonly count: NullType;
-                            }>;
-                        }>;
-                        readonly column: StructType<{
-                            readonly points: ArrayType<StructType<{
-                                readonly t: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly y: import("@elaraai/east").FloatType;
-                            }>>;
-                            readonly axis: import("@elaraai/east").VariantType<{
-                                readonly left: NullType;
-                                readonly right: NullType;
-                            }>;
-                            readonly series: OptionType<StringType>;
-                            readonly breach: OptionType<import("@elaraai/east").VariantType<{
-                                readonly above: import("@elaraai/east").FloatType;
-                                readonly below: import("@elaraai/east").FloatType;
-                            }>>;
-                            readonly fold: import("@elaraai/east").VariantType<{
-                                readonly sum: NullType;
-                                readonly mean: NullType;
-                                readonly min: NullType;
-                                readonly max: NullType;
-                                readonly last: NullType;
-                                readonly count: NullType;
-                            }>;
-                        }>;
-                        readonly scatter: StructType<{
-                            readonly points: ArrayType<StructType<{
-                                readonly t: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly y: import("@elaraai/east").FloatType;
-                            }>>;
-                            readonly axis: import("@elaraai/east").VariantType<{
-                                readonly left: NullType;
-                                readonly right: NullType;
-                            }>;
-                        }>;
-                        readonly band: StructType<{
-                            readonly points: ArrayType<StructType<{
-                                readonly t: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly lo: import("@elaraai/east").FloatType;
-                                readonly hi: import("@elaraai/east").FloatType;
-                            }>>;
-                            readonly axis: import("@elaraai/east").VariantType<{
-                                readonly left: NullType;
-                                readonly right: NullType;
-                            }>;
-                        }>;
-                        readonly refLine: StructType<{
-                            readonly y: import("@elaraai/east").FloatType;
-                            readonly axis: import("@elaraai/east").VariantType<{
-                                readonly left: NullType;
-                                readonly right: NullType;
-                            }>;
-                            readonly label: OptionType<StringType>;
-                        }>;
-                        readonly refBand: StructType<{
-                            readonly from: import("@elaraai/east").VariantType<{
-                                readonly time: import("@elaraai/east").DateTimeType;
-                                readonly number: import("@elaraai/east").FloatType;
-                                readonly ordinal: StringType;
-                            }>;
-                            readonly to: import("@elaraai/east").VariantType<{
-                                readonly time: import("@elaraai/east").DateTimeType;
-                                readonly number: import("@elaraai/east").FloatType;
-                                readonly ordinal: StringType;
-                            }>;
-                            readonly label: OptionType<StringType>;
-                        }>;
-                        readonly refDot: StructType<{
-                            readonly t: import("@elaraai/east").VariantType<{
-                                readonly time: import("@elaraai/east").DateTimeType;
-                                readonly number: import("@elaraai/east").FloatType;
-                                readonly ordinal: StringType;
-                            }>;
-                            readonly y: import("@elaraai/east").FloatType;
-                            readonly axis: import("@elaraai/east").VariantType<{
-                                readonly left: NullType;
-                                readonly right: NullType;
-                            }>;
-                            readonly label: OptionType<StringType>;
-                        }>;
-                    }>>;
-                    readonly left: OptionType<StructType<{
-                        readonly domain: OptionType<import("@elaraai/east").VariantType<{
-                            readonly number: StructType<{
-                                readonly min: import("@elaraai/east").FloatType;
-                                readonly max: import("@elaraai/east").FloatType;
-                            }>;
-                            readonly time: StructType<{
-                                readonly min: import("@elaraai/east").DateTimeType;
-                                readonly max: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>>;
-                        readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                            readonly number: ArrayType<import("@elaraai/east").FloatType>;
-                            readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
-                        }>>;
-                        readonly format: OptionType<import("@elaraai/east").VariantType<{
-                            readonly number: NullType;
-                            readonly currency: StructType<{
-                                readonly code: StringType;
-                                readonly compact: import("@elaraai/east").BooleanType;
-                            }>;
-                            readonly percent: NullType;
-                            readonly compact: NullType;
-                            readonly date: StringType;
-                            readonly time: StringType;
-                            readonly datetime: StringType;
-                        }>>;
-                    }>>;
-                    readonly right: OptionType<StructType<{
-                        readonly domain: OptionType<import("@elaraai/east").VariantType<{
-                            readonly number: StructType<{
-                                readonly min: import("@elaraai/east").FloatType;
-                                readonly max: import("@elaraai/east").FloatType;
-                            }>;
-                            readonly time: StructType<{
-                                readonly min: import("@elaraai/east").DateTimeType;
-                                readonly max: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>>;
-                        readonly tickValues: OptionType<import("@elaraai/east").VariantType<{
-                            readonly number: ArrayType<import("@elaraai/east").FloatType>;
-                            readonly time: ArrayType<import("@elaraai/east").DateTimeType>;
-                        }>>;
-                        readonly format: OptionType<import("@elaraai/east").VariantType<{
-                            readonly number: NullType;
-                            readonly currency: StructType<{
-                                readonly code: StringType;
-                                readonly compact: import("@elaraai/east").BooleanType;
-                            }>;
-                            readonly percent: NullType;
-                            readonly compact: NullType;
-                            readonly date: StringType;
-                            readonly time: StringType;
-                            readonly datetime: StringType;
-                        }>>;
-                    }>>;
-                    readonly height: import("@elaraai/east").VariantType<{
-                        readonly spark: NullType;
-                        readonly expanded: NullType;
-                        readonly fixed: StringType;
-                    }>;
-                    readonly expandedHeight: OptionType<StringType>;
-                    readonly expandable: import("@elaraai/east").BooleanType;
-                }>;
-                readonly heat: StructType<{
-                    readonly cells: import("@elaraai/east").VariantType<{
-                        readonly heat: StructType<{
-                            readonly cells: ArrayType<StructType<{
-                                readonly at: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly value: OptionType<import("@elaraai/east").FloatType>;
-                                readonly label: OptionType<StringType>;
-                            }>>;
-                            readonly scale: StructType<{
-                                readonly min: OptionType<import("@elaraai/east").FloatType>;
-                                readonly max: OptionType<import("@elaraai/east").FloatType>;
-                                readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                            }>;
-                            readonly fold: import("@elaraai/east").VariantType<{
-                                readonly sum: NullType;
-                                readonly mean: NullType;
-                                readonly min: NullType;
-                                readonly max: NullType;
-                                readonly last: NullType;
-                                readonly count: NullType;
-                            }>;
-                            readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                        }>;
-                        readonly weight: StructType<{
-                            readonly cells: ArrayType<StructType<{
-                                readonly at: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly fraction: import("@elaraai/east").FloatType;
-                                readonly planned: import("@elaraai/east").BooleanType;
-                            }>>;
-                            readonly fold: import("@elaraai/east").VariantType<{
-                                readonly sum: NullType;
-                                readonly mean: NullType;
-                                readonly min: NullType;
-                                readonly max: NullType;
-                                readonly last: NullType;
-                                readonly count: NullType;
-                            }>;
-                            readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                        }>;
-                        readonly segments: StructType<{
-                            readonly cells: ArrayType<StructType<{
-                                readonly at: import("@elaraai/east").VariantType<{
-                                    readonly time: import("@elaraai/east").DateTimeType;
-                                    readonly number: import("@elaraai/east").FloatType;
-                                    readonly ordinal: StringType;
-                                }>;
-                                readonly segments: ArrayType<StructType<{
-                                    readonly fill: import("@elaraai/east").VariantType<{
-                                        readonly brand: NullType;
-                                        readonly success: NullType;
-                                        readonly warning: NullType;
-                                        readonly danger: NullType;
-                                        readonly info: NullType;
-                                        readonly neutral: NullType;
-                                        readonly slack: NullType;
-                                        readonly free: NullType;
-                                    }>;
-                                    readonly weight: import("@elaraai/east").FloatType;
-                                    readonly label: OptionType<StringType>;
-                                }>>;
-                            }>>;
-                            readonly fold: import("@elaraai/east").VariantType<{
-                                readonly sum: NullType;
-                                readonly mean: NullType;
-                                readonly min: NullType;
-                                readonly max: NullType;
-                                readonly last: NullType;
-                                readonly count: NullType;
-                            }>;
-                            readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                        }>;
-                    }>;
-                    readonly aggregate: OptionType<import("@elaraai/east").VariantType<{
-                        readonly mean: NullType;
-                        readonly max: NullType;
-                        readonly sum: NullType;
-                    }>>;
-                    readonly scale: OptionType<StructType<{
-                        readonly min: OptionType<import("@elaraai/east").FloatType>;
-                        readonly max: OptionType<import("@elaraai/east").FloatType>;
-                        readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
-                    }>>;
-                }>;
-                readonly table: StructType<{
-                    readonly series: ArrayType<StructType<{
-                        readonly cells: ArrayType<StructType<{
-                            readonly at: import("@elaraai/east").VariantType<{
-                                readonly time: import("@elaraai/east").DateTimeType;
-                                readonly number: import("@elaraai/east").FloatType;
-                                readonly ordinal: StringType;
-                            }>;
-                            readonly value: OptionType<import("@elaraai/east").FloatType>;
-                            readonly text: OptionType<StringType>;
-                            readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                                readonly neg: NullType;
-                                readonly muted: NullType;
-                            }>>;
-                        }>>;
-                        readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                        readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                            readonly neg: NullType;
-                            readonly muted: NullType;
-                        }>>;
-                        readonly strong: import("@elaraai/east").BooleanType;
-                        readonly rollup: import("@elaraai/east").BooleanType;
-                        readonly fold: import("@elaraai/east").VariantType<{
-                            readonly sum: NullType;
-                            readonly mean: NullType;
-                            readonly min: NullType;
-                            readonly max: NullType;
-                            readonly last: NullType;
-                            readonly count: NullType;
-                        }>;
-                    }>>;
-                    readonly split: import("@elaraai/east").VariantType<{
-                        readonly horizontal: NullType;
-                        readonly vertical: NullType;
-                    }>;
-                    readonly aggregate: OptionType<import("@elaraai/east").VariantType<{
-                        readonly sum: NullType;
-                        readonly mean: NullType;
-                        readonly min: NullType;
-                        readonly max: NullType;
-                        readonly count: NullType;
-                    }>>;
-                    readonly format: OptionType<import("../../internal.js").TickFormatType>;
-                    readonly emphasis: import("@elaraai/east").VariantType<{
-                        readonly body: NullType;
-                        readonly header: NullType;
-                        readonly footer: NullType;
-                    }>;
-                }>;
-                readonly cards: StructType<{
-                    readonly chips: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly from: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly to: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly label: StringType;
-                        readonly state: import("@elaraai/east").VariantType<{
-                            readonly estimated: NullType;
-                            readonly proposed: import("@elaraai/east").VariantType<{
-                                readonly added: NullType;
-                                readonly recommended: NullType;
-                                readonly removed: NullType;
-                            }>;
-                            readonly confirmed: NullType;
-                            readonly "in-progress": NullType;
-                            readonly actual: NullType;
-                            readonly rejected: NullType;
-                        }>;
-                        readonly icon: OptionType<StructType<{
-                            readonly name: StringType;
-                            readonly prefix: StringType;
-                            readonly label: OptionType<StringType>;
-                            readonly style: OptionType<StructType<{
-                                readonly size: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly xs: NullType;
-                                    readonly sm: NullType;
-                                    readonly md: NullType;
-                                    readonly lg: NullType;
-                                    readonly xl: NullType;
-                                    readonly "2xl": NullType;
-                                }>>;
-                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly solid: NullType;
-                                    readonly regular: NullType;
-                                    readonly light: NullType;
-                                    readonly thin: NullType;
-                                    readonly brands: NullType;
-                                }>>;
-                                readonly color: OptionType<StringType>;
-                                readonly background: OptionType<StringType>;
-                                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly brand: NullType;
-                                    readonly gray: NullType;
-                                    readonly red: NullType;
-                                    readonly orange: NullType;
-                                    readonly yellow: NullType;
-                                    readonly green: NullType;
-                                    readonly teal: NullType;
-                                    readonly blue: NullType;
-                                    readonly cyan: NullType;
-                                    readonly purple: NullType;
-                                    readonly pink: NullType;
-                                    readonly success: NullType;
-                                    readonly warning: NullType;
-                                    readonly danger: NullType;
-                                    readonly info: NullType;
-                                    readonly neutral: NullType;
-                                }>>;
-                                readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                                readonly borderRadius: OptionType<StringType>;
-                                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly width: OptionType<StringType>;
-                                readonly height: OptionType<StringType>;
-                                readonly minWidth: OptionType<StringType>;
-                                readonly minHeight: OptionType<StringType>;
-                                readonly maxWidth: OptionType<StringType>;
-                                readonly maxHeight: OptionType<StringType>;
-                                readonly padding: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                                readonly margin: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                            }>>;
-                        }>>;
-                    }>>;
-                }>;
-                readonly events: StructType<{
-                    readonly marks: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: import("@elaraai/east").DateTimeType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                        readonly kind: import("@elaraai/east").VariantType<{
-                            readonly milestone: NullType;
-                            readonly decision: StructType<{
-                                readonly applied: import("@elaraai/east").BooleanType;
-                            }>;
-                            readonly exception: NullType;
-                        }>;
-                        readonly icon: OptionType<StructType<{
-                            readonly name: StringType;
-                            readonly prefix: StringType;
-                            readonly label: OptionType<StringType>;
-                            readonly style: OptionType<StructType<{
-                                readonly size: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly xs: NullType;
-                                    readonly sm: NullType;
-                                    readonly md: NullType;
-                                    readonly lg: NullType;
-                                    readonly xl: NullType;
-                                    readonly "2xl": NullType;
-                                }>>;
-                                readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly solid: NullType;
-                                    readonly regular: NullType;
-                                    readonly light: NullType;
-                                    readonly thin: NullType;
-                                    readonly brands: NullType;
-                                }>>;
-                                readonly color: OptionType<StringType>;
-                                readonly background: OptionType<StringType>;
-                                readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly brand: NullType;
-                                    readonly gray: NullType;
-                                    readonly red: NullType;
-                                    readonly orange: NullType;
-                                    readonly yellow: NullType;
-                                    readonly green: NullType;
-                                    readonly teal: NullType;
-                                    readonly blue: NullType;
-                                    readonly cyan: NullType;
-                                    readonly purple: NullType;
-                                    readonly pink: NullType;
-                                    readonly success: NullType;
-                                    readonly warning: NullType;
-                                    readonly danger: NullType;
-                                    readonly info: NullType;
-                                    readonly neutral: NullType;
-                                }>>;
-                                readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                                readonly borderRadius: OptionType<StringType>;
-                                readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                                    readonly visible: NullType;
-                                    readonly hidden: NullType;
-                                    readonly scroll: NullType;
-                                    readonly auto: NullType;
-                                }>>;
-                                readonly width: OptionType<StringType>;
-                                readonly height: OptionType<StringType>;
-                                readonly minWidth: OptionType<StringType>;
-                                readonly minHeight: OptionType<StringType>;
-                                readonly maxWidth: OptionType<StringType>;
-                                readonly maxHeight: OptionType<StringType>;
-                                readonly padding: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                                readonly margin: OptionType<StructType<{
-                                    readonly top: OptionType<StringType>;
-                                    readonly right: OptionType<StringType>;
-                                    readonly bottom: OptionType<StringType>;
-                                    readonly left: OptionType<StringType>;
-                                }>>;
-                            }>>;
-                        }>>;
-                        readonly label: OptionType<StringType>;
-                    }>>;
-                }>;
-            }>;
-            readonly collapsed: import("@elaraai/east").BooleanType;
-            readonly pinned: import("@elaraai/east").BooleanType;
-            readonly height: OptionType<StringType>;
-            readonly status: OptionType<import("@elaraai/east").VariantType<{
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-                readonly info: NullType;
-                readonly neutral: NullType;
-            }>>;
-            readonly approval: OptionType<import("@elaraai/east").VariantType<{
-                readonly approved: NullType;
-                readonly pending: NullType;
-                readonly rejected: NullType;
-            }>>;
-            readonly expand: OptionType<StructType<{
-                readonly height: OptionType<StringType>;
-                readonly axis: import("@elaraai/east").VariantType<{
-                    readonly keep: NullType;
-                    readonly dim: NullType;
-                    readonly off: NullType;
-                }>;
-            }>>;
-            readonly edits: StructType<{
-                readonly verdict: import("@elaraai/east").BooleanType;
-                readonly drop: import("@elaraai/east").BooleanType;
-                readonly move: OptionType<StructType<{
-                    readonly items: StringType;
-                    readonly resize: import("@elaraai/east").BooleanType;
-                }>>;
-            }>;
-        }>>;
-    }>>>;
-    readonly links: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly from: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly run: StringType;
-        }>;
-        readonly to: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly run: StringType;
-        }>;
-        readonly quantity: OptionType<StructType<{
-            readonly value: import("@elaraai/east").FloatType;
-            readonly unit: OptionType<StringType>;
-            readonly format: OptionType<import("../../internal.js").TickFormatType>;
-            readonly text: OptionType<StringType>;
-        }>>;
-    }>>;
-    readonly axis: import("@elaraai/east").VariantType<{
-        readonly time: StructType<{
-            readonly window: OptionType<StructType<{
-                readonly min: import("@elaraai/east").DateTimeType;
-                readonly max: import("@elaraai/east").DateTimeType;
-            }>>;
-            readonly resolution: import("@elaraai/east").VariantType<{
-                readonly auto: NullType;
-                readonly hour: NullType;
-                readonly day: NullType;
-                readonly week: NullType;
-                readonly month: NullType;
-                readonly quarter: NullType;
-                readonly year: NullType;
-            }>;
-            readonly resolutions: ArrayType<import("@elaraai/east").VariantType<{
-                readonly auto: NullType;
-                readonly hour: NullType;
-                readonly day: NullType;
-                readonly week: NullType;
-                readonly month: NullType;
-                readonly quarter: NullType;
-                readonly year: NullType;
-            }>>;
-            readonly now: OptionType<import("@elaraai/east").DateTimeType>;
-            readonly format: OptionType<StringType>;
-        }>;
-        readonly number: StructType<{
-            readonly window: OptionType<StructType<{
-                readonly min: import("@elaraai/east").FloatType;
-                readonly max: import("@elaraai/east").FloatType;
-            }>>;
-            readonly step: import("@elaraai/east").FloatType;
-            readonly now: OptionType<import("@elaraai/east").FloatType>;
-            readonly format: OptionType<import("@elaraai/east").VariantType<{
-                readonly number: NullType;
-                readonly currency: StructType<{
-                    readonly code: StringType;
-                    readonly compact: import("@elaraai/east").BooleanType;
-                }>;
-                readonly percent: NullType;
-                readonly compact: NullType;
-                readonly date: StringType;
-                readonly time: StringType;
-                readonly datetime: StringType;
-            }>>;
-        }>;
-        readonly ordinal: StructType<{
-            readonly values: ArrayType<StringType>;
-            readonly now: OptionType<StringType>;
-        }>;
-    }>;
-    readonly grain: OptionType<import("@elaraai/east").VariantType<{
-        readonly group: NullType;
-        readonly resource: NullType;
-    }>>;
-    readonly popover: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly run: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly run: StringType;
-        }>;
-        readonly event: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly event: StringType;
-        }>;
-        readonly chip: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly chip: StringType;
-        }>;
-        readonly mark: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly mark: StringType;
-        }>;
-        readonly cell: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly at: import("@elaraai/east").VariantType<{
-                readonly time: import("@elaraai/east").DateTimeType;
-                readonly number: import("@elaraai/east").FloatType;
-                readonly ordinal: StringType;
-            }>;
-        }>;
-        readonly link: StructType<{
-            readonly key: StringType;
-            readonly from: StructType<{
-                readonly row: import("@elaraai/east").VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly run: StringType;
-            }>;
-            readonly to: StructType<{
-                readonly row: import("@elaraai/east").VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly run: StringType;
-            }>;
-        }>;
-    }>], OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>>>;
-    readonly hover: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly run: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly run: StringType;
-        }>;
-        readonly event: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly event: StringType;
-        }>;
-        readonly chip: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly chip: StringType;
-        }>;
-        readonly mark: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly mark: StringType;
-        }>;
-        readonly cell: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly at: import("@elaraai/east").VariantType<{
-                readonly time: import("@elaraai/east").DateTimeType;
-                readonly number: import("@elaraai/east").FloatType;
-                readonly ordinal: StringType;
-            }>;
-        }>;
-        readonly link: StructType<{
-            readonly key: StringType;
-            readonly from: StructType<{
-                readonly row: import("@elaraai/east").VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly run: StringType;
-            }>;
-            readonly to: StructType<{
-                readonly row: import("@elaraai/east").VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly run: StringType;
-            }>;
-        }>;
-    }>], OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>>>;
-    readonly expandRender: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly entry: StructType<{
-            readonly series: StringType;
-            readonly path: ArrayType<StringType>;
-        }>;
-        readonly section: StructType<{
-            readonly series: StringType;
-            readonly path: ArrayType<StringType>;
-        }>;
-    }>], import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>>;
-    readonly expandGutter: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly entry: StructType<{
-            readonly series: StringType;
-            readonly path: ArrayType<StringType>;
-        }>;
-        readonly section: StructType<{
-            readonly series: StringType;
-            readonly path: ArrayType<StringType>;
-        }>;
-    }>], import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>>;
-    readonly review: OptionType<StructType<{
-        readonly columnLabel: StringType;
-        readonly summary: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
-        readonly onRerun: OptionType<FunctionType<[], NullType>>;
-        readonly rerunLabel: StringType;
-    }>>;
-    readonly editing: OptionType<PlanEditingType>;
-    readonly pick: OptionType<StructType<{
-        readonly key: StringType;
-        readonly state: StructType<{
-            readonly read: FunctionType<[], ArrayType<StringType>>;
-            readonly write: FunctionType<[ArrayType<StringType>], NullType>;
-            readonly has: FunctionType<[], import("@elaraai/east").BooleanType>;
-        }>;
-        readonly items: ArrayType<StructType<{
-            readonly id: StringType;
-            readonly title: StringType;
-            readonly subtitle: OptionType<StringType>;
-            readonly icon: OptionType<StructType<{
-                readonly name: StringType;
-                readonly prefix: StringType;
-                readonly label: OptionType<StringType>;
-                readonly style: OptionType<StructType<{
-                    readonly size: OptionType<import("@elaraai/east").VariantType<{
-                        readonly xs: NullType;
-                        readonly sm: NullType;
-                        readonly md: NullType;
-                        readonly lg: NullType;
-                        readonly xl: NullType;
-                        readonly "2xl": NullType;
-                    }>>;
-                    readonly variant: OptionType<import("@elaraai/east").VariantType<{
-                        readonly solid: NullType;
-                        readonly regular: NullType;
-                        readonly light: NullType;
-                        readonly thin: NullType;
-                        readonly brands: NullType;
-                    }>>;
-                    readonly color: OptionType<StringType>;
-                    readonly background: OptionType<StringType>;
-                    readonly colorPalette: OptionType<import("@elaraai/east").VariantType<{
-                        readonly brand: NullType;
-                        readonly gray: NullType;
-                        readonly red: NullType;
-                        readonly orange: NullType;
-                        readonly yellow: NullType;
-                        readonly green: NullType;
-                        readonly teal: NullType;
-                        readonly blue: NullType;
-                        readonly cyan: NullType;
-                        readonly purple: NullType;
-                        readonly pink: NullType;
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>>;
-                    readonly opacity: OptionType<import("@elaraai/east").FloatType>;
-                    readonly borderRadius: OptionType<StringType>;
-                    readonly overflow: OptionType<import("@elaraai/east").VariantType<{
-                        readonly visible: NullType;
-                        readonly hidden: NullType;
-                        readonly scroll: NullType;
-                        readonly auto: NullType;
-                    }>>;
-                    readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
-                        readonly visible: NullType;
-                        readonly hidden: NullType;
-                        readonly scroll: NullType;
-                        readonly auto: NullType;
-                    }>>;
-                    readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
-                        readonly visible: NullType;
-                        readonly hidden: NullType;
-                        readonly scroll: NullType;
-                        readonly auto: NullType;
-                    }>>;
-                    readonly width: OptionType<StringType>;
-                    readonly height: OptionType<StringType>;
-                    readonly minWidth: OptionType<StringType>;
-                    readonly minHeight: OptionType<StringType>;
-                    readonly maxWidth: OptionType<StringType>;
-                    readonly maxHeight: OptionType<StringType>;
-                    readonly padding: OptionType<StructType<{
-                        readonly top: OptionType<StringType>;
-                        readonly right: OptionType<StringType>;
-                        readonly bottom: OptionType<StringType>;
-                        readonly left: OptionType<StringType>;
-                    }>>;
-                    readonly margin: OptionType<StructType<{
-                        readonly top: OptionType<StringType>;
-                        readonly right: OptionType<StringType>;
-                        readonly bottom: OptionType<StringType>;
-                        readonly left: OptionType<StringType>;
-                    }>>;
-                }>>;
-            }>>;
-            readonly count: OptionType<import("@elaraai/east").IntegerType>;
-            readonly narrowed: import("@elaraai/east").BooleanType;
-        }>>;
-    }>>;
-    readonly slice: OptionType<StructType<{
-        readonly slice: StructType<{
-            readonly key: StringType;
-            readonly read: FunctionType<[], StructType<{
-                readonly range: OptionType<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
-                    }>;
-                }>>;
-                readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: 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 startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly lt: import("@elaraai/east").FloatType;
-                            readonly lte: import("@elaraai/east").FloatType;
-                            readonly gt: import("@elaraai/east").FloatType;
-                            readonly gte: import("@elaraai/east").FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: 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 startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly lt: import("@elaraai/east").FloatType;
-                                readonly lte: import("@elaraai/east").FloatType;
-                                readonly gt: import("@elaraai/east").FloatType;
-                                readonly gte: import("@elaraai/east").FloatType;
-                            }>;
-                        }>;
-                        readonly datetime: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: import("@elaraai/east").BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: NullType;
-                    readonly hour: NullType;
-                    readonly day: NullType;
-                    readonly week: NullType;
-                    readonly month: NullType;
-                    readonly quarter: NullType;
-                    readonly year: NullType;
-                }>>;
-            }>>;
-            readonly write: FunctionType<[StructType<{
-                readonly range: OptionType<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
-                    }>;
-                }>>;
-                readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: 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 startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly lt: import("@elaraai/east").FloatType;
-                            readonly lte: import("@elaraai/east").FloatType;
-                            readonly gt: import("@elaraai/east").FloatType;
-                            readonly gte: import("@elaraai/east").FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: 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 startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly lt: import("@elaraai/east").FloatType;
-                                readonly lte: import("@elaraai/east").FloatType;
-                                readonly gt: import("@elaraai/east").FloatType;
-                                readonly gte: import("@elaraai/east").FloatType;
-                            }>;
-                        }>;
-                        readonly datetime: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: import("@elaraai/east").BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: NullType;
-                    readonly hour: NullType;
-                    readonly day: NullType;
-                    readonly week: NullType;
-                    readonly month: NullType;
-                    readonly quarter: NullType;
-                    readonly year: NullType;
-                }>>;
-            }>], NullType>;
-            readonly setRange: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: import("@elaraai/east").VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
-                }>;
-                readonly integer: StructType<{
-                    readonly from: import("@elaraai/east").IntegerType;
-                    readonly to: import("@elaraai/east").IntegerType;
-                }>;
-                readonly float: StructType<{
-                    readonly from: import("@elaraai/east").FloatType;
-                    readonly to: import("@elaraai/east").FloatType;
-                }>;
-            }>>], NullType>;
-            readonly setCompare: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>], NullType>;
-            readonly addFilter: FunctionType<[import("@elaraai/east").VariantType<{
-                readonly string: 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 startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly eq: import("@elaraai/east").IntegerType;
-                        readonly neq: import("@elaraai/east").IntegerType;
-                        readonly lt: import("@elaraai/east").IntegerType;
-                        readonly lte: import("@elaraai/east").IntegerType;
-                        readonly gt: import("@elaraai/east").IntegerType;
-                        readonly gte: import("@elaraai/east").IntegerType;
-                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly lt: import("@elaraai/east").FloatType;
-                        readonly lte: import("@elaraai/east").FloatType;
-                        readonly gt: import("@elaraai/east").FloatType;
-                        readonly gte: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly datetime: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>], NullType>;
-            readonly removeFilter: FunctionType<[import("@elaraai/east").IntegerType], NullType>;
-            readonly clearFilters: FunctionType<[], NullType>;
-            readonly defineCohort: FunctionType<[StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: 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 startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly lt: import("@elaraai/east").FloatType;
-                            readonly lte: import("@elaraai/east").FloatType;
-                            readonly gt: import("@elaraai/east").FloatType;
-                            readonly gte: import("@elaraai/east").FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly group: OptionType<StringType>;
-            }>], NullType>;
-            readonly updateCohort: FunctionType<[StringType, StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: 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 startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly lt: import("@elaraai/east").FloatType;
-                            readonly lte: import("@elaraai/east").FloatType;
-                            readonly gt: import("@elaraai/east").FloatType;
-                            readonly gte: import("@elaraai/east").FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly group: OptionType<StringType>;
-            }>], NullType>;
-            readonly removeCohort: FunctionType<[StringType], NullType>;
-            readonly toggleCohort: FunctionType<[StringType], NullType>;
-            readonly setBreakdown: FunctionType<[OptionType<StructType<{
-                readonly fieldId: StringType;
-                readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-            }>>], NullType>;
-            readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
-            readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
-            readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
-            readonly isActive: FunctionType<[], import("@elaraai/east").BooleanType>;
-            readonly activeCount: FunctionType<[], import("@elaraai/east").IntegerType>;
-            readonly dimensions: FunctionType<[], ArrayType<StructType<{
-                readonly fieldId: StringType;
-                readonly label: StringType;
-            }>>>;
-            readonly fields: FunctionType<[], ArrayType<StructType<{
-                readonly fieldId: StringType;
-                readonly label: StringType;
-                readonly kind: StringType;
-                readonly hints: ArrayType<StringType>;
-                readonly format: OptionType<import("@elaraai/east").VariantType<{
-                    readonly number: NullType;
-                    readonly currency: StructType<{
-                        readonly code: StringType;
-                        readonly compact: import("@elaraai/east").BooleanType;
-                    }>;
-                    readonly percent: NullType;
-                    readonly compact: NullType;
-                    readonly date: StringType;
-                    readonly time: StringType;
-                    readonly datetime: StringType;
-                }>>;
-            }>>>;
-            readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
-            readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
-            readonly totalCount: FunctionType<[], import("@elaraai/east").IntegerType>;
-            readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
-            readonly groups: FunctionType<[], ArrayType<StructType<{
-                readonly key: StringType;
-                readonly count: import("@elaraai/east").IntegerType;
-                readonly color: StringType;
-            }>>>;
-            readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
-                readonly key: StringType;
-                readonly color: StringType;
-                readonly points: ArrayType<StructType<{
-                    readonly x: import("@elaraai/east").VariantType<{
-                        readonly category: StringType;
-                        readonly number: import("@elaraai/east").FloatType;
-                        readonly time: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly value: import("@elaraai/east").FloatType;
-                    readonly size: OptionType<import("@elaraai/east").FloatType>;
-                    readonly color: OptionType<StringType>;
-                }>>;
-            }>>>;
-            readonly matches: FunctionType<[], ArrayType<StructType<{
-                readonly id: StringType;
-                readonly label: StringType;
-                readonly meta: OptionType<StringType>;
-            }>>>;
-            readonly cohortCounts: FunctionType<[], import("@elaraai/east").DictType<StringType, import("@elaraai/east").IntegerType>>;
-            readonly toggleFilter: FunctionType<[import("@elaraai/east").VariantType<{
-                readonly string: 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 startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly eq: import("@elaraai/east").IntegerType;
-                        readonly neq: import("@elaraai/east").IntegerType;
-                        readonly lt: import("@elaraai/east").IntegerType;
-                        readonly lte: import("@elaraai/east").IntegerType;
-                        readonly gt: import("@elaraai/east").IntegerType;
-                        readonly gte: import("@elaraai/east").IntegerType;
-                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly lt: import("@elaraai/east").FloatType;
-                        readonly lte: import("@elaraai/east").FloatType;
-                        readonly gt: import("@elaraai/east").FloatType;
-                        readonly gte: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly datetime: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>], NullType>;
-            readonly facetGroups: FunctionType<[], ArrayType<StructType<{
-                readonly key: StringType;
-                readonly count: import("@elaraai/east").IntegerType;
-                readonly color: StringType;
-            }>>>;
-            readonly setResolution: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
-                readonly auto: NullType;
-                readonly hour: NullType;
-                readonly day: NullType;
-                readonly week: NullType;
-                readonly month: NullType;
-                readonly quarter: NullType;
-                readonly year: NullType;
-            }>>], NullType>;
-        }>;
-        readonly affordances: ArrayType<import("@elaraai/east").VariantType<{
-            readonly filter: NullType;
-            readonly search: NullType;
-            readonly breakdown: NullType;
-            readonly range: NullType;
-            readonly cohort: NullType;
-            readonly brush: NullType;
-            readonly presets: NullType;
-            readonly legend: NullType;
-            readonly resolution: NullType;
-            readonly summary: NullType;
-        }>>;
-    }>>;
-    readonly footer: ArrayType<StructType<{
-        readonly text: StringType;
-        readonly tone: OptionType<import("@elaraai/east").VariantType<{
-            readonly success: NullType;
-            readonly warning: NullType;
-            readonly danger: NullType;
-            readonly info: NullType;
-            readonly neutral: NullType;
-        }>>;
-        readonly end: import("@elaraai/east").BooleanType;
-    }>>;
-    readonly id: OptionType<StringType>;
-    readonly sources: ArrayType<StringType>;
-    readonly canDrop: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly add: StructType<{
-            readonly from: StructType<{
-                readonly library: StringType;
-                readonly key: StringType;
-            }>;
-            readonly into: StructType<{
-                readonly surface: StringType;
-                readonly row: StringType;
-                readonly slot: StringType;
-                readonly event: OptionType<StringType>;
-            }>;
-            readonly duplicate: import("@elaraai/east").BooleanType;
-        }>;
-        readonly move: StructType<{
-            readonly from: StructType<{
-                readonly surface: StringType;
-                readonly row: StringType;
-                readonly slot: StringType;
-                readonly event: OptionType<StringType>;
-            }>;
-            readonly to: StructType<{
-                readonly surface: StringType;
-                readonly row: StringType;
-                readonly slot: StringType;
-                readonly event: OptionType<StringType>;
-            }>;
-        }>;
-        readonly remove: StructType<{
-            readonly from: StructType<{
-                readonly surface: StringType;
-                readonly row: StringType;
-                readonly slot: StringType;
-                readonly event: OptionType<StringType>;
-            }>;
-            readonly to: import("@elaraai/east").VariantType<{
-                readonly trash: NullType;
-                readonly source: NullType;
-            }>;
-        }>;
-        readonly resize: StructType<{
-            readonly event: StructType<{
-                readonly surface: StringType;
-                readonly row: StringType;
-                readonly slot: StringType;
-                readonly event: OptionType<StringType>;
-            }>;
-            readonly edge: import("@elaraai/east").VariantType<{
-                readonly start: NullType;
-                readonly end: NullType;
-            }>;
-        }>;
-    }>], import("@elaraai/east").BooleanType>>;
-    readonly onSelect: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly entry: StructType<{
-            readonly series: StringType;
-            readonly path: ArrayType<StringType>;
-        }>;
-        readonly section: StructType<{
-            readonly series: StringType;
-            readonly path: ArrayType<StringType>;
-        }>;
-    }>], NullType>>;
-    readonly onElementClick: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly run: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly run: StringType;
-        }>;
-        readonly event: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly event: StringType;
-        }>;
-        readonly chip: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly chip: StringType;
-        }>;
-        readonly mark: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly mark: StringType;
-        }>;
-        readonly cell: StructType<{
-            readonly row: import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>;
-            readonly at: import("@elaraai/east").VariantType<{
-                readonly time: import("@elaraai/east").DateTimeType;
-                readonly number: import("@elaraai/east").FloatType;
-                readonly ordinal: StringType;
-            }>;
-        }>;
-        readonly link: StructType<{
-            readonly key: StringType;
-            readonly from: StructType<{
-                readonly row: import("@elaraai/east").VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly run: StringType;
-            }>;
-            readonly to: StructType<{
-                readonly row: import("@elaraai/east").VariantType<{
-                    readonly entry: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                    readonly section: StructType<{
-                        readonly series: StringType;
-                        readonly path: ArrayType<StringType>;
-                    }>;
-                }>;
-                readonly run: StringType;
-            }>;
-        }>;
-    }>], NullType>>;
-    readonly onGroupToggle: OptionType<FunctionType<[StructType<{
-        readonly row: import("@elaraai/east").VariantType<{
-            readonly entry: StructType<{
-                readonly series: StringType;
-                readonly path: ArrayType<StringType>;
-            }>;
-            readonly section: StructType<{
-                readonly series: StringType;
-                readonly path: ArrayType<StringType>;
-            }>;
-        }>;
-        readonly expanded: import("@elaraai/east").BooleanType;
-    }>], NullType>>;
-    readonly onGrainChange: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
-        readonly group: NullType;
-        readonly resource: NullType;
-    }>], NullType>>;
-    readonly ui: OptionType<StructType<{
-        readonly read: FunctionType<[], StructType<{
-            readonly selected: OptionType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly collapsed: ArrayType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly expanded: ArrayType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly charts: ArrayType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly focus: OptionType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-        }>>;
-        readonly write: FunctionType<[StructType<{
-            readonly selected: OptionType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly collapsed: ArrayType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly expanded: ArrayType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly charts: ArrayType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-            readonly focus: OptionType<import("@elaraai/east").VariantType<{
-                readonly entry: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-                readonly section: StructType<{
-                    readonly series: StringType;
-                    readonly path: ArrayType<StringType>;
-                }>;
-            }>>;
-        }>], NullType>;
-        readonly has: FunctionType<[], import("@elaraai/east").BooleanType>;
-    }>>;
-    readonly style: OptionType<StructType<{
-        readonly height: OptionType<StringType>;
-        readonly maxHeight: OptionType<StringType>;
-        readonly density: OptionType<import("@elaraai/east").VariantType<{
-            readonly comfortable: NullType;
-            readonly compact: NullType;
-            readonly condensed: NullType;
-        }>>;
-        readonly gutterWidth: OptionType<StringType>;
-    }>>;
-}>;
-/** Type alias for {@link PlanRootType}. */
-export type PlanRootType = typeof PlanRootType;
-//# sourceMappingURL=ir.d.ts.map