@elaraai/east-ui 1.0.28 → 1.0.29

package/dist/src/collections/schematic/index.d.ts

@@ -6,20 +6,77 @@
  * `Schematic` — a 2D world-coordinate canvas for placing real-world
  * entities (tanks, bays, lines, nodes, cells) in space, plus annotation
  * zones (rooms, walkways) and key-addressed links, all from flat data
- * tables with chart-style field encodings. **Read-only**: single-click
- * selection only — appearance belongs to the linked Library entry;
- * position and live metrics are owned here.
+ * tables with chart-style field encodings. Interaction is opt-in per
+ * channel (selection, camera, zone / link / net editing, item moves,
+ * hover cards) — with nothing bound it is a read-only picture; appearance
+ * belongs to the linked Library entry; position and live metrics are
+ * owned here.
  *
  * @packageDocumentation
  */
-import { type ExprType, type SubtypeExprOrValue, type TypeOf, variant, ArrayType, type BooleanType, FloatType, type FunctionType, type NullType, type OptionType, StringType, StructType } from "@elaraai/east";
+import { type ExprType, type SubtypeExprOrValue, type TypeOf, variant, ArrayType, BooleanType, FloatType, FunctionType, NullType, OptionType, StringType, StructType } from "@elaraai/east";
 import { UIComponentType } from "../../component.js";
 import { StatusTokenType } from "../../style/interaction.js";
 import { type IconName } from "../../display/icon/types.js";
-import { SliceBindType } from "../../platform/slice/index.js";
+import { SliceBindType, SliceChromeType } from "../../platform/slice/index.js";
 import { type SliceAffordanceLiteral } from "../../contracts/slice-affordances.js";
-import { SchematicPointType, SchematicVertexType, SchematicGeometryType, SchematicZonePatternType, SchematicLinkStyleType, SchematicRouteType, SchematicToneType } from "./types.js";
-export { SchematicRootType, SchematicItemType, SchematicZoneType, SchematicLinkType, SchematicPointType, SchematicVertexType, SchematicGeometryType, SchematicZonePatternType, SchematicLinkStyleType, SchematicRouteType, SchematicToneType, } from "./types.js";
+import { SchematicItemType, SchematicZoneType, SchematicLinkType, SchematicPointType, SchematicVertexType, SchematicGeometryType, SchematicZonePatternType, SchematicLinkStyleType, SchematicRouteType, SchematicToneType, SchematicEmphasisType, SchematicSliceEffectType, SchematicLayerType, SchematicSelectionModeType, SchematicSelectionEventType, SchematicViewportEventType, SchematicZoneSelectionEventType, SchematicLinkModeType, SchematicLinkCreateEventType, SchematicLinkEditEventType, SchematicNetEndpointsType, SchematicNetType, SchematicItemMoveEventType } from "./types.js";
+export { SchematicItemType, SchematicZoneType, SchematicLinkType, SchematicPointType, SchematicVertexType, SchematicGeometryType, SchematicZonePatternType, SchematicLinkStyleType, SchematicRouteType, SchematicToneType, SchematicEmphasisType, SchematicSliceEffectType, SchematicLayerType, SchematicSelectionModeType, SchematicRegionType, SchematicSelectionEventType, SchematicViewportEventType, SchematicZoneSelectionEventType, SchematicLinkModeType, SchematicLinkEndpointsType, SchematicLinkCreateEventType, SchematicLinkEditEventType, SchematicNetEndpointsType, SchematicNetType, SchematicItemMoveEventType, } from "./types.js";
+/**
+ * East type for the Schematic root — the resolved mirror of the inline
+ * `Schematic` struct in `component.ts` (which spells the three `*Hover`
+ * fields with the recursion `node` where this mirror resolves them to
+ * `UIComponentType`). Keep the two spellings in sync field-for-field.
+ *
+ * @remarks
+ * Per-field docs live on {@link SchematicConfig}; events and collection
+ * row types are documented in `./types.ts`.
+ */
+export declare const SchematicRootType: StructType<{
+    extent: StructType<{
+        width: FloatType;
+        height: FloatType;
+    }>;
+    items: ArrayType<SchematicItemType>;
+    zones: ArrayType<SchematicZoneType>;
+    links: ArrayType<SchematicLinkType>;
+    nets: ArrayType<SchematicNetType>;
+    scaleUnit: OptionType<StringType>;
+    grid: OptionType<BooleanType>;
+    navigator: OptionType<BooleanType>;
+    minimap: OptionType<BooleanType>;
+    slice: OptionType<SliceChromeType>;
+    sliceEffect: OptionType<SchematicSliceEffectType>;
+    layers: OptionType<ArrayType<SchematicLayerType>>;
+    height: OptionType<StringType>;
+    onSelect: OptionType<FunctionType<[StringType], NullType>>;
+    selectionMode: OptionType<SchematicSelectionModeType>;
+    onSelectionChange: OptionType<FunctionType<[SchematicSelectionEventType], NullType>>;
+    sliceSelectField: OptionType<StringType>;
+    selectZoomFocus: OptionType<BooleanType>;
+    onViewportChange: OptionType<FunctionType<[SchematicViewportEventType], NullType>>;
+    onItemOpen: OptionType<FunctionType<[StringType], NullType>>;
+    onSelectZone: OptionType<FunctionType<[StringType], NullType>>;
+    onZoneSelectionChange: OptionType<FunctionType<[SchematicZoneSelectionEventType], NullType>>;
+    linkMode: OptionType<SchematicLinkModeType>;
+    onCreateLink: OptionType<FunctionType<[SchematicLinkCreateEventType], NullType>>;
+    onSelectLink: OptionType<FunctionType<[StringType], NullType>>;
+    onEditLink: OptionType<FunctionType<[SchematicLinkEditEventType], NullType>>;
+    onDeleteLink: OptionType<FunctionType<[StringType], NullType>>;
+    readOnly: OptionType<BooleanType>;
+    readOnlyLinks: OptionType<BooleanType>;
+    readOnlyItems: OptionType<BooleanType>;
+    onMoveItem: OptionType<FunctionType<[SchematicItemMoveEventType], NullType>>;
+    itemHover: OptionType<FunctionType<[StringType], UIComponentType>>;
+    zoneHover: OptionType<FunctionType<[StringType], UIComponentType>>;
+    linkHover: OptionType<FunctionType<[StringType], UIComponentType>>;
+    onEditNet: OptionType<FunctionType<[SchematicNetEndpointsType], NullType>>;
+    canConnect: OptionType<FunctionType<[StringType, StringType], BooleanType>>;
+}>;
+/**
+ * Type representing the Schematic component.
+ */
+export type SchematicRootType = typeof SchematicRootType;
 /** String literal form of {@link SchematicToneType} tags. */
 export type SchematicToneLiteral = "brand" | "ink" | "muted" | "success" | "warning" | "danger";
 /** Style configuration accepted by {@link outline} / {@link hatch} / {@link solid} / {@link dashed}. */
