@petrarca/sonnet-graph 0.4.2 → 0.5.0

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 import * as zustand from 'zustand';
 import { UseBoundStore, StoreApi } from 'zustand';
-import * as react from 'react';
-import react__default, { ReactNode } from 'react';
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
 import { GraphEdge, GraphNode } from 'reagraph';
 import cytoscape from 'cytoscape';
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import { z } from 'zod';
+import { JsonSchema, UISchema } from '@petrarca/sonnet-core/schema';
+import { WidgetRegistry } from '@petrarca/sonnet-forms';
 
 /**
  * Visual Graph Model - Domain types combining API data with UI enrichment.
@@ -426,6 +429,9 @@ interface GraphFilterStore {
     clearNodeLabelFilters: () => void;
     setNodeLabelFilters: (labels: string[]) => void;
     toggleAllLabelsDisabled: () => void;
+    setAllLabelsDisabled: (disabled: boolean) => void;
+    /** Atomically update both allLabelsDisabled and nodeLabelFilters in one write. */
+    setNodeFilterState: (disabled: boolean, filters: string[]) => void;
     edgeLabelFilters: string[];
     allEdgeLabelsDisabled: boolean;
     toggleEdgeLabelFilter: (label: string, allAvailableLabels?: string[], edgeToNodeLabels?: Record<string, string[]>) => void;
@@ -685,9 +691,9 @@ interface WorkspaceStores {
 
 /**
  * Context for providing graph stores to visualization components.
- * Must be set by the host application (e.g., explorer, Atlas).
+ * Must be set by the host application (e.g., a graph explorer or consumer app).
  */
-declare const GraphStoresContext: react.Context<WorkspaceStores | null>;
+declare const GraphStoresContext: React.Context<WorkspaceStores | null>;
 /** Get GraphFilter store from context. */
 declare function useWorkspaceGraphFilter(): UseBoundStore<StoreApi<GraphFilterStore>>;
 /** Get GraphData store from context. */
@@ -697,6 +703,9 @@ declare function useWorkspaceGraphExploration(): UseBoundStore<StoreApi<GraphExp
 /** Get Selection store from context. */
 declare function useWorkspaceSelection(): UseBoundStore<StoreApi<SelectionStore>>;
 
+declare function useStableRef<T extends (...args: never[]) => unknown>(fn: T): T;
+declare function useStableRef<T extends (...args: never[]) => unknown>(fn: T | undefined): T | undefined;
+
 /**
  * Result type for useLiveGraphData hook.
  *
@@ -825,7 +834,7 @@ type GraphRendererContextType = {
 declare function useGraphRenderer(): GraphRendererContextType;
 
 type ProviderProps = {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     /**
      * Initial renderer to use. Defaults to 'cytoscape'.
      * The host application controls which renderer is active — typically
@@ -838,7 +847,7 @@ type ProviderProps = {
      */
     onRendererChange?: (renderer: GraphRenderer) => void;
 };
