@elaraai/east-ui 1.0.28 → 1.0.30

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

@@ -2,7 +2,7 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import { ArrayType, BooleanType, FloatType, FunctionType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
+import { ArrayType, BooleanType, FloatType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
 /**
  * Theme tone for zone strokes, hatching, and links.
  *
@@ -377,6 +377,14 @@ export declare const SchematicItemType: StructType<{
     readonly fillOpacity: OptionType<FloatType>;
     /** Optional stroke width in px */
     readonly weight: OptionType<FloatType>;
+    /** Optional slice-excluded flag — when a {@link SchematicSliceEffectType}
+     * is active, a `some(true)` item is treated as filtered-out (ghosted /
+     * hidden per the effect); absent / `some(false)` ⇒ included / normal. */
+    readonly excluded: OptionType<BooleanType>;
+    /** Optional layer membership — the `key` of a {@link SchematicLayerType} in
+     * the root `layers`. Hidden when its layer is hidden; absent ⇒ unlayered
+     * (always visible). An unknown key is treated as always-visible. */
+    readonly layer: OptionType<StringType>;
 }>;
 /**
  * Type representing resolved placed items.
@@ -514,6 +522,9 @@ export declare const SchematicZoneType: StructType<{
     readonly fillOpacity: OptionType<FloatType>;
     /** Optional stroke width in px */
     readonly weight: OptionType<FloatType>;
+    /** Optional layer membership — the `key` of a {@link SchematicLayerType};
+     * hidden when its layer is hidden. Absent ⇒ unlayered (always visible). */
+    readonly layer: OptionType<StringType>;
 }>;
 /**
  * Type representing resolved zones.
@@ -525,6 +536,8 @@ export type SchematicZoneType = typeof SchematicZoneType;
  * @property key - Link identity
  * @property from - Source item key
  * @property to - Destination item key
+ * @property label - Optional mid-path label (name / flow description)
+ * @property metric - Optional mid-path metric readout (muted, after the label)
  * @property style - Render style (`solid` / `dashed`, with stroke config)
  * @property route - Routing mode (`orthogonal` / `direct`)
  * @property via - Optional world-coordinate waypoints, in order
@@ -536,6 +549,10 @@ export declare const SchematicLinkType: StructType<{
     readonly from: StringType;
     /** Destination item key */
     readonly to: StringType;
