@grafloria/element 0.3.20 → 0.3.21

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

@@ -1,666 +0,0 @@
-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;
-}