@@ -203,6 +260,13 @@ export interface SchematicItemFields {
     fillOpacity?: SubtypeExprOrValue<FloatType>;
     /** Optional stroke width in px. */
     weight?: SubtypeExprOrValue<FloatType>;
+    /** Optional slice-excluded flag — when a `sliceEffect` is set, a `true` item
+     * is treated as filtered-out (ghosted / hidden per the effect). Typically
+     * `Slice.apply.matches(state, cfg, row).not()`, or read from `Slice.partition`. */
+    excluded?: SubtypeExprOrValue<BooleanType>;
+    /** Optional layer membership — the `key` of a `layers` entry; hidden when
+     * that layer is hidden. Absent ⇒ unlayered (always visible). */
+    layer?: SubtypeExprOrValue<StringType>;
 }
 /**
  * Fields the `zone` mapper returns — one annotation zone, before defaults.
@@ -248,6 +312,9 @@ export interface SchematicZoneFields {
     fillOpacity?: SubtypeExprOrValue<FloatType>;
     /** Optional stroke width in px. */
     weight?: SubtypeExprOrValue<FloatType>;
+    /** Optional layer membership — the `key` of a `layers` entry; hidden when
+     * that layer is hidden. Absent ⇒ unlayered (always visible). */
+    layer?: SubtypeExprOrValue<StringType>;
 }
 /**
  * Fields the `link` mapper returns — one connection, before defaults.
@@ -266,12 +333,74 @@ export interface SchematicLinkFields {
     from: SubtypeExprOrValue<StringType>;
     /** Destination item key. */
     to: SubtypeExprOrValue<StringType>;
+    /** Optional label rendered mid-path (a name / flow description); hidden when zoomed out past the label band. */
+    label?: SubtypeExprOrValue<StringType>;
+    /** Optional metric rendered after the label mid-path (a rate / capacity readout), muted. */
+    metric?: SubtypeExprOrValue<StringType>;
     /** Optional style (default `Schematic.solid()`). */
     style?: SubtypeExprOrValue<SchematicLinkStyleType>;
     /** Optional routing (default orthogonal, rounded corners). */
     route?: SubtypeExprOrValue<SchematicRouteType>;
     /** Optional world-coordinate waypoints, in order. */
     via?: SubtypeExprOrValue<ArrayType<SchematicPointType>>;
+    /** Optional layer membership — the `key` of a `layers` entry; hidden when
+     * that layer is hidden (or when either endpoint item is hidden). */
+    layer?: SubtypeExprOrValue<StringType>;
+}
+/**
+ * Author-facing fields for one net (manifold / bus), produced by the `net`
+ * mapper — many `sources` feeding many `destinations` through one trunk.
+ */
+export interface SchematicNetFields {
+    /** Net identity. */
+    key: SubtypeExprOrValue<StringType>;
+    /** Source item keys (the feeding side). */
+    sources: SubtypeExprOrValue<ArrayType<StringType>>;
+    /** Destination item keys (the fed side). */
+    destinations: SubtypeExprOrValue<ArrayType<StringType>>;
+    /** Optional label rendered mid-trunk. */
+    label?: SubtypeExprOrValue<StringType>;
+    /** Optional metric rendered after the label mid-trunk, muted. */
+    metric?: SubtypeExprOrValue<StringType>;
+    /** Optional style (default `Schematic.solid()`). */
+    style?: SubtypeExprOrValue<SchematicLinkStyleType>;
+    /** Optional trunk routing (default orthogonal, rounded corners). */
+    route?: SubtypeExprOrValue<SchematicRouteType>;
+    /** Optional world-coordinate trunk waypoints, in order. */
+    via?: SubtypeExprOrValue<ArrayType<SchematicPointType>>;
+    /** Optional layer membership — hidden when that layer is hidden. */
+    layer?: SubtypeExprOrValue<StringType>;
+}
+/** String literal form of {@link SchematicEmphasisType} tags. */
+export type SchematicEmphasisLiteral = "halo" | "pulse";
+/** String literal form of {@link SchematicSelectionModeType} tags. */
+export type SchematicSelectionModeLiteral = "single" | "multiple";
+/** String literal form of {@link SchematicLinkModeType} tags. */
+export type SchematicLinkModeLiteral = "draw" | "connect";
+/**
+ * A layer declaration for {@link SchematicConfig.layers}. Only `key` + `label`
+ * are required; the rest are author defaults the user's panel toggles override.
+ *
+ * @property key - Layer identity — entities reference it via their `layer` field
+ * @property label - Panel display name
+ * @property visible - Author default visibility (default `true`); `false` ⇒ ships hidden
+ * @property locked - Author default lock / non-selectable (default `false`)
+ * @property opacity - Item-level dim (0–1) for the layer's items (default `1`)
+ * @property tone - Panel swatch tone
+ */
+export interface SchematicLayerInput {
+    /** Layer identity — entities reference it via their `layer` field. */
+    key: string;
+    /** Panel display name. */
+    label: string;
+    /** Author default visibility (default `true`); `false` ⇒ ships hidden. */
+    visible?: boolean;
+    /** Author default lock / non-selectable (default `false`). */
+    locked?: boolean;
+    /** Item-level dim (0–1) for the layer's items (default `1`). */
+    opacity?: number;
+    /** Panel swatch tone. */
+    tone?: SchematicToneLiteral;
 }
 /**
  * Configuration for {@link createSchematic}.
@@ -292,7 +421,7 @@ export interface SchematicLinkFields {
  * @property height - Optional fixed panel height (any CSS length)
  * @property onSelect - Optional item-click callback (receives the item key)
  */