+    /** Optional label rendered mid-path (a name / flow description); hidden when zoomed out past the label band */
+    readonly label: OptionType<StringType>;
+    /** Optional metric rendered after the label mid-path (a rate / capacity readout), muted */
+    readonly metric: OptionType<StringType>;
     /** Render style (`solid` / `dashed`, with stroke config) */
     readonly style: VariantType<{
         /** A physical run (pipe, conveyor) */
@@ -596,867 +613,571 @@ export declare const SchematicLinkType: StructType<{
         /** World y */
         readonly y: FloatType;
     }>>;
+    /** Optional layer membership — the `key` of a {@link SchematicLayerType};
+     * hidden when its layer is hidden (a link also vanishes when either endpoint
+     * item is hidden). Absent ⇒ unlayered (always visible). */
+    readonly layer: OptionType<StringType>;
 }>;
 /**
  * Type representing resolved links.
  */
 export type SchematicLinkType = typeof SchematicLinkType;
 /**
- * East StructType for the Schematic component.
+ * Positive emphasis applied to the remaining (matched) items when a
+ * {@link SchematicSliceEffectType} is active.
+ *
+ * @remarks
+ * `halo` draws a static highlight ring behind each matched marker / card;
+ * `pulse` animates that ring (a slow breathing glow) to pull the eye to the
+ * survivors. `pulse` runs a lightweight animation loop; `halo` repaints on the
+ * normal frame path.
+ *
+ * @property halo - Static highlight ring on matched items
+ * @property pulse - Animated pulse ring on matched items
+ */
+export declare const SchematicEmphasisType: VariantType<{
+    /** Static highlight ring on matched items. */
+    readonly halo: NullType;
+    /** Animated pulse ring on matched items. */
+    readonly pulse: NullType;
+}>;
+/**
+ * Type representing the matched-item emphasis style.
+ */
+export type SchematicEmphasisType = typeof SchematicEmphasisType;
+/**
+ * Optional slice-driven render effect — how the Schematic treats items once a
+ * bound slice narrows them, instead of the default "hidden completely". A flat
+ * bag of independently-optional settings, mirroring the flat `sliceHidden` /
+ * `sliceOpacity` / `sliceEmphasis` / … config props (each driven statically or
+ * reactively via `SubtypeExprOrValue`).
+ *
+ * @remarks
+ * Feed the **full** item set (not `Slice.rows`) and mark each item's `excluded`
+ * flag (e.g. via `Slice.partition`, or `Slice.apply.matches(...).not()`).
+ * `hidden` removes the filtered-out items entirely (else they stay as context);
+ * `opacity` / `desaturate` / `dot` de-emphasise the kept ones; `emphasis`
+ * highlights the remainder; `frame` boxes the matched set and `frameFit` also
+ * flies the camera to it. Every field absent is a no-op.
+ *
+ * @property hidden - Remove filtered-out items entirely; absent / `some(false)` ⇒ keep as context
+ * @property opacity - Fade alpha (0–1) for kept filtered-out items; absent ⇒ full
+ * @property desaturate - Drain kept filtered-out items' colour to grey
+ * @property dot - Collapse kept filtered-out items to a bare dot
+ * @property emphasis - Positive emphasis on matched items (absent ⇒ none)
+ * @property frame - Draw a bounding frame around the matched set
+ * @property frameFit - Auto-fit the camera to the matched frame when the set changes
+ */
+export declare const SchematicSliceEffectType: StructType<{
+    /** Remove filtered-out items entirely; absent / `some(false)` ⇒ keep as context. */
+    readonly hidden: OptionType<BooleanType>;
+    /** Fade alpha (0–1) for kept filtered-out items; absent ⇒ full. */
+    readonly opacity: OptionType<FloatType>;
+    /** Drain kept filtered-out items' colour to grey. */
+    readonly desaturate: OptionType<BooleanType>;
+    /** Collapse kept filtered-out items to a bare dot (drop card / label / footprint). */
+    readonly dot: OptionType<BooleanType>;
+    /** Positive emphasis on matched items; absent ⇒ none. */
+    readonly emphasis: OptionType<VariantType<{
+        /** Static highlight ring on matched items. */
+        readonly halo: NullType;
+        /** Animated pulse ring on matched items. */
+        readonly pulse: NullType;
+    }>>;
+    /** Draw a bounding frame around the matched set. */
+    readonly frame: OptionType<BooleanType>;
+    /** Auto-fit the camera to the matched frame when the matched set changes. */
+    readonly frameFit: OptionType<BooleanType>;
+}>;
+/**
+ * Type representing the slice-driven render effect.
+ */
+export type SchematicSliceEffectType = typeof SchematicSliceEffectType;
+/**
+ * A named layer — a cross-cutting group of items / zones / links that can be
+ * shown, hidden, isolated (solo), locked, or dimmed together via the canvas
+ * layer button.
  *
  * @remarks
- * A 2D world-coordinate canvas for placing real-world entities (tanks,
- * bays, lines, cells) plus annotation zones and links, all from flat data
- * tables. **Read-only**: single-click selection only — no events, no drag
- * & drop; editing routes through the linked Library.
+ * Membership is by `key`: an entity's `layer` field names the layer it belongs
+ * to. Layer visibility / lock are VIEW state (owned by the renderer, persisted
+ * per panel); the `visible` / `locked` here are the AUTHOR defaults the user's
+ * toggles override. `opacity` dims the layer's items (markers / footprints) in
+ * v1 (zone / link dimming is not yet applied). `tone` colours the panel swatch
+ * (theme-owned). Membership is strictly per-entity — hiding a container zone
+ * does not hide the items geometrically inside it.
+ *
+ * @property key - Layer identity — entities reference it via their `layer` field
+ * @property label - Display name shown in the layer panel
+ * @property visible - Author default visibility; absent / `some(true)` ⇒ shown, `some(false)` ⇒ ships hidden
+ * @property locked - Author default lock (non-selectable); absent ⇒ unlocked
+ * @property opacity - Optional item dim (0–1) for the layer's items; absent ⇒ full
+ * @property tone - Optional panel swatch tone
+ */
+export declare const SchematicLayerType: StructType<{
+    /** Layer identity — entities reference it via their `layer` field. */
+    readonly key: StringType;
+    /** Display name shown in the layer panel. */
+    readonly label: StringType;
+    /** Author default visibility; `some(false)` ships hidden, absent ⇒ shown. */
+    readonly visible: OptionType<BooleanType>;
+    /** Author default lock (non-selectable); absent ⇒ unlocked. */
+    readonly locked: OptionType<BooleanType>;
+    /** Optional item dim (0–1) for the layer's items; absent ⇒ full. */
+    readonly opacity: OptionType<FloatType>;
+    /** Optional panel swatch tone. */
+    readonly tone: OptionType<VariantType<{
+        /** Brand teal */
+        readonly brand: NullType;
+        /** Foreground ink */
+        readonly ink: NullType;
+        /** Muted foreground */
+        readonly muted: NullType;
+        /** Status ok */
+        readonly success: NullType;
+        /** Status warn */
+        readonly warning: NullType;
+        /** Status bad */
+        readonly danger: NullType;
+    }>>;
+}>;
+/**
+ * Type representing a schematic layer.
+ */
+export type SchematicLayerType = typeof SchematicLayerType;
+/**
+ * Selection cardinality for the Schematic. Absent on the root ⇒ `single`.
+ *
+ * @remarks
+ * `single` keeps today's behaviour — one selected item at a time, no
+ * marquee. `multiple` is the multi-select mode: it reveals a marquee tool
+ * in a second control group, where a plain tap / box **replaces** the
+ * selection and **Shift**+tap / **Shift**+box **extend** it (Shift-tap
+ * toggles a single item; Shift-box unions). Esc / the clear button reset.
+ *
+ * @property single - At most one item selected; tap replaces (default; no marquee)
+ * @property multiple - Multi-select; tap / box replace, Shift+tap / Shift+box extend
+ */
+export declare const SchematicSelectionModeType: VariantType<{
+    /** At most one item selected; tap replaces (default; no marquee). */
+    readonly single: NullType;
+    /** Multi-select; tap / box replace, Shift+tap toggles and Shift+box unions. */
+    readonly multiple: NullType;
+}>;
+/**
+ * Type representing the Schematic selection cardinality.
+ */
+export type SchematicSelectionModeType = typeof SchematicSelectionModeType;
+/**
+ * A world-coordinate rectangle swept by a marquee gesture — matches the
+ * box handed to the spatial index, so coordinates are world units.
+ *
+ * @property minX - Left edge (world units)
+ * @property minY - Top edge (world units)
+ * @property maxX - Right edge (world units)
+ * @property maxY - Bottom edge (world units)
+ */
+export declare const SchematicRegionType: StructType<{
+    /** Left edge (world units). */
+    readonly minX: FloatType;
+    /** Top edge (world units). */
+    readonly minY: FloatType;
+    /** Right edge (world units). */
+    readonly maxX: FloatType;
+    /** Bottom edge (world units). */
+    readonly maxY: FloatType;
+}>;
+/**
+ * Type representing a swept marquee region.
+ */
+export type SchematicRegionType = typeof SchematicRegionType;
+/**
+ * Selection-set change event — the Schematic analogue of Table's
+ * `TableRowSelectionEventType`. Passed to `onSelectionChange` whenever the
+ * selected set changes (a tap, a marquee sweep, or a clear).
+ *
+ * @remarks
+ * `key` is `some` for a single-item tap and `none` for a bulk marquee or a
+ * clear. `selectedKeys` is always the FULL selection after the gesture (the
+ * spatial analogue of `selectedRowsIndices`). `region` is `some` only for a
+ * marquee sweep.
+ *
+ * @property key - The item that triggered the change (some for a tap; none for marquee / clear)
+ * @property selected - Whether `key` is now selected (for a tap); 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 (true) or replaced it (false)
+ * @property region - The world rectangle a marquee swept (some for a marquee; none for tap / clear)
+ */
+export declare const SchematicSelectionEventType: StructType<{
+    /** The item that triggered the change (some for a tap; none for marquee / clear). */
+    readonly key: OptionType<StringType>;
+    /** Whether `key` is now selected (tap); for bulk changes, whether the set is non-empty. */
+    readonly selected: BooleanType;
+    /** The full selected set after the gesture. */
+    readonly selectedKeys: ArrayType<StringType>;
+    /** Whether the gesture added to the prior selection (true) or replaced it (false). */
+    readonly additive: BooleanType;
+    /** The world rectangle a marquee swept (some for a marquee; none for tap / clear). */
+    readonly region: OptionType<StructType<{
+        /** Left edge (world units). */
+        readonly minX: FloatType;
+        /** Top edge (world units). */
+        readonly minY: FloatType;
+        /** Right edge (world units). */
+        readonly maxX: FloatType;
+        /** Bottom edge (world units). */
+        readonly maxY: FloatType;
+    }>>;
+}>;
+/**
+ * Type representing a Schematic selection-set change event.
+ */
+export type SchematicSelectionEventType = typeof SchematicSelectionEventType;
+/**
+ * Viewport-settled event — the camera zoom plus the visible world rectangle,
+ * reported (debounced) after a pan / zoom / fly / resize settles. Passed to
+ * `onViewportChange` so hosts can sync external UI, lazy-load data for the
+ * visible region, or persist the view.
  *
- * @property extent - World-coordinate bounds (the canvas scales to fit)
- * @property items - The placed items
- * @property zones - Annotation zones (rooms, cells, walkway bands)
- * @property links - Connections between items, addressed by key
- * @property scaleUnit - Optional unit for the bottom-right scale bar
- * @property grid - Metric grid aligned to the scale legend
- * @property navigator - Navigator rail (zones → items TOC)
- * @property minimap - Minimap with the viewport rectangle
- * @property height - Optional fixed panel height (any CSS length)
- * @property onSelect - Optional item-click callback (receives the item key)
+ * @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
  */
