@elaraai/e3-ui 1.0.85 → 1.0.87

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

@@ -0,0 +1,2594 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The Plan's UIComponent-coupled IR — since the data-interface redesign only
+ * the ROOT touches `UIComponentType`; the whole row
+ * vocabulary (elements, kinds, rows) is pure data in `./types.ts`. The root
+ * is the canvas `<Plan>` carries in its payload (`./plan.ts`, #1191).
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, FunctionType, NullType, OptionType, StringType, StructType } from "@elaraai/east";
+import { PlanEditingType } from "./types.js";
+/**
+ * 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("@elaraai/east-ui").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("@elaraai/east-ui/internal").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("@elaraai/east-ui/internal").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("@elaraai/east-ui/internal").TickFormatType>;
+                            }>;
+                        }>;
+                        readonly aggregate: import("@elaraai/east").VariantType<{
+                            readonly mean: NullType;
+                            readonly max: NullType;
+                            readonly sum: NullType;
+                        }>;
+                    }>;
+                }>;
+                readonly span: StructType<{
+                    readonly runs: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly start: import("@elaraai/east").VariantType<{
+                            readonly time: 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("@elaraai/east-ui/internal").TickFormatType>;
+                            readonly text: OptionType<StringType>;
+                        }>>;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                        readonly status: OptionType<import("@elaraai/east").VariantType<{
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly moved: OptionType<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 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 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("@elaraai/east-ui/internal").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("@elaraai/east-ui/internal").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("@elaraai/east-ui/internal").TickFormatType>;
+                        }>;
+                    }>;
+                    readonly aggregate: OptionType<import("@elaraai/east").VariantType<{
+                        readonly mean: NullType;
+                        readonly max: NullType;
+                        readonly sum: NullType;
+                    }>>;
+                    readonly scale: OptionType<StructType<{
+                        readonly min: OptionType<import("@elaraai/east").FloatType>;
+                        readonly max: OptionType<import("@elaraai/east").FloatType>;
+                        readonly warnAt: OptionType<import("@elaraai/east").FloatType>;
+                    }>>;
+                }>;
+                readonly table: StructType<{
+                    readonly series: ArrayType<StructType<{
+                        readonly cells: ArrayType<StructType<{
+                            readonly at: import("@elaraai/east").VariantType<{
+                                readonly time: 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("@elaraai/east-ui/internal").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("@elaraai/east-ui/internal").TickFormatType>;
+                    readonly emphasis: import("@elaraai/east").VariantType<{
+                        readonly body: NullType;
+                        readonly header: NullType;
+                        readonly footer: NullType;
+                    }>;
+                }>;
+                readonly cards: StructType<{
+                    readonly chips: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly from: import("@elaraai/east").VariantType<{
+                            readonly time: 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 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 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 expand: OptionType<StructType<{
+                readonly height: OptionType<StringType>;
+                readonly axis: import("@elaraai/east").VariantType<{
+                    readonly keep: NullType;
+                    readonly dim: NullType;
+                    readonly off: NullType;
+                }>;
+            }>>;
+            readonly edits: StructType<{
+                readonly drop: 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("@elaraai/east-ui/internal").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("@elaraai/east-ui").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("@elaraai/east-ui").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("@elaraai/east-ui").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("@elaraai/east-ui").UIComponentNode>>>;
+    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 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>;
+    }>>;
+    /** Record narrowing, appended separately from the local Slice wire. */
+    readonly recordSlice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: import("@elaraai/east").StringType;
+            readonly config: StructType<{
+                readonly fields: ArrayType<StructType<{
+                    readonly fieldId: import("@elaraai/east").StringType;
+                    readonly label: import("@elaraai/east").StringType;
+                    readonly kind: import("@elaraai/east").StringType;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly multiple: import("@elaraai/east").BooleanType;
+                    readonly set: import("@elaraai/east").BooleanType;
+                    readonly values: ArrayType<StructType<{
+                        readonly value: import("@elaraai/east").StringType;
+                        readonly label: import("@elaraai/east").StringType;
+                    }>>;
+                    readonly format: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: import("@elaraai/east").StringType;
+                            readonly compact: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: import("@elaraai/east").StringType;
+                        readonly time: import("@elaraai/east").StringType;
+                        readonly datetime: import("@elaraai/east").StringType;
+                    }>>;
+                }>>;
+                readonly indexes: ArrayType<StructType<{
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly fields: ArrayType<import("@elaraai/east").StringType>;
+                    readonly sets: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                    readonly structured: import("@elaraai/east").BooleanType;
+                    readonly interval: OptionType<StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                        readonly optional: import("@elaraai/east").BooleanType;
+                    }>>;
+                }>>;
+                readonly range: OptionType<import("@elaraai/east").StringType>;
+                readonly search: ArrayType<import("@elaraai/east").StringType>;
+                readonly presets: ArrayType<StructType<{
+                    readonly id: import("@elaraai/east").StringType;
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>;
+                }>>;
+            }>;
+            readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                    readonly values: ArrayType<import("@elaraai/east").StringType>;
+                    readonly range: StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>;
+                    readonly prefix: import("@elaraai/east").StringType;
+                }>>;
+                readonly preset: OptionType<import("@elaraai/east").StringType>;
+                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: import("@elaraai/east").FunctionType<[StructType<{
+                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                    readonly values: ArrayType<import("@elaraai/east").StringType>;
+                    readonly range: StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>;
+                    readonly prefix: import("@elaraai/east").StringType;
+                }>>;
+                readonly preset: OptionType<import("@elaraai/east").StringType>;
+                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 choose: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, ArrayType<import("@elaraai/east").StringType>], NullType>;
+            readonly range: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+            readonly prefix: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+            readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+            readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly countWhere: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                readonly range: StructType<{
+                    readonly from: import("@elaraai/east").StringType;
+                    readonly to: import("@elaraai/east").StringType;
+                }>;
+                readonly prefix: import("@elaraai/east").StringType;
+            }>>], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
+                readonly from: import("@elaraai/east").StringType;
+                readonly to: import("@elaraai/east").StringType;
+            }>>>;
+            readonly values: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<StructType<{
+                readonly value: import("@elaraai/east").StringType;
+                readonly label: import("@elaraai/east").StringType;
+                readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                readonly selected: import("@elaraai/east").BooleanType;
+                readonly error: OptionType<import("@elaraai/east").StringType>;
+            }>>>;
+            readonly suggest: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], OptionType<ArrayType<StructType<{
+                readonly value: import("@elaraai/east").StringType;
+                readonly label: import("@elaraai/east").StringType;
+                readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                readonly selected: import("@elaraai/east").BooleanType;
+                readonly error: OptionType<import("@elaraai/east").StringType>;
+            }>>>>;
+            readonly replaces: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<import("@elaraai/east").StringType>>;
+            readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+            readonly setResolution: import("@elaraai/east").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 retry: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly sourceId: import("@elaraai/east").StringType;
+            readonly readEntry: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<OptionType<import("@elaraai/east").BlobType>>>;
+            readonly contains: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                readonly range: StructType<{
+                    readonly from: import("@elaraai/east").StringType;
+                    readonly to: import("@elaraai/east").StringType;
+                }>;
+                readonly prefix: import("@elaraai/east").StringType;
+            }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+        }>;
+        readonly affordances: ArrayType<import("@elaraai/east").VariantType<{
+            readonly fields: NullType;
+            readonly search: NullType;
+            readonly range: NullType;
+            readonly presets: NullType;
+            readonly resolution: NullType;
+            readonly brush: NullType;
+            readonly summary: NullType;
+        }>>;
+        readonly persist: OptionType<import("@elaraai/east").VariantType<{
+            readonly local: NullType;
+            readonly session: NullType;
+            readonly url: NullType;
+        }>>;
+    }>>;
+}>;
+/** Type alias for {@link PlanRootType}. */
+export type PlanRootType = typeof PlanRootType;
+//# sourceMappingURL=ir.d.ts.map