-declare function GraphRendererProvider({ children, defaultRenderer, onRendererChange, }: ProviderProps): react__default.ReactElement;
+declare function GraphRendererProvider({ children, defaultRenderer, onRendererChange, }: ProviderProps): React__default.ReactElement;
 
 interface GraphVisualizerProps {
     /** Callback when a node is copied (e.g. to clipboard). Decouples renderers from clipboard store. */
@@ -866,7 +875,19 @@ type Props = {
 };
 declare function EdgeInfoCard({ edge }: Props): react_jsx_runtime.JSX.Element;
 
-declare function Overview(): react_jsx_runtime.JSX.Element | null;
+/** A named group of node labels shown as its own legend sub-section. */
+interface NodeLabelBucket {
+    title: string;
+    /** Node labels in this bucket; only those present in the graph are shown. */
+    labels: string[];
+}
+interface OverviewProps {
+    /** Split the node section into named buckets (default: one "Node Labels"). */
+    nodeBuckets?: NodeLabelBucket[];
+    /** Heading for the edge (arrow) section. Default "Relations". */
+    edgeSectionTitle?: string;
+}
+declare function Overview({ nodeBuckets, edgeSectionTitle }?: OverviewProps): react_jsx_runtime.JSX.Element | null;
 
 interface GraphA11yListProps {
     /** Render on-screen instead of visually-hidden (still a11y-present). */
@@ -879,4 +900,1045 @@ interface GraphA11yListProps {
 }
 declare function GraphA11yList({ visible, rowHeight, maxHeight, className, }: GraphA11yListProps): react_jsx_runtime.JSX.Element;
 
-export { ActionPanel, type ActionPanelState, type ActionPanelStore, type ColorPalette, EMPTY_NORMALIZED, EdgeInfoCard, type EdgeVisual, type ExpandOptions, type ExpandResult, GraphA11yList, type GraphA11yListProps, type GraphDataHook, type GraphDataStore, type GraphDisplayConfig, type GraphExplorationDeps, type GraphExplorationStore, type GraphFilterStore, type GraphFocusAction, type GraphFocusStore, type GraphProperties, type GraphProperty, type GraphRenderer, GraphRendererProvider, type GraphStatistics, type WorkspaceStores as GraphStoreBundle, GraphStoresContext, GraphVisualizer, type GraphVisualizerProps, type LabelDisplayMap, type LiveGraphDataResult, NodeInfoCard, type NodeVisual, type NormalizedGraph, Overview, type RawGraphEdge, type RawGraphNode, type SelectionStore, type StoreFactory, type VisualGraphEdge, type VisualGraphNode, type VisualGraphNormalized, type WorkspaceStores, buildColorPalette, buildColorPaletteFromNodes, createActionPanelStore, createGraphDataStore, createGraphExplorationStore, createGraphFilterStore, createGraphFocusStore, createSelectionStore, enrichEdge, enrichEdges, enrichNode, enrichNodes, extractDisplayLabel, isRawGraphNode, isVisualEdge, isVisualNode, normalizeGraph, toCytoscapeEdge, toCytoscapeNode, toReagraphEdge, toReagraphNode, useActionPanelStore, useCytoscapeData, useGraphFocus, useGraphRenderer, useLiveGraphData, useReagraphData, useWorkspaceGraphData, useWorkspaceGraphExploration, useWorkspaceGraphFilter, useWorkspaceSelection };
+/**
+ * Graph model (metamodel) types.
+ *
+ * A graph model is a list of type schemas, each a JSON Schema carrying an
+ * `x-graph` extension that declares whether it is a node or edge type, its
+ * graph label, and (for node types) the valid outbound relations. This mirrors
+ * the shape consumed by cypher-graphdb-core, so a model authored here is a
+ * valid model there.
+ *
+ * The model is the source of truth. It is rendered as a graph of node-types and
+ * relation-edges via `modelToGraph` + `GraphVisualizer`; there is no reverse
+ * conversion.
+ */
+/** Relation cardinality. Binary only, matching the core model. */
+type Cardinality = "ONE_TO_ONE" | "ONE_TO_MANY";
+/**
+ * A valid outbound relation from a node type. Directional: the triple is
+ * (owning type, rel_type_name, to_type_name). Asymmetry is the default --
+ * declare the reverse relation explicitly if it is also valid.
+ */
+interface GraphRelation {
+    /** Relation/edge label, e.g. "partOf". */
+    rel_type_name: string;
+    /** Target node-type label. */
+    to_type_name: string;
+    /** Binary cardinality. Defaults to ONE_TO_MANY when omitted. */
+    cardinality?: Cardinality;
+    /** Whether the relation is surfaced as a form field (consumer hint). */
+    form_field?: boolean;
+    description?: string;
+}
+/** Optional display configuration for a type (how instances are labelled). */
+interface GraphModelDisplay {
+    labelTemplate?: string;
+    labelProperty?: string;
+    fallbackProperty?: string;
+    sortProperty?: string;
+    sortOrder?: "ASC" | "DESC";
+    filterProperty?: string;
+}
+/** The `x-graph` extension on a type schema. */
+interface XGraph {
+    /** NODE types carry relations; EDGE types define relationship properties. */
+    type: "NODE" | "EDGE";
+    /** The authoritative graph label, e.g. "Hospital" or "partOf". */
+    label: string;
+    /** Allowed outbound relations (node types only). */
+    relations?: GraphRelation[];
+    /** Parent type labels this type inherits from. */
+    inherits_from?: string[];
+    display?: GraphModelDisplay;
+    /** Free-form metadata preserved on round-trip. */
+    metadata?: Record<string, unknown>;
+    source?: string;
+}
+/**
+ * A single property definition within a type schema. A pragmatic subset of
+ * JSON Schema; unknown keys are preserved.
+ */
+interface GraphModelProperty {
+    type?: string | string[];
+    title?: string;
+    description?: string;
+    enum?: Array<string | number>;
+    format?: string;
+    default?: unknown;
+    items?: GraphModelProperty;
+    [key: string]: unknown;
+}
+/**
+ * One type in the model: a JSON Schema object with an `x-graph` extension.
+ * Additional `x-*` extension keys are allowed and preserved.
+ */
+interface GraphTypeSchema {
+    title?: string;
+    type: "object";
+    properties?: Record<string, GraphModelProperty>;
+    required?: string[];
+    "x-graph": XGraph;
+    [key: string]: unknown;
+}
+/** A graph model: the list of node/edge type schemas. */
+type GraphModel = GraphTypeSchema[];
+/** Type guard: is this type schema a node type (vs an edge type). */
+declare function isNodeType(schema: GraphTypeSchema): boolean;
+/** Type guard: is this type schema an edge type (vs a node type). */
+declare function isEdgeType(schema: GraphTypeSchema): boolean;
+/** The graph label of a type schema (x-graph.label, falling back to title). */
+declare function typeLabel(schema: GraphTypeSchema): string;
+
+/**
+ * Convert a graph model (metamodel) into renderable nodes and edges.
+ *
+ * Forward conversion only: a `GraphModel` becomes a graph of node-type nodes
+ * and relation/inheritance edges, suitable for `enrichNodes` / `enrichEdges`
+ * and `GraphVisualizer`. The model JSON is the source of truth; there is no
+ * reverse conversion.
+ *
+ * Ports cypher-graphdb-core's `json_schemas_to_graph` with two deliberate
+ * differences:
+ *  - Node/edge ids are derived deterministically from type/relation names so
+ *    the same model always yields the same ids (required for visualizer merge,
+ *    dedup, and stable selection).
+ *  - A node's `label_` is the type label itself (e.g. "Hospital"), so the
+ *    legend colours and filters by type. `x-graph.type` still distinguishes
+ *    node from edge type schemas.
+ */
+
+/** The output of modelToGraph: renderable nodes + edges. */
+interface ModelGraph {
+    nodes: RawGraphNode[];
+    edges: RawGraphEdge[];
+}
+/**
+ * Convert a graph model into renderable nodes and edges.
+ *
+ * Both node types and edge types become canvas nodes. Node types carry the
+ * `x-graph.relations[*]` arrows between them (plus `inherits_from` arrows).
+ * Edge types are rendered as standalone nodes (the catalog of relationship
+ * types); they are not connected by arrows. Relation arrows only connect node
+ * types, so relations whose target is not a node type are skipped.
+ */
+declare function modelToGraph(model: GraphModel): ModelGraph;
+
+/**
+ * Canvas label-filter reconciliation for the model editor.
+ *
+ * The graph filter is an allowlist of node labels: empty = show all; non-empty
+ * = show only those labels. The model editor uses it to optionally hide
+ * edge-type nodes (showEdgeTypes) while keeping the user's show/hide choices
+ * stable across model edits.
+ */
+
+/**
+ * Reconcile the node-label allowlist after a model load.
+ *
+ *  - baselineReset (first load or showEdgeTypes toggled): set the baseline --
+ *    show all (empty) when showEdgeTypes is true, otherwise allow only
+ *    node-type labels so edge types are hidden.
+ *  - Otherwise (a model edit): preserve the user's current filter, but drop
+ *    labels that no longer exist and add any new node-type labels so a
+ *    just-created node type is visible. An empty filter ("show all") stays
+ *    empty -- we never spontaneously start hiding what the user chose to show.
+ */
+declare function reconcileFilter(current: string[], model: GraphModel, baselineReset: boolean, showEdgeTypes: boolean): string[];
+
+/**
+ * GraphModelEditor capabilities -- a single structure that gates what can be
+ * edited. Consumers pass `capabilities` to tailor the editor (e.g. an
+ * organization-model profile that hides node properties). `readOnly` is a
+ * shorthand for the fully-locked capabilities.
+ *
+ * This module is the single source of truth: the Zod schema below defines the
+ * shape, the TypeScript type is inferred from it (`z.infer`), the JSON Schema
+ * is generated from it (see `capabilities.schema.ts` / the generate script),
+ * and `validateCapabilities` validates hand-authored / external JSON at the
+ * boundary. Every field is optional and defaults to the most permissive value,
+ * so adding a new capability never tightens an existing consumer's profile
+ * (forward compatible).
+ */
+
+/**
+ * Mode for a section that can be edited, shown read-only, or dropped entirely.
+ * "hidden" omits the section (meaningful only where there is a section to drop,
+ * e.g. properties -- not for node types, which are the canvas nodes).
+ */
+type EditMode$1 = "edit" | "readonly" | "hidden";
+/** Mode for a structural area that is always present (cannot be hidden). */
+type EditableMode = "edit" | "readonly";
+/**
+ * Mode for the edge-type catalog when creating relations.
+ *  - "edit": pick an existing edge type or create a new one inline.
+ *  - "catalog": pick only from existing edge types (the catalog passed in the
+ *    model); creating new edge types is not allowed.
+ *  - "readonly": no changes (view only).
+ */
+type EdgeTypeMode = "edit" | "catalog" | "readonly";
+/**
+ * The capabilities schema. Each field is optional with a permissive default;
+ * `.meta({ description })` is carried through to the generated JSON Schema.
+ */
+declare const capabilitiesSchema: z.ZodObject<{
+    nodeTypes: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    edgeTypes: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+        catalog: "catalog";
+    }>>;
+    nodeProperties: z.ZodDefault<z.ZodEnum<{
+        hidden: "hidden";
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    edgeProperties: z.ZodDefault<z.ZodEnum<{
+        hidden: "hidden";
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    relations: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    showEdgeTypes: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * The capabilities a consumer may pass. Inferred from the schema; with all
+ * fields optional on input (defaults are applied by resolveCapabilities).
+ */
+type GraphModelCapabilities = z.input<typeof capabilitiesSchema>;
+/** The fully-resolved capabilities (every field present). */
+type ResolvedCapabilities = z.output<typeof capabilitiesSchema>;
+/**
+ * Resolve the effective capabilities: readOnly wins (everything locked),
+ * otherwise parse the provided capabilities (applying per-field defaults).
+ * Invalid input falls back to the permissive defaults rather than throwing --
+ * use validateCapabilities to surface errors at a boundary.
+ */
+declare function resolveCapabilities(capabilities: GraphModelCapabilities | undefined, readOnly: boolean | undefined): ResolvedCapabilities;
+/** Result of validating an untrusted capabilities object. */
+type CapabilitiesValidation = {
+    ok: true;
+    value: ResolvedCapabilities;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validate a hand-authored / external capabilities object (e.g. parsed from a
+ * per-tenant config JSON). Returns the resolved value or a list of readable
+ * error messages. Does not throw.
+ */
+declare function validateCapabilities(input: unknown): CapabilitiesValidation;
+
+/**
+ * GraphModelEditor -- view and edit a graph model (metamodel).
+ *
+ * A controlled component over the model JSON: pass a `GraphModel` in, render it
+ * as a graph of node-types and relation-edges via `GraphVisualizer`, and (when
+ * authoring lands) emit an edited model through `onChange`. Read-only is a mode
+ * of the same component.
+ *
+ * Rendering reuses the existing visualizer: the model is converted with
+ * `modelToGraph`, enriched, and pushed into a per-instance workspace store.
+ */
+
+interface GraphModelEditorProps {
+    /** The graph model to view/edit. Controlled. */
+    value: GraphModel;
+    /**
+     * Called with the edited model. Omit (or set readOnly) for a view-only
+     * editor.
+     */
+    onChange?: (model: GraphModel) => void;
+    /** View-only: no edit affordances, onChange never fires. Shorthand for
+     * fully-locked capabilities. */
+    readOnly?: boolean;
+    /** Fine-grained gating of what can be edited. Merged onto full-edit
+     * defaults; readOnly overrides to fully locked. */
+    capabilities?: GraphModelCapabilities;
+    /** Allowed x-ui-widget values offered when editing a property. */
+    widgetOptions?: string[];
+    /** Default graph renderer. */
+    defaultRenderer?: GraphRenderer;
+    /** Hide the side panel (node/edge detail + overview legend). */
+    hideActionPanel?: boolean;
+}
+declare function GraphModelEditor({ value, readOnly, capabilities, onChange, widgetOptions, defaultRenderer, hideActionPanel, }: GraphModelEditorProps): React__default.ReactElement;
+
+/**
+ * Type-view parser: turn a graph model + a selection into clean, readable
+ * structured data for the detail panel.
+ *
+ * The model JSON is low-level (JSON Schema + x-graph). This module resolves a
+ * selected node type or relation arrow into a flat shape the panel renders --
+ * hiding mechanics (gid_, raw nested schema) and joining a relation arrow to
+ * its hidden edge type so the relation's properties surface on the arrow.
+ */
+
+/** One property of a type, flattened for display. */
+interface PropertyView {
+    /** Property key. */
+    name: string;
+    /** JSON Schema type (e.g. "string", "integer"); "object" when absent. */
+    type: string;
+    required: boolean;
+    title?: string;
+    description?: string;
+    /** x-ui-widget, if set on the property. */
+    widget?: string;
+    enum?: Array<string | number>;
+}
+/** One relation declared on a node type, flattened for display. */
+interface RelationView {
+    relType: string;
+    target: string;
+    cardinality: Cardinality;
+    description?: string;
+}
+/** View of a selected node type. */
+interface NodeTypeView {
+    kind: "node";
+    label: string;
+    description?: string;
+    properties: PropertyView[];
+    relations: RelationView[];
+}
+/**
+ * View of a selected edge type (a catalog entry). An edge type carries only
+ * identity and properties -- it has no relations of its own (relations are
+ * declared on node types and reference an edge type by label).
+ */
+interface EdgeTypeView {
+    kind: "edge";
+    label: string;
+    description?: string;
+    properties: PropertyView[];
+}
+/**
+ * View of a selected relation arrow. Properties are joined from the relation's
+ * hidden edge type (the edge-type schema whose label === relType), if one
+ * exists; otherwise the relation simply has no properties yet.
+ */
+interface RelationDetailView {
+    kind: "relation";
+    relType: string;
+    source: string;
+    target: string;
+    cardinality: Cardinality;
+    description?: string;
+    /** Whether a hidden edge type backs this relation's properties. */
+    hasEdgeType: boolean;
+    properties: PropertyView[];
+}
+/** Human-readable label for a cardinality value. */
+declare function cardinalityLabel(c: Cardinality): string;
+/** Find a type schema by its graph label. */
+declare function findType(model: GraphModel, label: string): GraphTypeSchema | undefined;
+/** Find the (hidden) edge type backing a relation type, if any. */
+declare function findEdgeType(model: GraphModel, relType: string): GraphTypeSchema | undefined;
+/**
+ * Resolve a selected relation edge into (source, relType, target).
+ *
+ * The converter sets each relation edge's `label_` to the relation type and its
+ * `gid_` to `schema:rel:<source>\0<target>`, using NUL as a separator so node
+ * type labels that contain colons parse unambiguously. INHERITS_FROM_ edges are
+ * not relations and resolve to null.
+ */
+declare function resolveRelationEdge(edge: {
+    label_: string;
+    properties_?: Record<string, unknown>;
+}): {
+    source: string;
+    relType: string;
+    target: string;
+} | null;
+/** Build the view for a selected node type. Returns null if not a node type. */
+declare function nodeTypeView(model: GraphModel, label: string): NodeTypeView | null;
+/**
+ * Build the view for a selected edge type. Returns null if the label does not
+ * resolve to an edge type. An edge type's properties are the relation
+ * properties shared by every relation of this type.
+ */
+declare function edgeTypeView(model: GraphModel, label: string): EdgeTypeView | null;
+/**
+ * Build the view for a selected relation arrow. `source` is the owning node
+ * type label, `relType` the relation type, `target` the target node label.
+ * Properties are joined from the hidden edge type, if present.
+ */
+declare function relationView(model: GraphModel, source: string, relType: string, target: string): RelationDetailView | null;
+
+/**
+ * TypeDetailPanel -- detail for a selected metamodel element.
+ *
+ * Renders either a node type (Identity + Properties + Relations) or a relation
+ * arrow (Identity + endpoints + Properties joined from the relation's hidden
+ * edge type). Uniform Properties presentation for both. When not readOnly and
+ * capabilities allow, properties can be added / edited / deleted; mutations
+ * edit the model and are emitted via onChange.
+ */
+
+interface TypeDetailPanelProps {
+    model: GraphModel;
+    /** The selected element: a node type, an edge type, or a relation arrow. */
+    selection: {
+        kind: "node";
+        label: string;
+    } | {
+        kind: "edge";
+        label: string;
+    } | {
+        kind: "relation";
+        source: string;
+        relType: string;
+        target: string;
+    };
+    onChange?: (model: GraphModel) => void;
+    readOnly?: boolean;
+    /** Resolved capabilities (gating per area). */
+    capabilities?: ResolvedCapabilities;
+    /** Allowed x-ui-widget values offered in the property form. */
+    widgetOptions?: string[];
+}
+declare function TypeDetailPanel({ model, selection, onChange, readOnly, capabilities, widgetOptions, }: TypeDetailPanelProps): React__default.ReactElement | null;
+
+/**
+ * ModelActionPanel -- selection-aware detail panel for the model editor.
+ *
+ * Renders, from the current model + workspace selection:
+ *   - a relation's detail when a relation arrow is selected,
+ *   - two node types selected => a "Create relation" prompt (select-two-then-link),
+ *   - a single node type's detail when one node is selected,
+ *   - the Overview legend when nothing is selected.
+ *
+ * Editing flows through onChange (controlled). Replaces the generic ActionPanel
+ * inside GraphModelEditor; the instance-graph ActionPanel is unchanged.
+ */
+
+interface ModelActionPanelProps {
+    model: GraphModel;
+    onChange?: (model: GraphModel) => void;
+    readOnly?: boolean;
+    capabilities?: GraphModelCapabilities;
+    widgetOptions?: string[];
+}
+declare function ModelActionPanel({ model, onChange, readOnly, capabilities, widgetOptions, }: ModelActionPanelProps): React__default.ReactElement;
+
+/**
+ * Pure model mutations. Each takes a GraphModel and returns a new GraphModel
+ * (immutable); GraphModelEditor is controlled, so callers pass the result to
+ * onChange. No mutation touches the input.
+ *
+ * Properties live on a type schema's `properties` (+ `required`). A relation's
+ * properties live on its hidden edge type (the EDGE schema whose label === the
+ * relation type); that edge type is created lazily when a relation gains its
+ * first property and removed when it loses its last.
+ */
+
+/** A property definition as edited in the form. */
+interface PropertyInput {
+    name: string;
+    type: string;
+    required: boolean;
+    title?: string;
+    description?: string;
+    widget?: string;
+    enum?: Array<string | number>;
+}
+/**
+ * Add or update a property on a node type. `prevName` set => rename/update that
+ * property; omitted => add `input.name`.
+ */
+declare function setNodeProperty(model: GraphModel, typeLabel_: string, input: PropertyInput, prevName?: string): GraphModel;
+/** Delete a property from a node type. */
+declare function deleteNodeProperty(model: GraphModel, typeLabel_: string, name: string): GraphModel;
+/**
+ * Add or update a property on a relation. Properties are stored on the
+ * relation's hidden edge type, which is created lazily here if absent.
+ */
+declare function setRelationProperty(model: GraphModel, relType: string, input: PropertyInput, prevName?: string): GraphModel;
+/**
+ * Delete a property from a relation. If that was the relation's last property,
+ * the now-empty hidden edge type is removed entirely.
+ */
+declare function deleteRelationProperty(model: GraphModel, relType: string, name: string): GraphModel;
+/**
+ * Add or update a property on an edge type selected directly (by its label).
+ * Unlike setRelationProperty this never creates the edge type -- it must
+ * already exist -- and is used when an edge-type node is selected on the canvas.
+ */
+declare function setEdgeTypeProperty(model: GraphModel, edgeLabel: string, input: PropertyInput, prevName?: string): GraphModel;
+/**
+ * Delete a property from an edge type selected directly. Unlike
+ * deleteRelationProperty this keeps the edge type even when it becomes empty:
+ * an explicitly-created edge type stays in the catalog with no properties.
+ */
+declare function deleteEdgeTypeProperty(model: GraphModel, edgeLabel: string, name: string): GraphModel;
+/** Add a new, empty edge type to the catalog. No-op if the label exists. */
+declare function addEdgeType(model: GraphModel, label: string): GraphModel;
+/** A relation definition as edited in the form. */
+interface RelationInput {
+    relType: string;
+    target: string;
+    cardinality: Cardinality;
+    description?: string;
+}
+/**
+ * Add a relation to a node type's x-graph.relations. No-op if an identical
+ * (relType, target) relation already exists on that source.
+ */
+declare function addRelation(model: GraphModel, source: string, input: RelationInput): GraphModel;
+/** Update an existing relation (matched by source + prev relType/target). */
+declare function updateRelation(model: GraphModel, source: string, prevRelType: string, prevTarget: string, input: RelationInput): GraphModel;
+/** Add a new, empty node type. No-op if the label already exists. */
+declare function addNodeType(model: GraphModel, label: string): GraphModel;
+/**
+ * Rename a node type, updating every reference: the type's own label/title and
+ * any relation `to_type_name` (and `inherits_from`) that pointed at the old
+ * label. No-op if newLabel already exists.
+ */
+declare function renameNodeType(model: GraphModel, oldLabel: string, newLabel: string): GraphModel;
+/**
+ * Delete a node type and clean up references: removes the type, plus any
+ * relations (on other types) that target it and any inherits_from entries.
+ */
+declare function deleteNodeType(model: GraphModel, label: string): GraphModel;
+/** Remove a relation from a node type. */
+declare function deleteRelation(model: GraphModel, source: string, relType: string, target: string): GraphModel;
+/**
+ * Rename an edge type, updating every relation `rel_type_name` that referenced
+ * the old label so those relations keep pointing at the (now renamed) edge
+ * type. No-op if newLabel already exists or there is no such edge type.
+ */
+declare function renameEdgeType(model: GraphModel, oldLabel: string, newLabel: string): GraphModel;
+/**
+ * Delete an edge type from the catalog. Relations that referenced it remain as
+ * bare-label relations (edge types are optional); only the catalog entry and
+ * its shared properties are removed.
+ */
+declare function deleteEdgeType(model: GraphModel, label: string): GraphModel;
+
+/**
+ * PropertyFormSheet -- add/edit a single property definition.
+ *
+ * A property definition (name, type, required, title, description, widget) is
+ * itself a small object, so it is edited with a schema-driven form
+ * (JsonSchemaFormRenderer) over a property meta-schema, inside a Sheet. The
+ * widget choice (x-ui-widget) is the extensibility hook; consumers can extend
+ * the allowed widget list via `widgetOptions`.
+ */
+
+interface PropertyFormSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The property being edited; omit for add. */
+    property?: PropertyView;
+    /** Owner label for the title (a type or relation name). */
+    ownerLabel: string;
+    /** Allowed x-ui-widget values; "default" is always included first. */
+    widgetOptions?: string[];
+    /** Called with the property input on save; the sheet closes after. */
+    onSave: (input: PropertyInput, prevName?: string) => void;
+}
+declare function PropertyFormSheet({ open, onOpenChange, property, ownerLabel, widgetOptions, onSave, }: PropertyFormSheetProps): React__default.ReactElement;
+
+/**
+ * RelationFormSheet -- create or edit a relation between two node types.
+ *
+ * Used by the select-two-then-link flow (create) and the relation edit action.
+ * The endpoints are fixed by the selection / existing relation; the form edits
+ * the relation type, direction (swap source/target), and cardinality.
+ */
+
+interface RelationFormSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The two endpoints; the first is the initial source. */
+    nodeA: string;
+    nodeB: string;
+    /** Existing relation values when editing. */
+    initial?: {
+        relType: string;
+        cardinality: Cardinality;
+    };
+    /**
+     * Existing edge-type labels (the catalog) offered for the relation type.
+     * The user selects one of these; in "edit" mode a new one can be created.
+     */
+    edgeTypeOptions: string[];
+    /**
+     * Edge-type governance. "edit": select or create; "catalog": select only
+     * from edgeTypeOptions; "readonly": no create. Default "edit".
+     */
+    edgeTypeMode?: EdgeTypeMode;
+    /** Save handler: (source, target, input). Sheet closes after. */
+    onSave: (source: string, target: string, input: RelationInput) => void;
+}
+declare function RelationFormSheet({ open, onOpenChange, nodeA, nodeB, initial, edgeTypeOptions, edgeTypeMode, onSave, }: RelationFormSheetProps): React__default.ReactElement;
+
+/**
+ * NodeTypeNameSheet -- name input for adding or renaming a node type.
+ */
+
+interface NodeTypeNameSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Current label when renaming; omit for add. */
+    initial?: string;
+    /** Existing labels, to prevent duplicates. */
+    existing: string[];
+    /** The kind of type being named (affects wording). Default "node". */
+    noun?: "node" | "edge";
+    onSave: (label: string) => void;
+}
+declare function NodeTypeNameSheet({ open, onOpenChange, initial, existing, noun, onSave, }: NodeTypeNameSheetProps): React__default.ReactElement;
+
+/**
+ * GraphMutationPort -- the core write seam for instance editing.
+ *
+ * The write analog of the read-side injected dependencies
+ * (`GraphExplorationDeps` / `GraphDataHook`). The library's editing components
+ * call only this port; they never see HTTP, auth, Cypher, or a cache. Each
+ * consumer implements the port against its own backend (the explorer wraps its
+ * existing `graphService`; a new consumer wraps its own graph REST API).
+ *
+ * Node/edge ids are numeric, matching `RawGraphNode.id_` / `RawGraphEdge.id_`
+ * and the explorer's `graphService` today. (If a future consumer keys nodes by
+ * string, this would widen to `number | string`.)
+ *
+ * The port is EVENT-FREE: it `await`s and returns the mutation result; it does
+ * not own a cache and emits no events. The consumer wraps the port to patch its
+ * own cache (the explorer keeps its React-Query patching in its wrapper).
+ *
+ * Relations stay ATOMIC: `createNodeWithRelations` / `updateNodeWithRelations`
+ * are single port methods, not decomposed into node + edge calls in the
+ * library. The backend already exposes transactional endpoints for these;
+ * decomposing would lose atomicity.
+ */
+
+/** A node create request: a label and its properties. */
+interface CreateNodeInput {
+    label_: string;
+    properties_: GraphProperties;
+}
+/** A node update request: id, label, and the full property set. */
+interface UpdateNodeInput {
+    id_: number;
+    label_: string;
+    properties_: GraphProperties;
+}
+/** An edge create request between two nodes. */
+interface CreateEdgeInput {
+    label_: string;
+    start_id_: number;
+    end_id_: number;
+    properties_?: GraphProperties;
+}
+/**
+ * An edge update request. Carries the full edge identity (label and endpoints),
+ * not just the id, so a consumer can build a REST PUT body or run a query
+ * without re-fetching the edge. The editor always has these (it edits an
+ * existing edge it already holds), so the port stays self-sufficient. The
+ * backend is free to ignore the fields it does not need.
+ */
+interface UpdateEdgeInput {
+    id_: number;
+    label_: string;
+    start_id_: number;
+    end_id_: number;
+    properties_: GraphProperties;
+}
+/**
+ * Relations grouped by relation/edge type: rel_type -> target node ids.
+ * Matches the `__rel_*` form-field shape after extraction.
+ */
+type RelationMap = Record<string, number[]>;
+/** A node-with-relations create request (atomic). */
+interface CreateNodeWithRelationsInput {
+    label_: string;
+    properties_: GraphProperties;
+    relations: RelationMap;
+}
+/** A node-with-relations update request (atomic; backend diffs the edges). */
+interface UpdateNodeWithRelationsInput {
+    id_: number;
+    label_: string;
+    properties_: GraphProperties;
+    relations: RelationMap;
+}
+/** Result of creating a node with relations: the node and the created edges. */
+interface CreateNodeWithRelationsResult {
+    node: RawGraphNode;
+    edges: RawGraphEdge[];
+}
+/** Result of updating a node with relations: the node and the edge diff. */
+interface UpdateNodeWithRelationsResult {
+    node: RawGraphNode;
+    edges: {
+        deleted: number[];
+        created: RawGraphEdge[];
+    };
+}
+/**
+ * The injected write interface. Shapes mirror the explorer's `graphService`
+ * almost one-to-one, which is what makes a consumer's adapter a thin wrapper.
+ */
+interface GraphMutationPort {
+    createNode(input: CreateNodeInput): Promise<RawGraphNode>;
+    updateNode(input: UpdateNodeInput): Promise<RawGraphNode>;
+    deleteNode(id: number): Promise<void>;
+    createEdge(input: CreateEdgeInput): Promise<RawGraphEdge>;
+    updateEdge(input: UpdateEdgeInput): Promise<RawGraphEdge>;
+    deleteEdge(id: number): Promise<void>;
+    /** Create a node and its relations in one server-side transaction. */
+    createNodeWithRelations(input: CreateNodeWithRelationsInput): Promise<CreateNodeWithRelationsResult>;
+    /** Update a node and diff its relations in one server-side transaction. */
+    updateNodeWithRelations(input: UpdateNodeWithRelationsInput): Promise<UpdateNodeWithRelationsResult>;
+    /** Reads needed by edit / delete flows. */
+    getInboundEdges(id: number): Promise<RawGraphEdge[]>;
+    getOutboundEdges(id: number): Promise<RawGraphEdge[]>;
+    /** All edges between two nodes, in both directions. */
+    getPairEdges(a: number, b: number): Promise<RawGraphEdge[]>;
+    /**
+     * Fetch nodes by id -- used by the delete-node dialog to resolve the display
+     * names of dependent (neighbour) nodes. Mirrors the explorer's
+     * graphService.getNodes.
+     */
+    getNodes(ids: number[]): Promise<RawGraphNode[]>;
+}
+
+/**
+ * GraphSchemaProvider -- the schema (type) seam for instance editing.
+ *
+ * The edit forms are schema-driven: they need the JSON Schema for a node label
+ * or edge type, plus its relation definitions, to build the form. Inject a
+ * provider; the library uses it only to build forms.
+ *
+ * This is a NEW, dedicated async interface, not an extension of the
+ * model-editor's controlled-value provider. `GraphModelEditor` works on an
+ * in-memory `GraphModel` (a controlled `value` prop) the host already holds;
+ * instance editing instead needs to FETCH a node/edge schema by label on
+ * demand (async), a different shape and lifecycle. A host that already has the
+ * full model in memory can implement the provider as a synchronous lookup
+ * wrapped in `Promise.resolve`.
+ */
+
+/** Relation cardinality. Binary, matching the model. Drives single vs multi
+ * select for the relation form field. */
+type RelationCardinality = "ONE_TO_ONE" | "ONE_TO_MANY";
+/**
+ * A relation definition surfaced to the instance-editing form layer.
+ *
+ * Structural own type -- not an alias of `GraphRelation` -- so the
+ * instance-editing seam is decoupled from the model-editor's internal types.
+ * Consumers implementing `GraphSchemaProvider` only need to satisfy this shape.
+ */
+interface RelationDef {
+    /** The relation/edge label, e.g. "USES_TECHNOLOGY". */
+    rel_type_name: string;
+    /** The target node-type label, e.g. "Technology". */
+    to_type_name: string;
+    /**
+     * Whether this relation is surfaced as an editable form field. Only relations
+     * with `form_field === true` become `__rel_*` fields in the node form
+     * (matching the explorer). Defaults to not-a-field.
+     */
+    form_field?: boolean;
+    /**
+     * Binary cardinality. ONE_TO_ONE renders a single-select; ONE_TO_MANY (or
+     * omitted) renders a multi-select.
+     */
+    cardinality?: RelationCardinality;
+    /** Optional explicit form-field title; defaults to a Title-Cased label. */
+    title?: string;
+    /**
+     * Optional widget hint for the relation field (the `x-ui-widget` value).
+     * Defaults to "entity-select". The explorer overrides this with
+     * "cypher-select"; the widget itself is supplied app-level via the registry.
+     */
+    widget?: string;
+}
+/**
+ * The injected schema source. All lookups are async (returning Promises) so a
+ * provider can fetch from a `/schemas` endpoint, a model store, or resolve
+ * synchronously from an in-memory model.
+ */
+interface GraphSchemaProvider {
+    /** The JSON Schema for a node label, used to render its property form. */
+    getNodeSchema(label: string): Promise<JsonSchema | null>;
+    /** The JSON Schema for an edge type, used to render its property form. */
+    getEdgeSchema(type: string): Promise<JsonSchema | null>;
+    /** The node labels a consumer may create (populates the label selector). */
+    listNodeLabels(): Promise<string[]>;
+    /** The outbound relation definitions for a node label (the form relations). */
+    relationsFor(label: string): Promise<RelationDef[]>;
+}
+
+/**
+ * Graph instance-editing capabilities -- a single structure that gates what a
+ * consumer can do with a live data graph. Distinct from `GraphModelCapabilities`
+ * (which gates the metamodel/schema editor): this profile governs the viewer +
+ * instance editor (editing node/edge DATA, not types).
+ *
+ * This profile is the RBAC/ABAC seam: the host resolves a user's
+ * role/attributes into a `GraphCapabilities` object and passes it in; the
+ * library enables only what the resolved capabilities allow and never sees
+ * roles, policies, or auth.
+ *
+ * This module is the single source of truth: the Zod schema below defines the
+ * shape, the TypeScript types are inferred from it (`z.input` / `z.output`),
+ * and `validateGraphCapabilities` validates hand-authored / external JSON at
+ * the boundary. Every field is optional and defaults to `"readonly"` (no
+ * editing affordances) so existing viewers are unaffected until a consumer
+ * opts in by passing a capabilities profile. The viewer areas are reserved for
+ * a follow-on refactor and default fully permissive; v1 ships the editing
+ * areas.
+ */
+
+/** Mode for an editable area: allow the action or not. */
+type EditMode = "edit" | "readonly";
+/**
+ * The capabilities schema. Each field is optional with a permissive default;
+ * `.meta({ description })` is carried through to any generated JSON Schema.
+ *
+ * Editing areas (v1): node CRUD, edge CRUD, property editing. Viewer areas are
+ * reserved (designed-for, not yet wired) so they slot in without a breaking
+ * change.
+ */
+declare const graphCapabilitiesSchema: z.ZodObject<{
+    createNode: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    updateNode: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    deleteNode: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    createEdge: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    updateEdge: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+    deleteEdge: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        readonly: "readonly";
+    }>>;
+}, z.core.$strip>;
+/**
+ * The capabilities a consumer may pass. Inferred from the schema; with all
+ * fields optional on input (defaults are applied by resolveGraphCapabilities).
+ */
+type GraphCapabilities = z.input<typeof graphCapabilitiesSchema>;
+/** The fully-resolved capabilities (every field present). */
+type ResolvedGraphCapabilities = z.output<typeof graphCapabilitiesSchema>;
+/**
+ * Resolve the effective capabilities: readOnly wins (everything read-only),
+ * otherwise parse the provided capabilities (applying per-field defaults of
+ * "readonly"). Invalid input falls back to the read-only defaults rather than
+ * throwing -- use validateGraphCapabilities to surface errors at a boundary.
+ */
+declare function resolveGraphCapabilities(capabilities: GraphCapabilities | undefined, readOnly: boolean | undefined): ResolvedGraphCapabilities;
+/** Result of validating an untrusted capabilities object. */
+type GraphCapabilitiesValidation = {
+    ok: true;
+    value: ResolvedGraphCapabilities;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validate a hand-authored / external capabilities object (e.g. parsed from a
+ * per-tenant config JSON or produced by an authorization layer). Returns the
+ * resolved value or a list of readable error messages. Does not throw.
+ */
+declare function validateGraphCapabilities(input: unknown): GraphCapabilitiesValidation;
+
+/**
+ * Relation form-field utilities.
+ *
+ * The schema-driven node form represents editable relations as synthetic
+ * `__rel_<type>__` fields (a multi-select of target node ids). These helpers
+ * convert between that flat form shape and the structured
+ * `{ properties, relations }` the mutation port expects.
+ *
+ * Relocated from the cypher-graphdb explorer (`services/nodeFormUtils.ts`) so
+ * every consumer of the shared editor gets the same relation handling. The
+ * functions are pure -- no I/O. Reads of a node's existing relations go through
+ * the injected `GraphMutationPort` (getInboundEdges / getOutboundEdges), not a
+ * hardcoded backend call.
+ */
+
+/** A per-field UI schema map, as JsonSchemaFormRenderer's `uiSchema` prop. */
+type FieldUiSchema = {
+    [fieldName: string]: UISchema;
+};
+/** Whether a form key is a synthetic relation field. */
+declare function isRelationField(key: string): boolean;
+/** The form-field name for a relation type (`USES` -> `__rel_uses__`). */
+declare function relationFieldName(relationType: string): string;
+/** The relation type for a form-field name (`__rel_uses__` -> `USES`). */
+declare function relationTypeFromField(fieldName: string): string;
+/**
+ * Group a node's edges into a relation map (rel_type -> target node ids),
+ * relative to the node. The target is the other end of each edge.
+ */
+declare function groupEdgesByRelation(nodeId: number, edges: RawGraphEdge[]): RelationMap;
+/**
+ * Build initial form data from a node's properties and its relations, including
+ * a `__rel_*` field for every editable relation type. `editableRelationTypes`
+ * is the set of relation types that should appear as form fields (typically
+ * those marked `form_field` in the model); an empty list yields properties
+ * only.
+ */
+declare function initializeFormData(properties: GraphProperties, relations: RelationMap, editableRelationTypes: string[]): Record<string, unknown>;
+/**
+ * Split form data into `{ properties, relations }`, converting `__rel_*` fields
+ * back to relation type names and numeric ids.
+ */
+declare function extractRelationFields(formData: Record<string, unknown>): {
+    properties: GraphProperties;
+    relations: RelationMap;
+};
+/** Whether any form key is a relation field (decides the atomic save path). */
+declare function hasRelationFields(formData: Record<string, unknown>): boolean;
+/** Title-case a relation type for a default field title ("USES_TECHNOLOGY" ->
+ * "Uses Technology"). Matches the explorer's formatting. */
+declare function relationTitle(relationType: string): string;
+/** A relation is editable (becomes a form field) when form_field === true,
+ * matching the explorer. */
+declare function editableRelations(relations: RelationDef[]): RelationDef[];
+/** Whether a node/edge schema declares any properties (gates "Edit edge" the
+ * same way the explorer's hasProperties does). */
+declare function hasProperties(schema: JsonSchema | null | undefined): boolean;
+/**
+ * Enrich a node schema with a `__rel_*` field per editable relation, returning
+ * a new `{ schema, uiSchema }`. Mirrors the explorer's enrichment:
+ *  - field type is `array of integer` (multi) for ONE_TO_MANY / unset
+ *    cardinality, or `integer` (single) for ONE_TO_ONE;
+ *  - the field title is the relation's title or a Title-Cased label;
+ *  - the uiSchema carries `x-ui-widget` (default "entity-select") plus
+ *    `x-ui-options` describing the target type and selection mode.
+ *
+ * The widget COMPONENT stays app-level (supplied via the form widget registry);
+ * this only produces the schema/uiSchema that drives it.
+ */
+declare function enrichSchemaWithRelations(baseSchema: JsonSchema, relations: RelationDef[]): {
+    schema: JsonSchema;
+    uiSchema: FieldUiSchema;
+};
+
+/**
+ * GraphEditToolbar -- the selection-driven CRUD toolbar for instance editing.
+ *
+ * Reads the current selection from the workspace selection store (the same
+ * store the viewer owns), gates each action behind the resolved
+ * `GraphCapabilities`, and owns the edit dialogs (node form, edge form, delete
+ * confirm). Relocated from the explorer's `CrudActions`, but library-native:
+ * it drives everything through the injected `GraphMutationPort` +
+ * `GraphSchemaProvider` and is slot-injectable via `ActionPanel actions={...}`.
+ *
+ * Override tiers: pass your own toolbar into `ActionPanel` to replace it
+ * entirely (tier 3), or drive the exported dialogs / port directly (tier 4).
+ */
+
+interface GraphEditToolbarProps {
+    port: GraphMutationPort;
+    schemaProvider: GraphSchemaProvider;
+    /** Capability profile. Defaults to read-only (no affordances shown). */
+    capabilities?: GraphCapabilities;
+    /** Force read-only regardless of capabilities. */
+    readOnly?: boolean;
+    /** Form widgets shared by the node + edge forms. */
+    widgets?: WidgetRegistry;
+    /** Called after any successful mutation so the consumer can refresh. */
+    onMutated?: () => void;
+}
+declare function GraphEditToolbar({ port, schemaProvider, capabilities, readOnly, widgets, onMutated, }: GraphEditToolbarProps): React__default.ReactElement | null;
+
+/**
+ * NodeFormSheet -- create or edit a graph node (instance data).
+ *
+ * Schema-driven: the node's JSON Schema and editable relations come from the
+ * injected `GraphSchemaProvider`; the form is rendered with
+ * `JsonSchemaFormRenderer`. Editable relations are surfaced as `__rel_*` form
+ * fields (see relationFields.ts). Saving goes through the injected
+ * `GraphMutationPort`: when relations are present the atomic
+ * create/updateNodeWithRelations methods are used, otherwise the plain
+ * create/updateNode methods.
+ *
+ * The component is I/O-free beyond the port + provider it is given, and emits
+ * no events: it `await`s the port and calls `onSaved` so the consumer can patch
+ * its own cache.
+ */
+
+interface NodeFormSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The node being edited; omit for create. */
+    node?: RawGraphNode | null;
+    port: GraphMutationPort;
+    schemaProvider: GraphSchemaProvider;
+    /** Form widgets (e.g. a product reference-select). Defaults to the built-ins. */
+    widgets?: WidgetRegistry;
+    /** Called with the saved node after a successful create/update. */
+    onSaved?: (node: RawGraphNode) => void;
+}
+declare function NodeFormSheet({ open, onOpenChange, node, port, schemaProvider, widgets, onSaved, }: NodeFormSheetProps): React__default.ReactElement;
+
+/**
+ * EdgeFormSheet -- manage the edges between two selected nodes.
+ *
+ * Lists the existing edges between the pair (loaded via the port's
+ * `getPairEdges`), the edge types that may still be created between them
+ * (derived from the schema provider's relations), and renders a schema-driven
+ * property form when creating or editing an edge. All writes go through the
+ * injected `GraphMutationPort`; the component emits no events and calls
+ * `onChanged` so the consumer can patch its own cache and re-read the pair.
+ */
+
+interface EdgeFormSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The two endpoints; the first is the edge source. */
+    nodeA: RawGraphNode;
+    nodeB: RawGraphNode;
+    port: GraphMutationPort;
+    schemaProvider: GraphSchemaProvider;
+    widgets?: WidgetRegistry;
+    /** Called after any edge create / update / delete succeeds. */
+    onChanged?: () => void;
+}
+declare function EdgeFormSheet({ open, onOpenChange, nodeA, nodeB, port, schemaProvider, widgets, onChanged, }: EdgeFormSheetProps): React__default.ReactElement;
+
+/**
+ * DeleteNodeDialog -- confirm deleting a node, warning about dependent edges.
+ *
+ * Loads the node's inbound/outbound edges through the injected
+ * `GraphMutationPort` so the user sees what will be removed. Deleting goes
+ * through `port.deleteNode`; the component emits no events and calls
+ * `onDeleted` so the consumer can patch its own cache.
+ */
+
+interface DeleteNodeDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    node: RawGraphNode;
+    port: GraphMutationPort;
+    /** Called with the deleted node id after a successful delete. */
+    onDeleted?: (id: number) => void;
+}
+declare function DeleteNodeDialog({ open, onOpenChange, node, port, onDeleted, }: DeleteNodeDialogProps): React__default.ReactElement;
+
+export { ActionPanel, type ActionPanelState, type ActionPanelStore, type CapabilitiesValidation, type Cardinality, type ColorPalette, type CreateEdgeInput, type CreateNodeInput, type CreateNodeWithRelationsInput, type CreateNodeWithRelationsResult, DeleteNodeDialog, type DeleteNodeDialogProps, EMPTY_NORMALIZED, EdgeFormSheet, type EdgeFormSheetProps, EdgeInfoCard, type EdgeTypeMode, type EdgeTypeView, type EdgeVisual, type EditMode$1 as EditMode, type EditableMode, type ExpandOptions, type ExpandResult, GraphA11yList, type GraphA11yListProps, type GraphCapabilities, type GraphCapabilitiesValidation, type GraphDataHook, type GraphDataStore, type GraphDisplayConfig, type EditMode as GraphEditMode, GraphEditToolbar, type GraphEditToolbarProps, type GraphExplorationDeps, type GraphExplorationStore, type GraphFilterStore, type GraphFocusAction, type GraphFocusStore, type GraphModel, type GraphModelCapabilities, type GraphModelDisplay, GraphModelEditor, type GraphModelEditorProps, type GraphModelProperty, type GraphMutationPort, type GraphProperties, type GraphProperty, type GraphRelation, type GraphRenderer, GraphRendererProvider, type GraphSchemaProvider, type GraphStatistics, type WorkspaceStores as GraphStoreBundle, GraphStoresContext, type GraphTypeSchema, GraphVisualizer, type GraphVisualizerProps, type LabelDisplayMap, type LiveGraphDataResult, ModelActionPanel, type ModelActionPanelProps, type ModelGraph, NodeFormSheet, type NodeFormSheetProps, NodeInfoCard, NodeTypeNameSheet, type NodeTypeNameSheetProps, type NodeTypeView, type NodeVisual, type NormalizedGraph, Overview, PropertyFormSheet, type PropertyFormSheetProps, type PropertyInput, type PropertyView, type RawGraphEdge, type RawGraphNode, type RelationCardinality, type RelationDef, type RelationDetailView, RelationFormSheet, type RelationFormSheetProps, type RelationInput, type RelationMap, type RelationView, type ResolvedCapabilities, type ResolvedGraphCapabilities, type SelectionStore, type StoreFactory, TypeDetailPanel, type TypeDetailPanelProps, type UpdateEdgeInput, type UpdateNodeInput, type UpdateNodeWithRelationsInput, type UpdateNodeWithRelationsResult, type VisualGraphEdge, type VisualGraphNode, type VisualGraphNormalized, type WorkspaceStores, type XGraph, addEdgeType, addNodeType, addRelation, buildColorPalette, buildColorPaletteFromNodes, capabilitiesSchema, cardinalityLabel, createActionPanelStore, createGraphDataStore, createGraphExplorationStore, createGraphFilterStore, createGraphFocusStore, createSelectionStore, deleteEdgeType, deleteEdgeTypeProperty, deleteNodeProperty, deleteNodeType, deleteRelation, deleteRelationProperty, edgeTypeView, editableRelations, enrichEdge, enrichEdges, enrichNode, enrichNodes, enrichSchemaWithRelations, extractDisplayLabel, extractRelationFields, findEdgeType, findType, graphCapabilitiesSchema, groupEdgesByRelation, hasProperties, hasRelationFields, initializeFormData, isEdgeType, isNodeType, isRawGraphNode, isRelationField, isVisualEdge, isVisualNode, modelToGraph, nodeTypeView, normalizeGraph, reconcileFilter, relationFieldName, relationTitle, relationTypeFromField, relationView, renameEdgeType, renameNodeType, resolveCapabilities, resolveGraphCapabilities, resolveRelationEdge, setEdgeTypeProperty, setNodeProperty, setRelationProperty, toCytoscapeEdge, toCytoscapeNode, toReagraphEdge, toReagraphNode, typeLabel, updateRelation, useActionPanelStore, useCytoscapeData, useGraphFocus, useGraphRenderer, useLiveGraphData, useReagraphData, useStableRef, useWorkspaceGraphData, useWorkspaceGraphExploration, useWorkspaceGraphFilter, useWorkspaceSelection, validateCapabilities, validateGraphCapabilities };