-export declare const SchematicRootType: StructType<{
-    /** World-coordinate bounds (the canvas scales to fit) */
-    readonly extent: StructType<{
-        /** World width */
-        readonly width: FloatType;
-        /** World height */
-        readonly height: FloatType;
+export declare const SchematicViewportEventType: StructType<{
+    /** The settled camera zoom (1 = fully zoomed out). */
+    readonly zoom: FloatType;
+    /** Left edge of the visible world rect. */
+    readonly minX: FloatType;
+    /** Top edge of the visible world rect. */
+    readonly minY: FloatType;
+    /** Right edge of the visible world rect. */
+    readonly maxX: FloatType;
+    /** Bottom edge of the visible world rect. */
+    readonly maxY: FloatType;
+}>;
+/**
+ * Type representing a Schematic viewport-settled event.
+ */
+export type SchematicViewportEventType = typeof SchematicViewportEventType;
+/**
+ * Zone (area) selection-set change event — the zone analogue of
+ * `SchematicSelectionEventType`, passed to `onZoneSelectionChange` whenever
+ * the selected ZONE set changes (a tap on a zone body, a nav-rail zone click,
+ * or a clear).
+ *
+ * @remarks
+ * `childItemKeys` reports the items sitting **inside** the selected zones —
+ * an item counts when its innermost containing zone, or any of that zone's
+ * ancestors, is selected (so selecting a hall includes items in its nested
+ * cells). Items always take hit-test precedence: tapping an item never
+ * selects its host zone.
+ *
+ * @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 (true) or replaced it (false)
+ */
+export declare const SchematicZoneSelectionEventType: StructType<{
+    /** The zone that triggered the change (some for a tap; none for a clear). */
+    readonly key: OptionType<StringType>;
+    /** Whether `key` is now selected (tap); for bulk changes, whether the set is non-empty. */
+    readonly selected: BooleanType;
+    /** The full selected zone set after the gesture. */
+    readonly selectedKeys: ArrayType<StringType>;
+    /** Item keys inside the selected zones (nested descendants included). */
+    readonly childItemKeys: ArrayType<StringType>;
+    /** Whether the gesture added to the prior selection (true) or replaced it (false). */
+    readonly additive: BooleanType;
+}>;
+/**
+ * Type representing a Schematic zone selection-set change event.
+ */
+export type SchematicZoneSelectionEventType = typeof SchematicZoneSelectionEventType;
+/**
+ * Link-gesture mode for the connect tool. Absent on the root ⇒ `draw`.
+ *
+ * @remarks
+ * `draw`: a committed connect gesture adds a **physical link** to the
+ * renderer's local link state (the form-input model — works with no callback
+ * wired), and `onCreateLink` fires in addition. `connect`: the gesture is a
+ * **pure connection event** — nothing is added; only `onCreateLink` fires
+ * (with the pair, the accumulated session, and any existing links between the
+ * endpoints), and the gesture stays repeatable — the channel for planning
+ * operations between plant areas rather than drawing pipes.
+ *
+ * @property draw - The gesture draws a physical link (local-state-first)
+ * @property connect - The gesture only fires the event (nothing added; repeatable)
+ */
+export declare const SchematicLinkModeType: VariantType<{
+    /** The gesture draws a physical link (local-state-first). */
+    readonly draw: NullType;
+    /** The gesture only fires the event (nothing added; repeatable). */
+    readonly connect: NullType;
+}>;
+/**
+ * Type representing the Schematic link-gesture mode.
+ */
+export type SchematicLinkModeType = typeof SchematicLinkModeType;
+/**
+ * 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
+ */
+export declare const SchematicLinkEndpointsType: StructType<{
+    /** Renderer-generated key for the gesture's connection. */
+    readonly key: StringType;
+    /** Source item key. */
+    readonly from: StringType;
+    /** Destination item key. */
+    readonly to: StringType;
+}>;
+/**
+ * Type representing a connect gesture's endpoints.
+ */
+export type SchematicLinkEndpointsType = typeof SchematicLinkEndpointsType;
+/**
+ * A connect-session collapsed to net endpoints — carried on every
+ * `onCreateLink` so handlers can upsert ONE net per session.
+ *
+ * @remarks
+ * `key` is the SESSION key, stable across all of a session's commits: the
+ * plain drag and every Shift-extension report the same `key` with the
+ * accumulated `sources` (distinct froms) and `destinations` (distinct tos).
+ *
+ * @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
+ */
+export declare const SchematicNetEndpointsType: StructType<{
+    /** The session key (stable across the session's commits). */
+    readonly key: StringType;
+    /** Distinct source item keys so far. */
+    readonly sources: ArrayType<StringType>;
+    /** Distinct destination item keys so far. */
+    readonly destinations: ArrayType<StringType>;
+}>;
+/**
+ * Type representing a session's net endpoints.
+ */
+export type SchematicNetEndpointsType = typeof SchematicNetEndpointsType;
+/**
+ * A net — a manifold / bus link joining MANY sources to MANY destinations as
+ * ONE entity, rendered as a trunk with per-endpoint branches.
+ *
+ * @remarks
+ * Use a net when the real topology is a shared run (a CIP manifold feeding
+ * 30 units, a header bridging two banks) — one row instead of a pairwise
+ * `links` explosion. The trunk routes like a link (`route`, with `via` as
+ * TRUNK waypoints); each source branches into the trunk head, each
+ * destination off the tail. A branch drops when its endpoint item is hidden
+ * (layer / slice-hide); the whole net hides when either side empties, or
+ * when its own `layer` is hidden.
+ *
+ * @property key - Net identity (participates in link selection / deletion)
+ * @property sources - Source item keys (the feeding side)
+ * @property destinations - Destination item keys (the fed side)
+ * @property label - Optional mid-trunk label (name / flow description)
+ * @property metric - Optional mid-trunk metric readout (muted, after the label)
+ * @property style - Render style (`solid` / `dashed`) — one stroke for the whole net
+ * @property route - Trunk routing mode (`orthogonal` / `direct`)
+ * @property via - Optional world-coordinate TRUNK waypoints, in order
+ * @property layer - Optional layer membership — hidden when its layer is hidden
+ */
+export declare const SchematicNetType: StructType<{
+    /** Net identity (participates in link selection / deletion) */
+    readonly key: StringType;
+    /** Source item keys (the feeding side) */
+    readonly sources: ArrayType<StringType>;
+    /** Destination item keys (the fed side) */
+    readonly destinations: ArrayType<StringType>;
+    /** Optional label rendered mid-trunk */
+    readonly label: OptionType<StringType>;
+    /** Optional metric rendered after the label mid-trunk, muted */
+    readonly metric: OptionType<StringType>;
+    /** Render style (`solid` / `dashed`, with stroke config) */
+    readonly style: VariantType<{
+        /** A physical run (pipe, conveyor) */
+        readonly solid: StructType<{
+            /** Stroke tone (default `brand`) */
+            readonly tone: OptionType<VariantType<{
+                /** Brand teal */
+                readonly brand: NullType;
+                /** Foreground ink */
+                readonly ink: NullType;
+                /** Muted foreground */
+                readonly muted: NullType;
+                /** Status ok */
+                readonly success: NullType;
+                /** Status warn */
+                readonly warning: NullType;
+                /** Status bad */
+                readonly danger: NullType;
+            }>>;
+            /** Stroke width in pixels (default 2.5) */
+            readonly weight: OptionType<FloatType>;
+        }>;
+        /** A routing / logical connection */
+        readonly dashed: StructType<{
+            /** Stroke tone (default `muted`) */
+            readonly tone: OptionType<VariantType<{
+                /** Brand teal */
+                readonly brand: NullType;
+                /** Foreground ink */
+                readonly ink: NullType;
+                /** Muted foreground */
+                readonly muted: NullType;
+                /** Status ok */
+                readonly success: NullType;
+                /** Status warn */
+                readonly warning: NullType;
+                /** Status bad */
+                readonly danger: NullType;
+            }>>;
+            /** Stroke width in pixels (default 1.5) */
+            readonly weight: OptionType<FloatType>;
+        }>;
     }>;
-    /** The placed items */
-    readonly items: ArrayType<StructType<{
-        /** Item identity — links reference it; `onSelect` returns it */
-        readonly key: StringType;
-        /** World x of the card centre */
+    /** Trunk routing mode (`orthogonal` / `direct`) */
+    readonly route: VariantType<{
+        /** Axis-aligned with rounded corners */
+        readonly orthogonal: StructType<{
+            /** Corner radius in pixels (default 8) */
+            readonly corner: OptionType<FloatType>;
+        }>;
+        /** Straight segments between anchors */
+        readonly direct: NullType;
+    }>;
+    /** Optional world-coordinate trunk waypoints, in order */
+    readonly via: ArrayType<StructType<{
+        /** World x */
         readonly x: FloatType;
-        /** World y of the card centre */
+        /** World y */
         readonly y: FloatType;
-        /** Primary identity line */
-        readonly label: StringType;
-        /** Optional muted second line (kind / capacity) */
-        readonly sublabel: OptionType<StringType>;
-        /** Optional Font Awesome solid icon name */
-        readonly icon: OptionType<StringType>;
-        /** Optional status dot tone */
-        readonly status: OptionType<VariantType<{
-            readonly success: NullType;
-            readonly warning: NullType;
-            readonly danger: NullType;
-            readonly info: NullType;
-            readonly neutral: NullType;
-        }>>;
-        /** Optional mini utilisation bar */
-        readonly meter: OptionType<StructType<{
-            /** Current value */
-            readonly value: FloatType;
-            /** Full-scale value */
-            readonly max: FloatType;
-        }>>;
-        /** Optional live metric text */
-        readonly metric: OptionType<StringType>;
-        /** Optional world width — renders the wide bar form */
-        readonly width: OptionType<FloatType>;
-        /** Optional shape footprint; absent ⇒ point + icon (`x/y` stay the anchor/centroid) */
-        readonly footprint: OptionType<VariantType<{
-            /** Axis-aligned box — zones use `x/y/width/height`; items, the point / marker form. */
-            readonly rect: NullType;
-            /** Circle centred on the entity anchor (item `x/y` or zone bbox centre); `radius` in world units. */
-            readonly circle: StructType<{
-                /** Circle radius in world units. */
-                readonly radius: FloatType;
-            }>;
-            /** Open, arc-aware polyline in world coords; optional world-space band width. */
-            readonly polyline: StructType<{
-                /** Vertices in world coords, in order (each carries a DXF bulge). */
-                readonly vertices: ArrayType<StructType<{
-                    /** World x */
-                    readonly x: FloatType;
-                    /** World y */
-                    readonly y: FloatType;
-                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`). */
-                    readonly bulge: FloatType;
-                }>>;
-                /** Optional band width in world units — the stroke widens into a road / aisle. */
-                readonly width: OptionType<FloatType>;
-            }>;
-            /** Closed, arc-aware polygon in world coords (>= 3 vertices, auto-closed). */
-            readonly polygon: StructType<{
-                /** Boundary vertices in world coords, in order (each carries a DXF bulge). */
-                readonly vertices: ArrayType<StructType<{
-                    /** World x */
-                    readonly x: FloatType;
-                    /** World y */
-                    readonly y: FloatType;
-                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`). */
-                    readonly bulge: FloatType;
-                }>>;
-            }>;
-        }>>;
-        /** Optional colour override (semantic tone); absent ⇒ `status` drives the colour */
-        readonly tone: OptionType<VariantType<{
-            /** Brand teal */
-            readonly brand: NullType;
-            /** Foreground ink */
-            readonly ink: NullType;
-            /** Muted foreground */
-            readonly muted: NullType;
-            /** Status ok */
-            readonly success: NullType;
-            /** Status warn */
-            readonly warning: NullType;
-            /** Status bad */
-            readonly danger: NullType;
-        }>>;
-        /** Optional raw CSS stroke / marker tint (e.g. `"#2D7FF9"`, `"teal"`); wins over `tone` */
-        readonly color: OptionType<StringType>;
-        /** Optional raw CSS fill for a polygon / circle footprint */
-        readonly bg: OptionType<StringType>;
-        /** Optional fill alpha (0–1) for a polygon / circle footprint */
-        readonly fillOpacity: OptionType<FloatType>;
-        /** Optional stroke width in px */
-        readonly weight: OptionType<FloatType>;
     }>>;
-    /** Annotation zones (rooms, cells, walkway bands) */
-    readonly zones: ArrayType<StructType<{
-        /** Zone identity */
+    /** Optional layer membership — hidden when its layer is hidden */
+    readonly layer: OptionType<StringType>;
+}>;
+/**
+ * Type representing a net (manifold / bus link).
+ */
+export type SchematicNetType = typeof SchematicNetType;
+/**
+ * Link-creation event passed to `onCreateLink` on every committed connect
+ * gesture.
+ *
+ * @remarks
+ * Connect gestures build a **session**: a plain drag starts a new session
+ * (one connection); a **Shift**+drag ADDS to the open session — mirroring
+ * Shift = "extend the set" in the selection modes — so an operation relating
+ * MORE than two items is built one visual link at a time. The event always
+ * carries the newest `link`, the FULL accumulated `links` session (newest
+ * included), whether the gesture was `additive` (Shift), and the keys of
+ * `existing` links already joining the newest pair (either direction).
+ *
+ * @property link - The newest connection (this drag)
+ * @property links - The full session set, `link` included (length 1 for a plain drag)
+ * @property net - The session collapsed to net endpoints (stable session `key` — upsert-friendly)
+ * @property additive - True when Shift extended an open session
+ * @property existing - Keys of links already joining the newest from↔to (either direction)
+ * @property absorbed - Keys of existing pairwise links absorbed into the session (selected-link seed)
+ */
+export declare const SchematicLinkCreateEventType: StructType<{
+    /** The newest connection (this drag). */
+    readonly link: StructType<{
+        /** Renderer-generated key for the gesture's connection. */
         readonly key: StringType;
-        /** Mono eyebrow label on the boundary */
-        readonly label: StringType;
-        /** World x of the top-left corner */
-        readonly x: FloatType;
-        /** World y of the top-left corner */
-        readonly y: FloatType;
-        /** World width */
-        readonly width: FloatType;
-        /** World height */
-        readonly height: FloatType;
-        /** Render pattern (`outline` / `hatch`) */
-        readonly pattern: VariantType<{
-            /** Dashed boundary with an eyebrow label (rooms, cells) */
-            readonly outline: StructType<{
-                /** Stroke tone (default `muted`) */
-                readonly tone: OptionType<VariantType<{
-                    /** Brand teal */
-                    readonly brand: NullType;
-                    /** Foreground ink */
-                    readonly ink: NullType;
-                    /** Muted foreground */
-                    readonly muted: NullType;
-                    /** Status ok */
-                    readonly success: NullType;
-                    /** Status warn */
-                    readonly warning: NullType;
-                    /** Status bad */
-                    readonly danger: NullType;
-                }>>;
-            }>;
-            /** Hatched band (walkways, aisles, exclusion strips) */
-            readonly hatch: StructType<{
-                /** Hatch-line tone (default `muted`) */
-                readonly tone: OptionType<VariantType<{
-                    /** Brand teal */
-                    readonly brand: NullType;
-                    /** Foreground ink */
-                    readonly ink: NullType;
-                    /** Muted foreground */
-                    readonly muted: NullType;
-                    /** Status ok */
-                    readonly success: NullType;
-                    /** Status warn */
-                    readonly warning: NullType;
-                    /** Status bad */
-                    readonly danger: NullType;
-                }>>;
-                /** Line spacing in pixels (default 8) */
-                readonly spacing: OptionType<FloatType>;
-                /** Line angle in degrees (default 45) */
-                readonly angle: OptionType<FloatType>;
-            }>;
-        }>;
-        /** Optional shape geometry; absent ⇒ rect (`x/y/width/height` stay the bounding box) */
-        readonly geometry: OptionType<VariantType<{
-            /** Axis-aligned box — zones use `x/y/width/height`; items, the point / marker form. */
-            readonly rect: NullType;
-            /** Circle centred on the entity anchor (item `x/y` or zone bbox centre); `radius` in world units. */
-            readonly circle: StructType<{
-                /** Circle radius in world units. */
-                readonly radius: FloatType;
-            }>;
-            /** Open, arc-aware polyline in world coords; optional world-space band width. */
-            readonly polyline: StructType<{
-                /** Vertices in world coords, in order (each carries a DXF bulge). */
-                readonly vertices: ArrayType<StructType<{
-                    /** World x */
-                    readonly x: FloatType;
-                    /** World y */
-                    readonly y: FloatType;
-                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`). */
-                    readonly bulge: FloatType;
-                }>>;
-                /** Optional band width in world units — the stroke widens into a road / aisle. */
-                readonly width: OptionType<FloatType>;
-            }>;
-            /** Closed, arc-aware polygon in world coords (>= 3 vertices, auto-closed). */
-            readonly polygon: StructType<{
-                /** Boundary vertices in world coords, in order (each carries a DXF bulge). */
-                readonly vertices: ArrayType<StructType<{
-                    /** World x */
-                    readonly x: FloatType;
-                    /** World y */
-                    readonly y: FloatType;
-                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`). */
-                    readonly bulge: FloatType;
-                }>>;
-            }>;
-        }>>;
-        /** Optional colour override (semantic tone); absent ⇒ the `pattern`'s tone drives the colour */
-        readonly tone: OptionType<VariantType<{
-            /** Brand teal */
-            readonly brand: NullType;
-            /** Foreground ink */
-            readonly ink: NullType;
-            /** Muted foreground */
-            readonly muted: NullType;
-            /** Status ok */
-            readonly success: NullType;
-            /** Status warn */
-            readonly warning: NullType;
-            /** Status bad */
-            readonly danger: NullType;
-        }>>;
-        /** Optional raw CSS stroke tint (e.g. `"#2D7FF9"`, `"teal"`); wins over `tone` */
-        readonly color: OptionType<StringType>;
-        /** Optional raw CSS area fill (opt-in; zones are unfilled by default) */
-        readonly bg: OptionType<StringType>;
-        /** Optional fill alpha (0–1) for the area fill */
-        readonly fillOpacity: OptionType<FloatType>;
-        /** Optional stroke width in px */
-        readonly weight: OptionType<FloatType>;
-    }>>;
-    /** Connections between items, addressed by key */
+        /** Source item key. */
+        readonly from: StringType;
+        /** Destination item key. */
+        readonly to: StringType;
+    }>;
+    /** The full session set, `link` included (length 1 for a plain drag). */
     readonly links: ArrayType<StructType<{
-        /** Link identity */
+        /** Renderer-generated key for the gesture's connection. */
         readonly key: StringType;
-        /** Source item key */
+        /** Source item key. */
         readonly from: StringType;
-        /** Destination item key */
+        /** Destination item key. */
         readonly to: StringType;
-        /** Render style (`solid` / `dashed`, with stroke config) */
-        readonly style: VariantType<{
-            /** A physical run (pipe, conveyor) */
-            readonly solid: StructType<{
-                /** Stroke tone (default `brand`) */
-                readonly tone: OptionType<VariantType<{
-                    /** Brand teal */
-                    readonly brand: NullType;
-                    /** Foreground ink */
-                    readonly ink: NullType;
-                    /** Muted foreground */
-                    readonly muted: NullType;
-                    /** Status ok */
-                    readonly success: NullType;
-                    /** Status warn */
-                    readonly warning: NullType;
-                    /** Status bad */
-                    readonly danger: NullType;
-                }>>;
-                /** Stroke width in pixels (default 2.5) */
-                readonly weight: OptionType<FloatType>;
-            }>;
-            /** A routing / logical connection */
-            readonly dashed: StructType<{
-                /** Stroke tone (default `muted`) */
-                readonly tone: OptionType<VariantType<{
-                    /** Brand teal */
-                    readonly brand: NullType;
-                    /** Foreground ink */
-                    readonly ink: NullType;
-                    /** Muted foreground */
-                    readonly muted: NullType;
-                    /** Status ok */
-                    readonly success: NullType;
-                    /** Status warn */
-                    readonly warning: NullType;
-                    /** Status bad */
-                    readonly danger: NullType;
-                }>>;
-                /** Stroke width in pixels (default 1.5) */
-                readonly weight: OptionType<FloatType>;
-            }>;
-        }>;
-        /** Routing mode (`orthogonal` / `direct`) */
-        readonly route: VariantType<{
-            /** Axis-aligned with rounded corners */
-            readonly orthogonal: StructType<{
-                /** Corner radius in pixels (default 8) */
-                readonly corner: OptionType<FloatType>;
-            }>;
-            /** Straight segments between anchors */
-            readonly direct: NullType;
-        }>;
-        /** Optional world-coordinate waypoints, in order */
-        readonly via: ArrayType<StructType<{
-            /** World x */
-            readonly x: FloatType;
-            /** World y */
-            readonly y: FloatType;
-        }>>;
-    }>>;
-    /** Optional unit for the bottom-right scale bar */
-    readonly scaleUnit: OptionType<StringType>;
-    /** Metric grid aligned to the scale legend; default on */
-    readonly grid: OptionType<BooleanType>;
-    /** Navigator rail (zones → items TOC); default: shown when zones exist */
-    readonly navigator: OptionType<BooleanType>;
-    /** Minimap with the viewport rectangle; default: shown for large canvases */
-    readonly minimap: OptionType<BooleanType>;
-    /** Optional Slice chrome — a full-width top-edge rail mounting the affordances (replaces the built-in search) */
-    readonly slice: OptionType<StructType<{
-        readonly slice: StructType<{
-            readonly key: StringType;
-            readonly read: FunctionType<[], StructType<{
-                readonly range: OptionType<VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: VariantType<{
-                        readonly today: 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<VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly lt: FloatType;
-                            readonly lte: FloatType;
-                            readonly gt: FloatType;
-                            readonly gte: FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly lt: FloatType;
-                                readonly lte: FloatType;
-                                readonly gt: FloatType;
-                                readonly gte: FloatType;
-                            }>;
-                        }>;
-                        readonly datetime: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-            }>>;
-            readonly write: FunctionType<[StructType<{
-                readonly range: OptionType<VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: VariantType<{
-                        readonly today: 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<VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly lt: FloatType;
-                            readonly lte: FloatType;
-                            readonly gt: FloatType;
-                            readonly gte: FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly lt: FloatType;
-                                readonly lte: FloatType;
-                                readonly gt: FloatType;
-                                readonly gte: FloatType;
-                            }>;
-                        }>;
-                        readonly datetime: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-            }>], NullType>;
-            readonly setRange: FunctionType<[OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: 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<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>], NullType>;
-            readonly addFilter: FunctionType<[VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: import("@elaraai/east").IntegerType;
-                        readonly neq: import("@elaraai/east").IntegerType;
-                        readonly lt: import("@elaraai/east").IntegerType;
-                        readonly lte: import("@elaraai/east").IntegerType;
-                        readonly gt: import("@elaraai/east").IntegerType;
-                        readonly gte: import("@elaraai/east").IntegerType;
-                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly lt: FloatType;
-                        readonly lte: FloatType;
-                        readonly gt: FloatType;
-                        readonly gte: FloatType;
-                    }>;
-                }>;
-                readonly datetime: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: BooleanType;
-                    }>;
-                }>;
-            }>], 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<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly lt: FloatType;
-                            readonly lte: FloatType;
-                            readonly gt: FloatType;
-                            readonly gte: FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>], NullType>;
-            readonly updateCohort: FunctionType<[StringType, StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly lt: FloatType;
-                            readonly lte: FloatType;
-                            readonly gt: FloatType;
-                            readonly gte: FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>], 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: 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<VariantType<{
-            readonly filter: NullType;
-            readonly search: NullType;
-            readonly breakdown: NullType;
-            readonly range: NullType;
-            readonly cohort: NullType;
-            readonly brush: NullType;
-        }>>;
     }>>;