-export interface SchematicConfig<I extends StructType, Z extends StructType, L extends StructType> {
+export interface SchematicConfig<I extends StructType, Z extends StructType, L extends StructType, N extends StructType = StructType> {
     /** World-coordinate bounds; the canvas scales to fit. */
     extent: {
         width: number;
@@ -308,6 +437,10 @@ export interface SchematicConfig<I extends StructType, Z extends StructType, L e
     links?: SubtypeExprOrValue<ArrayType<L>>;
     /** Links row mapper; omit when `links` is already `ArrayType(Schematic.Types.Link)`. */
     link?: (link: ExprType<L>) => SchematicLinkFields;
+    /** Optional nets — manifold / bus rows (one row = many sources → many destinations). */
+    nets?: SubtypeExprOrValue<ArrayType<N>>;
+    /** Maps a net row to its {@link SchematicNetFields} (or passes a resolved {@link SchematicNetType} through). */
+    net?: (net: ExprType<N>) => SchematicNetFields;
     /** Optional unit for the bottom-right scale bar. */
     scaleUnit?: SubtypeExprOrValue<StringType>;
     /** Metric grid aligned to the scale legend; default on. */
@@ -325,10 +458,84 @@ export interface SchematicConfig<I extends StructType, Z extends StructType, L e
     slice?: SubtypeExprOrValue<SliceBindType>;
     /** Rail affordances when `slice` is set. Default `["search"]`. */
     affordances?: SliceAffordanceLiteral[];
+    /**
+     * Slice-driven render effect — instead of hiding filtered-out items, keep
+     * them as ghosted / desaturated / shrunk context and emphasise the remainder.
+     * Feed the **full** item set and mark each item's `excluded` flag (via
+     * `Slice.partition`, or `Slice.apply.matches(...).not()`); every prop below is
+     * `SubtypeExprOrValue`, so any can be static or driven reactively from a
+     * `State.read`. All absent ⇒ excluded items hidden completely (today's default).
+     */
+    /** Remove filtered-out items entirely; absent / `false` ⇒ keep them as context. */
+    sliceHidden?: SubtypeExprOrValue<BooleanType>;
+    /** Ghost opacity (0–1) for kept filtered-out items; absent ⇒ full. */
+    sliceOpacity?: SubtypeExprOrValue<FloatType>;
+    /** Drain kept filtered-out items' colour to grey. */
+    sliceDesaturate?: SubtypeExprOrValue<BooleanType>;
+    /** Collapse kept filtered-out items to a bare dot (drop card / label / footprint). */
+    sliceDot?: SubtypeExprOrValue<BooleanType>;
+    /** Emphasise the matched remainder — `"halo"` (static ring) or `"pulse"`
+     * (animated). A reactive `option<Emphasis>` value can be `none` to turn the
+     * ring off; the string shorthands are sugar for `some(variant(...))`. */
+    sliceEmphasis?: SubtypeExprOrValue<OptionType<SchematicEmphasisType>> | SchematicEmphasisLiteral;
+    /** Draw a bounding frame around the matched set. */
+    sliceFrame?: SubtypeExprOrValue<BooleanType>;
+    /** Auto-fit the camera to the matched frame when the matched set changes. */
+    sliceFrameFit?: SubtypeExprOrValue<BooleanType>;
+    /**
+     * Named layers — cross-cutting groups of items / zones / links, toggled
+     * (visibility / solo / lock / dim) from a layer button on the canvas. Tag
+     * each entity with a matching `layer` key. Absent ⇒ no layer chrome.
+     */
+    layers?: SchematicLayerInput[];
     /** Optional fixed panel height (any CSS length, e.g. `"400px"`); default: aspect-driven, capped at 75vh. */
     height?: SubtypeExprOrValue<StringType> | string;
     /** Optional item-click callback (receives the item key). */
     onSelect?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
+    /** Optional selection cardinality (`"single"` / `"multiple"` / `"range"`); absent ⇒ single. `multiple` / `range` reveal the marquee tool. */
+    selectionMode?: SubtypeExprOrValue<SchematicSelectionModeType> | SchematicSelectionModeLiteral;
+    /** Optional selection-set change callback — fired on any tap / marquee / clear with the full selected set ({@link SchematicSelectionEventType}). */
+    onSelectionChange?: SubtypeExprOrValue<FunctionType<[SchematicSelectionEventType], NullType>>;
+    /** Optional bound-slice fieldId that selection drives with an `in` filter of the selected item keys (requires a bound `slice`); absent ⇒ selection leaves the slice untouched. Best paired with the ghost `slice*` effect rather than a `Slice.rows` feed on the same slice. */
+    sliceSelectField?: SubtypeExprOrValue<StringType> | string;
+    /** When true, a canvas selection also moves the camera — a single tap flies to the item, a marquee fits to the selected set — regardless of `selectionMode`; default false. The navigator rail + prev/next always fly. */
+    selectZoomFocus?: SubtypeExprOrValue<BooleanType> | boolean;
+    /** Optional debounced viewport-settled callback ({@link SchematicViewportEventType}: zoom + visible world rect) — fired after a pan / zoom / fly / resize settles, never per-frame. */
+    onViewportChange?: SubtypeExprOrValue<FunctionType<[SchematicViewportEventType], NullType>>;
+    /** Optional item-open callback (receives the item key) — fired on double-click / double-tap of an item (drill-in); a background double-click keeps Fit / reset. Locked-layer items do not open. */
+    onItemOpen?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
+    /** Optional zone-click callback (receives the zone key) — the single-key channel, parallel to `onSelect`. Items take hit-test precedence; outline zones only (hatch bands are annotations); innermost zone wins for nested zones. */
+    onSelectZone?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
+    /** Optional zone selection-set change callback ({@link SchematicZoneSelectionEventType}) — fired on any zone tap / nav zone click / clear with the full selected zone set AND their `childItemKeys`. Zone gestures follow `selectionMode` (Shift extends in `multiple`). */
+    onZoneSelectionChange?: SubtypeExprOrValue<FunctionType<[SchematicZoneSelectionEventType], NullType>>;
+    /** Optional connect-gesture mode (`"draw"` adds a physical link locally, form-input style; `"connect"` is event-only and repeatable — the plan-an-operation channel); absent ⇒ draw. */
+    linkMode?: SubtypeExprOrValue<SchematicLinkModeType> | SchematicLinkModeLiteral;
+    /** Optional link-creation callback ({@link SchematicLinkCreateEventType}) — fired on every committed connect gesture with the newest link, the accumulated Shift-session (`links`), and the pair's `existing` links. */
+    onCreateLink?: SubtypeExprOrValue<FunctionType<[SchematicLinkCreateEventType], NullType>>;
+    /** Optional link-click callback (receives the link key) — the link analogue of `onSelect`. */
+    onSelectLink?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
+    /** Optional link-edit callback ({@link SchematicLinkEditEventType}) — fired after an endpoint connector re-target with the endpoints AFTER the edit. */
+    onEditLink?: SubtypeExprOrValue<FunctionType<[SchematicLinkEditEventType], NullType>>;
+    /** Optional link-delete callback (receives the deleted link's key). */
+    onDeleteLink?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
+    /** Master read-only switch — disables ALL editing affordances; default false. */
+    readOnly?: SubtypeExprOrValue<BooleanType> | boolean;
+    /** Read-only for LINK editing only (connect tool, connectors, delete); effective = `readOnly || readOnlyLinks`; default false. */
+    readOnlyLinks?: SubtypeExprOrValue<BooleanType> | boolean;
+    /** Read-only for ITEM editing only (the move tool); effective = `readOnly || readOnlyItems`; default false. */
+    readOnlyItems?: SubtypeExprOrValue<BooleanType> | boolean;
+    /** Optional item-move callback ({@link SchematicItemMoveEventType}) — fired once per move-tool gesture on release; group move rides the current selection. */
+    onMoveItem?: SubtypeExprOrValue<FunctionType<[SchematicItemMoveEventType], NullType>>;
+    /** Optional hover-card content builder for ITEMS — receives the hovered item's key and returns arbitrary UI (a `Sparkline` / `Chart` over the entity's history is the headline case), evaluated lazily on hover; absent ⇒ no item hover card. Hover is read-only context — it ignores `readOnly` and locked layers. */
+    itemHover?: SubtypeExprOrValue<FunctionType<[StringType], UIComponentType>>;
+    /** Optional hover-card content builder for ZONES — receives the hovered zone's key; absent ⇒ no zone hover card. */
+    zoneHover?: SubtypeExprOrValue<FunctionType<[StringType], UIComponentType>>;
+    /** Optional hover-card content builder for LINKS and NETS — receives the hovered link / net key (nets share the channel, like `onSelectLink`); absent ⇒ no link hover card. */
+    linkHover?: SubtypeExprOrValue<FunctionType<[StringType], UIComponentType>>;
+    /** Optional net membership-edit callback — fired after deleting ONE selected leg (a stub) of a net, with the net's endpoints AFTER the removal (upsert by `key`); removing the last endpoint of a side deletes the whole net via `onDeleteLink` instead. Gated by `readOnly` / `readOnlyLinks`. */
+    onEditNet?: SubtypeExprOrValue<FunctionType<[SchematicNetEndpointsType], NullType>>;
+    /** Optional connection validator — receives `(from, to)` item keys BEFORE a connect gesture resolves; return false to forbid the pair: the draft never snaps to that target and releasing does nothing. Applies to draw AND connect modes, Shift-session extensions, and endpoint re-targets. A throwing validator logs and ALLOWS (fail-open) so a broken predicate cannot brick editing. */
+    canConnect?: SubtypeExprOrValue<FunctionType<[StringType, StringType], BooleanType>>;
 }
 /**
  * Creates a Schematic — a read-only 2D world-coordinate canvas.
@@ -360,9 +567,10 @@ export interface SchematicConfig<I extends StructType, Z extends StructType, L e
  * );
  * ```
  */
-declare function createSchematic<I extends SubtypeExprOrValue<ArrayType<StructType>>, Z extends SubtypeExprOrValue<ArrayType<StructType>> = [], L extends SubtypeExprOrValue<ArrayType<StructType>> = []>(items: I, config: SchematicConfig<RowElement<I>, RowElement<Z>, RowElement<L>> & {
+declare function createSchematic<I extends SubtypeExprOrValue<ArrayType<StructType>>, Z extends SubtypeExprOrValue<ArrayType<StructType>> = [], L extends SubtypeExprOrValue<ArrayType<StructType>> = [], N extends SubtypeExprOrValue<ArrayType<StructType>> = []>(items: I, config: SchematicConfig<RowElement<I>, RowElement<Z>, RowElement<L>, RowElement<N>> & {
     zones?: Z;
     links?: L;
+    nets?: N;
 }): ExprType<UIComponentType>;
 /**
  * Schematic component namespace.
@@ -525,707 +733,45 @@ export declare const Schematic: {
          * @property onSelect - Optional item-click callback
          */
         readonly Schematic: StructType<{
-            readonly extent: StructType<{
-                readonly width: FloatType;
-                readonly height: FloatType;
+            extent: StructType<{
+                width: FloatType;
+                height: FloatType;
             }>;
-            readonly items: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly x: FloatType;
-                readonly y: FloatType;
-                readonly label: StringType;
-                readonly sublabel: OptionType<StringType>;
-                readonly icon: 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 meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly width: OptionType<FloatType>;
-                readonly footprint: OptionType<import("@elaraai/east").VariantType<{
-                    readonly rect: NullType;
-                    readonly circle: StructType<{
-                        readonly radius: FloatType;
-                    }>;
-                    readonly polyline: StructType<{
-                        readonly vertices: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                            readonly bulge: FloatType;
-                        }>>;
-                        readonly width: OptionType<FloatType>;
-                    }>;
-                    readonly polygon: StructType<{
-                        readonly vertices: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                            readonly bulge: FloatType;
-                        }>>;
-                    }>;
-                }>>;
-                readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                    readonly brand: NullType;
-                    readonly ink: NullType;
-                    readonly muted: NullType;
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                }>>;
-                readonly color: OptionType<StringType>;
-                readonly bg: OptionType<StringType>;
-                readonly fillOpacity: OptionType<FloatType>;
-                readonly weight: OptionType<FloatType>;
-            }>>;
-            readonly zones: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly x: FloatType;
-                readonly y: FloatType;
-                readonly width: FloatType;
-                readonly height: FloatType;
-                readonly pattern: import("@elaraai/east").VariantType<{
-                    readonly outline: StructType<{
-                        readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: NullType;
-                            readonly ink: NullType;
-                            readonly muted: NullType;
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                        }>>;
-                    }>;
-                    readonly hatch: StructType<{
-                        readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: NullType;
-                            readonly ink: NullType;
-                            readonly muted: NullType;
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                        }>>;
-                        readonly spacing: OptionType<FloatType>;
-                        readonly angle: OptionType<FloatType>;
-                    }>;
-                }>;
-                readonly geometry: OptionType<import("@elaraai/east").VariantType<{
-                    readonly rect: NullType;
-                    readonly circle: StructType<{
-                        readonly radius: FloatType;
-                    }>;
-                    readonly polyline: StructType<{
-                        readonly vertices: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                            readonly bulge: FloatType;
-                        }>>;
-                        readonly width: OptionType<FloatType>;
-                    }>;
-                    readonly polygon: StructType<{
-                        readonly vertices: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                            readonly bulge: FloatType;
-                        }>>;
-                    }>;
-                }>>;
-                readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                    readonly brand: NullType;
-                    readonly ink: NullType;
-                    readonly muted: NullType;
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                }>>;
-                readonly color: OptionType<StringType>;
-                readonly bg: OptionType<StringType>;
-                readonly fillOpacity: OptionType<FloatType>;
-                readonly weight: OptionType<FloatType>;
-            }>>;
-            readonly links: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly from: StringType;
-                readonly to: StringType;
-                readonly style: import("@elaraai/east").VariantType<{
-                    readonly solid: StructType<{
-                        readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: NullType;
-                            readonly ink: NullType;
-                            readonly muted: NullType;
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                        }>>;
-                        readonly weight: OptionType<FloatType>;
-                    }>;
-                    readonly dashed: StructType<{
-                        readonly tone: OptionType<import("@elaraai/east").VariantType<{
-                            readonly brand: NullType;
-                            readonly ink: NullType;
-                            readonly muted: NullType;
-                            readonly success: NullType;
-                            readonly warning: NullType;
-                            readonly danger: NullType;
-                        }>>;
-                        readonly weight: OptionType<FloatType>;
-                    }>;
-                }>;
-                readonly route: import("@elaraai/east").VariantType<{
-                    readonly orthogonal: StructType<{
-                        readonly corner: OptionType<FloatType>;
-                    }>;
-                    readonly direct: NullType;
-                }>;
-                readonly via: ArrayType<StructType<{
-                    readonly x: FloatType;
-                    readonly y: FloatType;
-                }>>;
-            }>>;
-            readonly scaleUnit: OptionType<StringType>;
-            readonly grid: OptionType<BooleanType>;
-            readonly navigator: OptionType<BooleanType>;
-            readonly minimap: OptionType<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: FloatType;
-                                readonly to: 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 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: FloatType;
-                                    readonly lte: FloatType;
-                                    readonly gt: FloatType;
-                                    readonly gte: 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: 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 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: FloatType;
-                                        readonly lte: FloatType;
-                                        readonly gt: FloatType;
-                                        readonly gte: 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: BooleanType;
-                                    }>;
-                                }>;
-                            }>>;
-                        }>>;
-                        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                        readonly breakdown: OptionType<StructType<{
-                            readonly fieldId: StringType;
-                            readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                        }>>;
-                        readonly search: OptionType<StringType>;
-                        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                        readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                    }>>;
-                    readonly write: 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: FloatType;
-                                readonly to: 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 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: FloatType;
-                                    readonly lte: FloatType;
-                                    readonly gt: FloatType;
-                                    readonly gte: 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: 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 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: FloatType;
-                                        readonly lte: FloatType;
-                                        readonly gt: FloatType;
-                                        readonly gte: 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: BooleanType;
-                                    }>;
-                                }>;
-                            }>>;
-                        }>>;
-                        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                        readonly breakdown: OptionType<StructType<{
-                            readonly fieldId: StringType;
-                            readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                        }>>;
-                        readonly search: OptionType<StringType>;
-                        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                        readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                    }>], 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: FloatType;
-                            readonly to: 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 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: FloatType;
-                                readonly lte: FloatType;
-                                readonly gt: FloatType;
-                                readonly gte: 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: 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 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: FloatType;
-                                    readonly lte: FloatType;
-                                    readonly gt: FloatType;
-                                    readonly gte: 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: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                    }>], 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 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: FloatType;
-                                    readonly lte: FloatType;
-                                    readonly gt: FloatType;
-                                    readonly gte: 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: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                    }>], 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<[], 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 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: FloatType;
-                                readonly time: import("@elaraai/east").DateTimeType;
-                            }>;
-                            readonly value: FloatType;
-                            readonly size: OptionType<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 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 height: OptionType<StringType>;
-            readonly onSelect: OptionType<FunctionType<[StringType], NullType>>;
+            items: ArrayType<SchematicItemType>;
+            zones: ArrayType<SchematicZoneType>;
+            links: ArrayType<SchematicLinkType>;
+            nets: ArrayType<SchematicNetType>;
+            scaleUnit: OptionType<StringType>;
+            grid: OptionType<BooleanType>;
+            navigator: OptionType<BooleanType>;
+            minimap: OptionType<BooleanType>;
+            slice: OptionType<SliceChromeType>;
+            sliceEffect: OptionType<SchematicSliceEffectType>;
+            layers: OptionType<ArrayType<SchematicLayerType>>;
+            height: OptionType<StringType>;
+            onSelect: OptionType<FunctionType<[StringType], NullType>>;
+            selectionMode: OptionType<SchematicSelectionModeType>;
+            onSelectionChange: OptionType<FunctionType<[SchematicSelectionEventType], NullType>>;
+            sliceSelectField: OptionType<StringType>;
+            selectZoomFocus: OptionType<BooleanType>;
+            onViewportChange: OptionType<FunctionType<[SchematicViewportEventType], NullType>>;
+            onItemOpen: OptionType<FunctionType<[StringType], NullType>>;
+            onSelectZone: OptionType<FunctionType<[StringType], NullType>>;
+            onZoneSelectionChange: OptionType<FunctionType<[SchematicZoneSelectionEventType], NullType>>;
+            linkMode: OptionType<SchematicLinkModeType>;
+            onCreateLink: OptionType<FunctionType<[SchematicLinkCreateEventType], NullType>>;
+            onSelectLink: OptionType<FunctionType<[StringType], NullType>>;
+            onEditLink: OptionType<FunctionType<[SchematicLinkEditEventType], NullType>>;
+            onDeleteLink: OptionType<FunctionType<[StringType], NullType>>;
+            readOnly: OptionType<BooleanType>;
+            readOnlyLinks: OptionType<BooleanType>;
+            readOnlyItems: OptionType<BooleanType>;
+            onMoveItem: OptionType<FunctionType<[SchematicItemMoveEventType], NullType>>;
+            itemHover: OptionType<FunctionType<[StringType], UIComponentType>>;
+            zoneHover: OptionType<FunctionType<[StringType], UIComponentType>>;
+            linkHover: OptionType<FunctionType<[StringType], UIComponentType>>;
+            onEditNet: OptionType<FunctionType<[SchematicNetEndpointsType], NullType>>;
+            canConnect: OptionType<FunctionType<[StringType, StringType], BooleanType>>;
         }>;
         /**
          * A resolved placed item.
@@ -1295,6 +841,8 @@ export declare const Schematic: {
             readonly bg: OptionType<StringType>;
             readonly fillOpacity: OptionType<FloatType>;
             readonly weight: OptionType<FloatType>;
+            readonly excluded: OptionType<BooleanType>;
+            readonly layer: OptionType<StringType>;
         }>;
         /**
          * A resolved annotation zone.
@@ -1372,6 +920,7 @@ export declare const Schematic: {
             readonly bg: OptionType<StringType>;
             readonly fillOpacity: OptionType<FloatType>;
             readonly weight: OptionType<FloatType>;
+            readonly layer: OptionType<StringType>;
         }>;
         /**
          * A resolved link between items.
@@ -1386,6 +935,8 @@ export declare const Schematic: {
             readonly key: StringType;
             readonly from: StringType;
             readonly to: StringType;
+            readonly label: OptionType<StringType>;
+            readonly metric: OptionType<StringType>;
             readonly style: import("@elaraai/east").VariantType<{
                 readonly solid: StructType<{
                     readonly tone: OptionType<import("@elaraai/east").VariantType<{
@@ -1420,6 +971,7 @@ export declare const Schematic: {
                 readonly x: FloatType;
                 readonly y: FloatType;
             }>>;
+            readonly layer: OptionType<StringType>;
         }>;
         /**
          * Zone render pattern (`outline` / `hatch`).
@@ -1553,6 +1105,282 @@ export declare const Schematic: {
             readonly y: FloatType;
             readonly bulge: FloatType;
         }>;
+        /**
+         * A named layer — a toggleable group of items / zones / links.
+         *
+         * @property key - Layer identity (entities reference it via `layer`)
+         * @property label - Panel display name
+         * @property visible - Author default visibility
+         * @property locked - Author default lock (non-selectable)
+         * @property opacity - Item dim (0–1)
+         * @property tone - Panel swatch tone
+         */
+        readonly Layer: StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly visible: OptionType<BooleanType>;
+            readonly locked: OptionType<BooleanType>;
+            readonly opacity: OptionType<FloatType>;
+            readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                readonly brand: NullType;
+                readonly ink: NullType;
+                readonly muted: NullType;
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+            }>>;
+        }>;
+        /**
+         * The flat slice-driven render effect struct (mirrors the `slice*` props).
+         */
+        readonly SliceEffect: StructType<{
+            readonly hidden: OptionType<BooleanType>;
+            readonly opacity: OptionType<FloatType>;
+            readonly desaturate: OptionType<BooleanType>;
+            readonly dot: OptionType<BooleanType>;
+            readonly emphasis: OptionType<import("@elaraai/east").VariantType<{
+                readonly halo: NullType;
+                readonly pulse: NullType;
+            }>>;
+            readonly frame: OptionType<BooleanType>;
+            readonly frameFit: OptionType<BooleanType>;
+        }>;
+        /**
+         * Matched-item emphasis (`halo` / `pulse`) — annotate `State` with it to
+         * drive `sliceEmphasis` reactively.
+         */
+        readonly Emphasis: import("@elaraai/east").VariantType<{
+            readonly halo: NullType;
+            readonly pulse: NullType;
+        }>;
+        /**
+         * Selection cardinality (`single` / `multiple` / `range`) — drive
+         * `selectionMode` reactively or read it back.
+         */
+        readonly SelectionMode: import("@elaraai/east").VariantType<{
+            readonly single: NullType;
+            readonly multiple: NullType;
+        }>;
+        /**
+         * A world-coordinate rectangle swept by a marquee gesture.
+         *
+         * @property minX - Left edge (world units)
+         * @property minY - Top edge (world units)
+         * @property maxX - Right edge (world units)
+         * @property maxY - Bottom edge (world units)
+         */
+        readonly Region: StructType<{
+            readonly minX: FloatType;
+            readonly minY: FloatType;
+            readonly maxX: FloatType;
+            readonly maxY: FloatType;
+        }>;
+        /**
+         * Selection-set change event passed to `onSelectionChange`.
+         *
+         * @property key - The item that triggered the change (some for a tap; none for marquee / clear)
+         * @property selected - Whether `key` is now selected; for bulk changes, whether the set is non-empty
+         * @property selectedKeys - The full selected set after the gesture
+         * @property additive - Whether the gesture added to the prior selection vs replaced it
+         * @property region - The world rectangle a marquee swept (some for a marquee; none otherwise)
+         */
+        readonly SelectionEvent: StructType<{
+            readonly key: OptionType<StringType>;
+            readonly selected: BooleanType;
+            readonly selectedKeys: ArrayType<StringType>;
+            readonly additive: BooleanType;
+            readonly region: OptionType<StructType<{
+                readonly minX: FloatType;
+                readonly minY: FloatType;
+                readonly maxX: FloatType;
+                readonly maxY: FloatType;
+            }>>;
+        }>;
+        /**
+         * Viewport-settled event passed to `onViewportChange` — the camera zoom
+         * plus the visible world rectangle, debounced to gesture settle points.
+         *
+         * @property zoom - The settled camera zoom (1 = fully zoomed out)
+         * @property minX - Left edge of the visible world rect
+         * @property minY - Top edge of the visible world rect
+         * @property maxX - Right edge of the visible world rect
+         * @property maxY - Bottom edge of the visible world rect
+         */
+        readonly ViewportEvent: StructType<{
+            readonly zoom: FloatType;
+            readonly minX: FloatType;
+            readonly minY: FloatType;
+            readonly maxX: FloatType;
+            readonly maxY: FloatType;
+        }>;
+        /**
+         * Zone selection-set change event passed to `onZoneSelectionChange` —
+         * the selected zones plus the item keys inside them.
+         *
+         * @property key - The zone that triggered the change (some for a tap; none for a clear)
+         * @property selected - Whether `key` is now selected; for bulk changes, whether the set is non-empty
+         * @property selectedKeys - The full selected zone set after the gesture
+         * @property childItemKeys - Item keys inside the selected zones (nested descendants included)
+         * @property additive - Whether the gesture added to the prior selection vs replaced it
+         */
+        readonly ZoneSelectionEvent: StructType<{
+            readonly key: OptionType<StringType>;
+            readonly selected: BooleanType;
+            readonly selectedKeys: ArrayType<StringType>;
+            readonly childItemKeys: ArrayType<StringType>;
+            readonly additive: BooleanType;
+        }>;
+        /**
+         * Connect-gesture mode (`draw` | `connect`) — `draw` adds a physical
+         * link locally; `connect` is event-only and repeatable.
+         */
+        readonly LinkMode: import("@elaraai/east").VariantType<{
+            readonly draw: NullType;
+            readonly connect: NullType;
+        }>;
+        /**
+         * One connection's endpoints — the unit a connect gesture produces.
+         *
+         * @property key - Renderer-generated key for the gesture's connection
+         * @property from - Source item key
+         * @property to - Destination item key
+         */
+        readonly LinkEndpoints: StructType<{
+            readonly key: StringType;
+            readonly from: StringType;
+            readonly to: StringType;
+        }>;
+        /**
+         * Link-creation event passed to `onCreateLink` — the newest link, the
+         * accumulated Shift-session, and the pair's existing links.
+         *
+         * @property link - The newest connection (this drag)
+         * @property links - The full session set, `link` included
+         * @property additive - True when Shift extended an open session
+         * @property existing - Keys of links already joining the newest pair
+         */
+        readonly LinkCreateEvent: StructType<{
+            readonly link: StructType<{
+                readonly key: StringType;
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly links: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly from: StringType;
+                readonly to: StringType;
+            }>>;
+            readonly net: StructType<{
+                readonly key: StringType;
+                readonly sources: ArrayType<StringType>;
+                readonly destinations: ArrayType<StringType>;
+            }>;
+            readonly additive: BooleanType;
+            readonly existing: ArrayType<StringType>;
+            readonly absorbed: ArrayType<StringType>;
+        }>;
+        /**
+         * Link-edit event passed to `onEditLink` — the endpoints AFTER an
+         * endpoint connector re-target.
+         *
+         * @property key - The edited link's key
+         * @property from - Source item key after the edit
+         * @property to - Destination item key after the edit
+         */
+        readonly LinkEditEvent: StructType<{
+            readonly key: StringType;
+            readonly from: StringType;
+            readonly to: StringType;
+        }>;
+        /**
+         * A net — a manifold / bus link (many `sources` → many `destinations`,
+         * drawn as a trunk with branches).
+         *
+         * @property key - Net identity
+         * @property sources - Source item keys
+         * @property destinations - Destination item keys
+         * @property label - Optional mid-trunk label
+         * @property metric - Optional mid-trunk metric (muted)
+         * @property style - Stroke style for the whole net
+         * @property route - Trunk routing mode
+         * @property via - Optional trunk waypoints
+         * @property layer - Optional layer membership
+         */
+        readonly Net: StructType<{
+            readonly key: StringType;
+            readonly sources: ArrayType<StringType>;
+            readonly destinations: ArrayType<StringType>;
+            readonly label: OptionType<StringType>;
+            readonly metric: OptionType<StringType>;
+            readonly style: import("@elaraai/east").VariantType<{
+                readonly solid: StructType<{
+                    readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                        readonly brand: NullType;
+                        readonly ink: NullType;
+                        readonly muted: NullType;
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                    }>>;
+                    readonly weight: OptionType<FloatType>;
+                }>;
+                readonly dashed: StructType<{
+                    readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                        readonly brand: NullType;
+                        readonly ink: NullType;
+                        readonly muted: NullType;
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                    }>>;
+                    readonly weight: OptionType<FloatType>;
+                }>;
+            }>;
+            readonly route: import("@elaraai/east").VariantType<{
+                readonly orthogonal: StructType<{
+                    readonly corner: OptionType<FloatType>;
+                }>;
+                readonly direct: NullType;
+            }>;
+            readonly via: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly layer: OptionType<StringType>;
+        }>;
+        /**
+         * A connect-session collapsed to net endpoints (stable session `key`)
+         * — carried on every `onCreateLink` for upsert-style handlers.
+         *
+         * @property key - The session key (stable across the session's commits)
+         * @property sources - Distinct source item keys so far
+         * @property destinations - Distinct destination item keys so far
+         */
+        readonly NetEndpoints: StructType<{
+            readonly key: StringType;
+            readonly sources: ArrayType<StringType>;
+            readonly destinations: ArrayType<StringType>;
+        }>;
+        /**
+         * Item-move event passed to `onMoveItem` — the pressed item's final
+         * position, every moved key (group move rides the selection), and the
+         * shared world delta.
+         *
+         * @property key - The pressed item's key
+         * @property x - Final world x
+         * @property y - Final world y
+         * @property keys - Every moved item (`key` included)
+         * @property dx - Shared world x delta
+         * @property dy - Shared world y delta
+         */
+        readonly ItemMoveEvent: StructType<{
+            readonly key: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly keys: ArrayType<StringType>;
+            readonly dx: FloatType;
+            readonly dy: FloatType;
+        }>;
     };
 };
 //# sourceMappingURL=index.d.ts.map