@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/models/NodeModel.d.ts

@@ -0,0 +1,666 @@
+import { DiagramEntity } from './DiagramEntity';
+import type { DiagramModel } from './DiagramModel';
+import { PortModel, SerializedPort } from './PortModel';
+import type { Point, Size, BoundingBox, NodeState, NodeBehavior, NodeStyle, SerializedEntity } from '../types';
+import type { TransformMatrix } from '../types/geometry.types';
+import type { FlexItemConfig, GridItemConfig } from '../types/layout.types';
+/**
+ * Positioning mode (Phase 1.6a)
+ * - absolute: Position relative to diagram origin (default, backward compatible)
+ * - relative: Position relative to parent
+ * - layout: Position managed by parent's layout algorithm (future)
+ */
+export type PositioningMode = 'absolute' | 'relative' | 'layout';
+/**
+ * wave14/model — the LAST-KNOWN ANCHOR of a node the diagram has REMOVED.
+ *
+ * A removed parent leaves soft refs behind by design (children's `parentId`, group
+ * `members`) — hard-clearing them would be irreversible under collab/undo, where the ref
+ * dangling and later RE-RESOLVING is exactly what makes undo-of-parent-delete restore
+ * children byte-identically (same argument as the link quarantine in collab/integrity.ts).
+ * The price of keeping the ref is that the position readers must TOLERATE it: without
+ * help, a relative child whose parent stopped resolving read its raw offset as world
+ * coordinates and visually JUMPED. This anchor is the help — everything the three parent
+ * frame readers (getWorldPosition / getGlobalPosition / getGlobalTransformMatrix) need to
+ * freeze an orphaned subtree exactly where the user last saw it. Captured by
+ * DiagramModel.removeNode() at the moment of removal; DERIVED, session-local, never
+ * serialized (a document loaded with a dangle has no anchor to freeze at — that is
+ * DiagramValidator's case, and the readers keep their deterministic raw-offset fallback).
+ */
+export interface DetachedParentAnchor {
+    /** getWorldPosition() at removal — the summed offset chain, world coords. */
+    world: Point;
+    /** getGlobalPosition() at removal — the transform-aware position. */
+    global: Point;
+    /** Local rotation at removal (getGlobalPosition composes against the parent's LOCAL rotation). */
+    rotation: number;
+    /** Local scale at removal (same reason). */
+    scale: Point;
+    /** getGlobalTransformMatrix() at removal — for getGlobalBounds and friends. */
+    matrix: TransformMatrix;
+}
+export interface SerializedNode extends SerializedEntity {
+    position: Point;
+    size: Size;
+    rotation: number;
+    scale: Point;
+    type: string;
+    systemType?: string;
+    definitionId?: string;
+    parentId?: string;
+    children: string[];
+    ports: SerializedPort[];
+    state: NodeState;
+    behavior: NodeBehavior;
+    style: Partial<NodeStyle>;
+    data: Record<string, any>;
+    positionMode?: PositioningMode;
+    transformOrigin?: Point;
+    /**
+     * Model-level stacking order. OMITTED when the node never set one, so every
+     * document written before this field existed round-trips byte-for-byte and no
+     * schema migration is needed — absence means "unset", not 0.
+     */
+    zIndex?: number;
+    flexConfig?: FlexItemConfig;
+    gridConfig?: GridItemConfig;
+    portRenderingConfig?: any;
+    dragHandlerConfig?: any;
+    connectionGroup?: string;
+}
+export declare class NodeModel extends DiagramEntity {
+    diagram?: DiagramModel;
+    /**
+     * Wave 9 — Card 7. Is a DOCUMENT write to this node forbidden right now?
+     * True only while the owning diagram is read-only and we are not inside a
+     * system write (auto-size / measurement). A detached node — one not yet added
+     * to any diagram — is freely mutable; `DiagramModel.addNode` is what refuses.
+     */
+    private writeBlocked;
+    /**
+     * D — is a DOCUMENT write to this node's GEOMETRY forbidden right now?
+     *
+     * `state.locked` used to be honoured by the input layers and by nothing else, so
+     * a "locked" node was moved without complaint by any command, script or importer
+     * that called `setPosition` — the same security-shaped lie the Wave-9 document
+     * lock was built to kill, one scope down.
+     *
+     * It draws exactly the Wave-9 distinction and for exactly the Wave-9 reason: a
+     * SYSTEM write (auto-size measuring text, a portal placing itself — anything
+     * inside `ReadonlyLock.runSystemWrite`) still passes, because refusing those
+     * renders a locked node at the wrong size and would have "worked" in a unit test
+     * while destroying the product.
+     *
+     * Scope is GEOMETRY only: position, size, rotation, scale. Style, data, classes,
+     * selection and `setState` itself stay open — you must be able to un-lock a
+     * locked node, and pinning a widget should not freeze its colour.
+     *
+     * A DETACHED node (no diagram back-reference) is freely mutable even with
+     * `locked` set: there is no document yet to protect, and you have to be able to
+     * BUILD a node before you can add it. Same tolerance `writeBlocked()` has.
+     */
+    private geometryWriteBlocked;
+    position: Point;
+    size: Size;
+    rotation: number;
+    scale: Point;
+    positionMode: PositioningMode;
+    transformOrigin: Point;
+    /**
+     * C — model-level stacking order (lower renders further back).
+     *
+     * `GroupModel` has had `zIndex` + `bringToFront`/`sendToBack` since Wave-5;
+     * nodes had nothing, so the only way to restack one was to write `style.zIndex`
+     * — a presentation field being used to carry a document fact, invisible to undo
+     * and to the diff/collab layers that watch `trackChange`.
+     *
+     * DELIBERATELY OPTIONAL, unlike the group's `zIndex = 0`. `undefined` means "this
+     * node never expressed an opinion", which is what lets {@link getEffectiveZIndex}
+     * fall through to the legacy `style.zIndex` the renderer already honoured, and
+     * what keeps `serialize()` byte-identical for every node that doesn't use it.
+     */
+    zIndex?: number;
+    flexConfig?: FlexItemConfig;
+    gridConfig?: GridItemConfig;
+    portRenderingConfig?: any;
+    dragHandlerConfig?: any;
+    connectionGroup?: string;
+    type: string;
+    systemType?: string;
+    definitionId?: string;
+    parentId?: string;
+    children: Set<string>;
+    depth: number;
+    ports: Map<string, PortModel>;
+    state: NodeState;
+    behavior: NodeBehavior;
+    style: Partial<NodeStyle>;
+    classes: Set<string>;
+    data: Record<string, any>;
+    computed: Map<string, any>;
+    constructor(config: {
+        id?: string;
+        type: string;
+        position: Point;
+        size?: Size;
+        systemType?: string;
+        definitionId?: string;
+    });
+    /**
+     * Initialize default ports (Phase 0.5.1)
+     * Creates 4 bidirectional ports (top, right, bottom, left) automatically
+     * This matches industry standards (Draw.io, Lucidchart, mxGraph, yFiles)
+     *
+     * Ports can be accessed via:
+     * - node.getPortBySide('top')
+     * - node.getPortsBySide('right')
+     * - node.getPorts() // all ports
+     */
+    private initializeDefaultPorts;
+    /**
+     * Set position
+     */
+    setPosition(x: number, y: number, z?: number): void;
+    /**
+     * Move by delta
+     */
+    move(dx: number, dy: number, dz?: number): void;
+    /**
+     * Set size.
+     *
+     * A — this used to be five lines that wrote a field and told NOBODY, while its
+     * sibling `setPosition` has propagated since Phase 1.6a. A node growing inside a
+     * flex/grid container is a layout-invalidating event: its siblings have to move.
+     *
+     * It notifies its LAYOUT CONTAINERS, and deliberately NOT the transform chain
+     * `setPosition` uses: a parent's size does not move a relative child (the child's
+     * offset is measured from the parent ORIGIN), so emitting `transform-propagated`
+     * here would be noise that says something untrue.
+     */
+    setSize(width: number, height: number, depth?: number): void;
+    /**
+     * A — tell every layout container that owns this node that its geometry moved.
+     *
+     * The re-entrancy this obviously invites (container lays out → writes a child's
+     * size → child notifies the container → …) is closed on the container side by
+     * `GroupModel.applyLayout`'s in-flight guard: a push that arrives DURING a pass
+     * is dropped, because that pass is already computing the answer it would ask for.
+     */
+    private notifyLayoutContainers;
+    /**
+     * Resize by delta
+     */
+    resize(dw: number, dh: number, dd?: number): void;
+    /**
+     * Set rotation
+     */
+    setRotation(degrees: number): void;
+    /**
+     * Rotate by delta
+     */
+    rotate(degrees: number): void;
+    /**
+     * Set scale
+     */
+    setScale(x: number, y: number): void;
+    /**
+     * Add port
+     */
+    addPort(port: PortModel): void;
+    /**
+     * Remove port
+     */
+    removePort(portId: string): PortModel | undefined;
+    /**
+     * Get port by ID
+     */
+    getPort(portId: string): PortModel | undefined;
+    /**
+     * Get all ports
+     */
+    getPorts(): PortModel[];
+    /**
+     * Links arriving at this node (resolved through the owning diagram; empty
+     * when the node isn't attached to a diagram yet)
+     */
+    getIncomingLinks(): import('./LinkModel').LinkModel[];
+    /**
+     * Links leaving this node (resolved through the owning diagram)
+     */
+    getOutgoingLinks(): import('./LinkModel').LinkModel[];
+    /**
+     * Get ports by type
+     */
+    getPortsByType(type: 'input' | 'output' | 'bi'): PortModel[];
+    /**
+     * Get port by side (Phase 0.5.1)
+     * Returns the first port found on the specified side
+     *
+     * @param side - The side to search ('top', 'right', 'bottom', 'left')
+     * @returns The first port on that side, or undefined if none found
+     */
+    getPortBySide(side: 'top' | 'right' | 'bottom' | 'left'): PortModel | undefined;
+    /**
+     * Get all ports on a specific side (Phase 0.5.1)
+     * Useful for nodes with multiple ports per side
+     *
+     * @param side - The side to search ('top', 'right', 'bottom', 'left')
+     * @returns Array of ports on that side, sorted by index
+     */
+    getPortsBySide(side: 'top' | 'right' | 'bottom' | 'left'): PortModel[];
+    /**
+     * Get available ports that can accept connections (Phase 0.5.1)
+     *
+     * @param type - Optional filter by port type ('input', 'output', 'bi')
+     * @returns Array of ports that can accept more connections
+     */
+    getAvailablePorts(type?: 'input' | 'output' | 'bi'): PortModel[];
+    /**
+     * Get ports that have active connections (Phase 0.5.1)
+     *
+     * @returns Array of ports with at least one connection
+     */
+    getConnectedPorts(): PortModel[];
+    /**
+     * Set state property
+     */
+    setState(state: Partial<NodeState>): void;
+    /**
+     * REPLACE the DOCUMENT half of `state`, keeping THIS viewer's own view half.
+     *
+     * The write `setState` cannot express, and the collab reducer's write path.
+     *
+     * ## Why a merge was wrong
+     *
+     * `state` is a value register: the op carries the whole (projected) object the author
+     * now holds. Applying it with the merging `setState` meant a peer could GAIN a key and
+     * never LOSE one — `NodeState.error`, `warning`, `status` and `animateStatus` are all
+     * optional, so the author clears an error badge and every other peer keeps it FOREVER,
+     * with no later edit able to correct it. Node `style` had exactly this defect and was
+     * fixed with `replaceStyle`; this is the same fix for the register next to it.
+     *
+     * ## Why it is not a plain wholesale replace either
+     *
+     * `selected` / `hovered` / `highlighted` / `focused` are facts about a VIEWER, not about
+     * the document. Capture strips them (see collab/capture.ts — syncing them meant your
+     * cursor lit up my node and your click deselected it), so an incoming register value
+     * never carries them. Replacing wholesale would therefore BLANK the receiving user's own
+     * selection on every remote state edit — reintroducing the very bug through the back
+     * door. So: durable keys replaced wholesale, view keys taken from what this replica
+     * already had.
+     *
+     * ## The read-only posture, deliberately UNCHANGED
+     *
+     * This refuses outright while the document is locked, exactly like `setPosition`,
+     * `setStyle` and `replaceStyle`. It does NOT copy `setState`'s Wave-9 Card-7 filter,
+     * and that is not an oversight:
+     *
+     *   • That filter exists so a LOCAL user can still select, hover and keyboard-navigate a
+     *     presentation-mode diagram. It is about input, not about the wire.
+     *   • It would be a no-op here anyway: capture strips the view keys, so an incoming
+     *     `state` value contains none of the keys the filter admits — a locked replica
+     *     already dropped remote state ops entirely, before this method existed. Behaviour
+     *     is therefore identical, and `setState` is left untouched.
+     *   • Making `state` the one register that DID reach a locked replica would be
+     *     incoherent: a read-only replica currently applies no remote document write at all
+     *     (verified — a locked peer ignores remote `position` and `style` too). That gap is
+     *     real and systemic, and it belongs to the lock, not to this register.
+     */
+    replaceState(state: Partial<NodeState>): void;
+    /**
+     * Set behavior property
+     */
+    setBehavior(behavior: Partial<NodeBehavior>): void;
+    /**
+     * Check if node is selected
+     */
+    isSelected(): boolean;
+    /**
+     * Set selection state
+     * @param selected - Whether the node should be selected
+     * @emits node:selected when node becomes selected
+     * @emits node:deselected when node becomes deselected
+     */
+    setSelected(selected: boolean): void;
+    /**
+     * Check if node is highlighted (attention state, independent of selection)
+     */
+    isHighlighted(): boolean;
+    /**
+     * Set highlight state (attention emphasis without selecting the node)
+     * @param highlighted - Whether the node should be highlighted
+     * @emits node:highlighted when node becomes highlighted
+     * @emits node:unhighlighted when node stops being highlighted
+     */
+    setHighlighted(highlighted: boolean): void;
+    /**
+     * Check if node is selectable (based on behavior)
+     * Note: Locked nodes are still selectable so users can unlock them
+     */
+    isSelectable(): boolean;
+    /**
+     * Check if node is draggable (based on behavior and state)
+     * Note: Locked nodes cannot be dragged
+     */
+    isDraggable(): boolean;
+    /**
+     * Set style property
+     */
+    setStyle(style: Partial<NodeStyle>): void;
+    /**
+     * REPLACE the whole style object — the write `setStyle` cannot express.
+     *
+     * `setStyle` merges, so it can add a key and overwrite a key but can never REMOVE
+     * one. Restoring a snapshot therefore has to assign wholesale, and the obvious way to
+     * do that — `node.style = snapshot` — is a plain field write that never passes
+     * `trackChange()`. That funnel is what collab captures from, so the direct assignment
+     * reaches the renderer (via markDirty) and reaches no other peer at all. That is not
+     * hypothetical: it is exactly how an undone LINK style stayed applied on every peer
+     * but the one that pressed Ctrl+Z. See collab/style-undo.spec.ts.
+     *
+     * Undo paths must use this, not the field.
+     */
+    replaceStyle(style: Partial<NodeStyle>): void;
+    /**
+     * Add CSS class
+     */
+    addClass(className: string): void;
+    /**
+     * Remove CSS class
+     */
+    removeClass(className: string): void;
+    /**
+     * REPLACE the whole class collection.
+     *
+     * `classes` is a `Set`, so it needs the same treatment `members` and `ports` needed: a
+     * register whose in-memory form is a collection and whose wire form is an array must be
+     * REBUILT on the receiving side, never assigned. The collab reducer writes it through
+     * here.
+     *
+     * A non-array is REFUSED rather than read as "no classes" — logs persisted before the
+     * funnel fix carry a bare class name (the old addClass) or a bare `null` (the old
+     * removeClass), and assigning either is what corrupted the Set in the first place.
+     */
+    setClasses(classNames: string[]): void;
+    /**
+     * Set data property
+     */
+    setData(key: string, value: any): void;
+    /**
+     * Get data property
+     */
+    getData(key: string): any;
+    /**
+     * Set computed property
+     */
+    setComputed(key: string, value: any): void;
+    /**
+     * Get computed property
+     */
+    getComputed(key: string): any;
+    /**
+     * Get world position (absolute coordinates accounting for parent chain)
+     * For nodes without parents, this is the same as position
+     * For child nodes, this walks up the parent chain and accumulates offsets
+     */
+    getWorldPosition(): Point;
+    /**
+     * Get bounding box in world coordinates
+     * For child nodes, this accounts for parent position
+     */
+    getBoundingBox(): BoundingBox;
+    /**
+     * Get center point in world coordinates
+     */
+    getCenter(): Point;
+    /**
+     * Check if point is inside node
+     */
+    containsPoint(point: Point): boolean;
+    /**
+     * Check if intersects with bounding box
+     */
+    intersectsBounds(bounds: BoundingBox): boolean;
+    /**
+     * Set parent
+     */
+    setParent(parentId: string | undefined): void;
+    /**
+     * Add child
+     */
+    addChild(childId: string): void;
+    /**
+     * Remove child
+     */
+    removeChild(childId: string): void;
+    /**
+     * REPLACE the whole child collection. The collab reducer's write path.
+     *
+     * Same contract as {@link setClasses}: a Set in memory, an array on the wire, rebuilt
+     * rather than assigned, and a non-array refused so a pre-fix log degrades instead of
+     * destroying the collection.
+     *
+     * This maintains only its own half of the hierarchy, exactly as `addChild`/`removeChild`
+     * do — the child's `parentId` is its own register with its own op.
+     */
+    setChildren(childIds: string[]): void;
+    /**
+     * Set transform origin (Phase 1.6a)
+     * @param x Normalized X coordinate (0-1)
+     * @param y Normalized Y coordinate (0-1)
+     */
+    setTransformOrigin(x: number, y: number): void;
+    /**
+     * Get absolute transform origin in pixels (Phase 1.6a)
+     */
+    getAbsoluteTransformOrigin(): Point;
+    /**
+     * Get local position (Phase 1.6a)
+     * Returns the position property as-is
+     */
+    getLocalPosition(): Point;
+    /**
+     * Get global position (Phase 1.6a)
+     * In absolute mode: returns position as-is
+     * In relative mode: transforms position by parent's hierarchy transform
+     */
+    getGlobalPosition(): Point;
+    /**
+     * Compose this node's global position from a parent FRAME (global position +
+     * local rotation/scale). For hierarchical positioning, apply:
+     * scale -> rotate -> translate (without transform origin offsets, which are
+     * for visual transforms). Shared by the live-parent path and the
+     * detached-anchor path of getGlobalPosition so the two can never disagree.
+     */
+    private composeGlobalFromParentFrame;
+    /**
+     * Set local position (Phase 1.6a)
+     * Sets position directly and switches to relative mode
+     */
+    setLocalPosition(x: number, y: number, z?: number): void;
+    /**
+     * Set global position (Phase 1.6a)
+     * Converts global coordinates to local if parent exists
+     */
+    setGlobalPosition(x: number, y: number, z?: number): void;
+    /**
+     * Inverse of {@link composeGlobalFromParentFrame}: write a GLOBAL point as a
+     * local offset against a parent frame. Shared by the live-parent path and the
+     * detached-anchor path of setGlobalPosition.
+     */
+    private setPositionFromGlobalInParentFrame;
+    /**
+     * Get local transform matrix (Phase 1.6a)
+     * Composes translation, rotation, and scale relative to transform origin
+     */
+    getLocalTransformMatrix(): TransformMatrix;
+    /**
+     * Get global transform matrix (Phase 1.6a)
+     * In absolute mode: returns local matrix
+     * In relative mode: composes parent's global matrix with local matrix
+     */
+    getGlobalTransformMatrix(): TransformMatrix;
+    /**
+     * Get global bounding box (Phase 1.6a)
+     * Calculates bounds by transforming all 4 corners through global matrix
+     */
+    getGlobalBounds(): BoundingBox;
+    /**
+     * Helper to get parent node (Phase 1.6a)
+     * Uses diagram reference to look up parent by ID
+     */
+    private getParentNode;
+    /**
+     * Get direct children nodes (Phase 1.6a Part 3)
+     */
+    getChildren(): NodeModel[];
+    /**
+     * Get parent node (Phase 1.6a Part 3)
+     * Public version of getParentNode
+     */
+    getParent(): NodeModel | undefined;
+    /**
+     * Get all ancestor nodes up to root (Phase 1.6a Part 3)
+     * Returns array with direct parent first, then grandparent, etc.
+     */
+    getAncestors(): NodeModel[];
+    /**
+     * Get all descendant nodes recursively (Phase 1.6a Part 3)
+     */
+    getDescendants(): NodeModel[];
+    /**
+     * Get root node of hierarchy (Phase 1.6a Part 3)
+     * Returns self if this is the root
+     */
+    getRoot(): NodeModel;
+    /**
+     * Get sibling nodes (same parent, excluding self) (Phase 1.6a Part 3)
+     */
+    getSiblings(): NodeModel[];
+    /**
+     * Check if this node is an ancestor of another node (Phase 1.6a Part 3)
+     * @param nodeId ID of node to check
+     * @returns true if this node is an ancestor of the given node
+     */
+    isAncestorOf(nodeId: string): boolean;
+    /**
+     * Get depth in hierarchy (Phase 1.6a Part 3)
+     * Root nodes have depth 0, their children have depth 1, etc.
+     * @returns depth level (0 = root)
+     */
+    getDepth(): number;
+    /**
+     * Validate hierarchy for circular references (Phase 1.6a Part 3)
+     * @returns true if hierarchy is valid (no cycles)
+     */
+    validateHierarchy(): boolean;
+    /**
+     * Update depth for this node and all descendants (Phase 1.6a Part 3)
+     * Recalculates depth values based on current hierarchy
+     */
+    updateHierarchyDepth(): void;
+    /**
+     * Get all nodes affected by transform changes (Phase 1.6a Part 4)
+     * Returns this node plus all descendants in relative positioning mode
+     * @returns Array of nodes that would be affected by this node's transform
+     */
+    getAffectedByTransform(): NodeModel[];
+    /**
+     * Emit transform propagation event (Phase 1.6a Part 4)
+     * Called after transform changes to notify renderers
+     */
+    private emitTransformPropagated;
+    /**
+     * The stacking index a renderer should paint by.
+     *
+     * Precedence is explicit-model-field → legacy `style.zIndex` → 0. That ordering
+     * is the whole compatibility story: diagrams that restacked via style keep
+     * working untouched, and the moment a node states a model z-index it wins — so
+     * `setZIndex(1)` on a node styled `zIndex: 4` does what it says instead of
+     * silently losing to a stylesheet.
+     */
+    getEffectiveZIndex(): number;
+    /** Set the stacking index (lower renders further back). Tracked for undo/diff. */
+    setZIndex(z: number | undefined): void;
+    /**
+     * Bring this node in front of every other node in the diagram.
+     * Falls back to a relative bump when the node is detached, exactly as
+     * `GroupModel.bringToFront` does.
+     */
+    bringToFront(diagram?: DiagramModel): void;
+    /** Send this node behind every other node in the diagram. */
+    sendToBack(diagram?: DiagramModel): void;
+    /**
+     * Set flexbox item configuration (Phase 1.7)
+     */
+    setFlexItem(config: FlexItemConfig): void;
+    /**
+     * Clear flexbox item configuration (Phase 1.7)
+     */
+    clearFlexItem(): void;
+    /**
+     * Get flexbox item configuration (Phase 1.7)
+     */
+    getFlexItem(): FlexItemConfig | undefined;
+    /**
+     * Check if node has flex item configuration (Phase 1.7)
+     */
+    hasFlexItem(): boolean;
+    /**
+     * Set grid item configuration (Phase 1.7)
+     */
+    setGridItem(config: GridItemConfig): void;
+    /**
+     * Clear grid item configuration (Phase 1.7)
+     */
+    clearGridItem(): void;
+    /**
+     * Get grid item configuration (Phase 1.7)
+     */
+    getGridItem(): GridItemConfig | undefined;
+    /**
+     * Check if node has grid item configuration (Phase 1.7)
+     */
+    hasGridItem(): boolean;
+    /**
+     * Set port rendering configuration (Phase 2)
+     */
+    setPortRenderingConfig(config: any): void;
+    /**
+     * Get port rendering configuration (Phase 2)
+     */
+    getPortRenderingConfig(): any | undefined;
+    /**
+     * Get port rendering mode (Phase 2)
+     * Auto-detects based on configuration and metadata
+     */
+    getPortRenderingMode(): 'svg' | 'html' | 'auto';
+    /**
+     * Set drag handler configuration (Phase 2)
+     */
+    setDragHandlerConfig(config: any): void;
+    /**
+     * Get drag handler configuration (Phase 2)
+     */
+    getDragHandlerConfig(): any | undefined;
+    /**
+     * Check if this node is a drag handler (Phase 2)
+     */
+    isDragHandler(): boolean;
+    /**
+     * Set connection group (Phase 2)
+     */
+    setConnectionGroup(group: string): void;
+    /**
+     * Get connection group (Phase 2)
+     */
+    getConnectionGroup(): string | undefined;
+    /**
+     * Serialize to JSON
+     */
+    serialize(): SerializedNode;
+    /**
+     * Deserialize from JSON
+     */
+    static fromJSON(data: SerializedNode): NodeModel;
+}