-    /** Optional fixed panel height (any CSS length, e.g. `"400px"`); default: aspect-driven, capped at 75vh */
-    readonly height: OptionType<StringType>;
-    /** Optional item-click callback (receives the item key) */
-    readonly onSelect: OptionType<FunctionType<[StringType], NullType>>;
+    /** The session collapsed to net endpoints — upsert ONE net per session by `net.key`. */
+    readonly net: StructType<{
+        /** The session key (stable across the session's commits). */
+        readonly key: StringType;
+        /** Distinct source item keys so far. */
+        readonly sources: ArrayType<StringType>;
+        /** Distinct destination item keys so far. */
+        readonly destinations: ArrayType<StringType>;
+    }>;
+    /** True when Shift extended an open session. */
+    readonly additive: BooleanType;
+    /** Keys of links already joining the newest from↔to (either direction). */
+    readonly existing: ArrayType<StringType>;
+    /** Keys of EXISTING pairwise links absorbed into this session (a selected
+     *  link's Shift-drag seed) — delete these rows when upserting the net. */
+    readonly absorbed: ArrayType<StringType>;
+}>;
+/**
+ * Type representing a link-creation (connect gesture) event.
+ */
+export type SchematicLinkCreateEventType = typeof SchematicLinkCreateEventType;
+/**
+ * Link-edit event passed to `onEditLink` after an endpoint connector is
+ * dragged to a new item.
+ *
+ * @property key - The edited link's key
+ * @property from - Source item key AFTER the re-target
+ * @property to - Destination item key AFTER the re-target
+ */
+export declare const SchematicLinkEditEventType: StructType<{
+    /** The edited link's key. */
+    readonly key: StringType;
+    /** Source item key AFTER the re-target. */
+    readonly from: StringType;
+    /** Destination item key AFTER the re-target. */
+    readonly to: StringType;
+}>;
+/**
+ * Type representing a link-edit (re-target) event.
+ */
+export type SchematicLinkEditEventType = typeof SchematicLinkEditEventType;
+/**
+ * Item-move event passed to `onMoveItem` when a move-tool drag releases.
+ *
+ * @remarks
+ * When the dragged item is part of the current selection the WHOLE selection
+ * moves rigidly — `keys` lists every moved item (the pressed `key` included)
+ * and `dx`/`dy` is the shared world delta; `x`/`y` is the pressed item's
+ * final position. Fired once per gesture, on release.
+ *
+ * @property key - The pressed (dragged) item's key
+ * @property x - The pressed item's final world x
+ * @property y - The pressed item's final world y
+ * @property keys - Every item moved by the gesture (`key` included)
+ * @property dx - The gesture's world x delta (applies to all `keys`)
+ * @property dy - The gesture's world y delta (applies to all `keys`)
+ */
+export declare const SchematicItemMoveEventType: StructType<{
+    /** The pressed (dragged) item's key. */
+    readonly key: StringType;
+    /** The pressed item's final world x. */
+    readonly x: FloatType;
+    /** The pressed item's final world y. */
+    readonly y: FloatType;
+    /** Every item moved by the gesture (`key` included). */
+    readonly keys: ArrayType<StringType>;
+    /** The gesture's world x delta (applies to all `keys`). */
+    readonly dx: FloatType;
+    /** The gesture's world y delta (applies to all `keys`). */
+    readonly dy: FloatType;
 }>;
 /**
- * Type representing the Schematic component.
+ * Type representing an item-move event.
  */
-export type SchematicRootType = typeof SchematicRootType;
+export type SchematicItemMoveEventType = typeof SchematicItemMoveEventType;
 //# sourceMappingURL=types.d.ts.map