@snaptrude/plugin-core 0.9.16 → 0.9.18-networks-20261016.1

package/dist/api/design/networks.d.ts

@@ -0,0 +1,1763 @@
+import * as z from "zod";
+import type { PluginApiReturn } from "../../types";
+/** Versioned metadata stored in a pinned FamilySpecBundle.network. Expressions use the
+ * family's parameter scope and SU, just like its geometry. No world-space port overrides.
+ * Pipe recipes run from local [0,0,0] to [length,0,0] along +X.
+ */
+export declare const NetworkFamilyContract: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    role: z.ZodEnum<{
+        pipe: "pipe";
+        duct: "duct";
+        wire: "wire";
+        cable: "cable";
+        conduit: "conduit";
+        cableDuct: "cableDuct";
+        cableTray: "cableTray";
+        connector: "connector";
+        equipment: "equipment";
+    }>;
+    lengthParameter: z.ZodOptional<z.ZodString>;
+    ports: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        position: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodString], null>;
+        direction: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodString], null>;
+        size: z.ZodString;
+        height: z.ZodOptional<z.ZodString>;
+        widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString, z.ZodString], null>>;
+        systems: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type NetworkFamilyContract = z.infer<typeof NetworkFamilyContract>;
+/** Authored topology: vertices are pinned connector/equipment families; each edge is one
+ * line and one pinned straight-pipe family. Curved runs are not yet supported by this
+ * contract; bends require explicit connector vertices. World mm, Y up, rotations in degrees.
+ * Plumbing v2 accepts round ports only. Rectangular ports need a section-roll contract.
+ * The resolved component graph is retained for existing persistence, replay and queries.
+ */
+export declare const NetworkTopologyDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    domain: z.ZodLiteral<"plumbing">;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    vertices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            equipment: "equipment";
+            fixture: "fixture";
+            tank: "tank";
+            pump: "pump";
+            valve: "valve";
+            manifold: "manifold";
+            fitting: "fitting";
+        }>;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        systems: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            pipe: "pipe";
+            riser: "riser";
+        }>;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        system: z.ZodString;
+        curve: z.ZodObject<{
+            kind: z.ZodLiteral<"line">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type NetworkTopologyDocument = z.infer<typeof NetworkTopologyDocument>;
+export declare const MechanicalAirSystem: z.ZodEnum<{
+    supplyAir: "supplyAir";
+    returnAir: "returnAir";
+    exhaustAir: "exhaustAir";
+    outsideAir: "outsideAir";
+    reliefAir: "reliefAir";
+}>;
+/** Air-side HVAC intent. Reuses the graph transport, not plumbing domain semantics.
+ * Every vertex and edge pins an existing family. Edges run from upstream to downstream.
+ * Rectangular duct ports use local +Y as their width axis. The host aligns this axis to
+ * the upstream connector's widthDirection and rejects incompatible downstream roll.
+ * Bends, branches and transitions are explicit fitting vertices. No flexible curves,
+ * hydronic/refrigerant design, airflow sizing or code-compliance inference is provided.
+ */
+export declare const MechanicalTopologyDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"mechanical">;
+    vertices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        kind: z.ZodEnum<{
+            equipment: "equipment";
+            fitting: "fitting";
+            terminal: "terminal";
+            damper: "damper";
+        }>;
+        systems: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            supplyAir: "supplyAir";
+            returnAir: "returnAir";
+            exhaustAir: "exhaustAir";
+            outsideAir: "outsideAir";
+            reliefAir: "reliefAir";
+        }>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        curve: z.ZodObject<{
+            kind: z.ZodLiteral<"line">;
+        }, z.core.$strict>;
+        kind: z.ZodEnum<{
+            duct: "duct";
+            riser: "riser";
+        }>;
+        system: z.ZodEnum<{
+            supplyAir: "supplyAir";
+            returnAir: "returnAir";
+            exhaustAir: "exhaustAir";
+            outsideAir: "outsideAir";
+            reliefAir: "reliefAir";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MechanicalTopologyDocument = z.infer<typeof MechanicalTopologyDocument>;
+/** Physical electrical topology, independent of logical circuit membership.
+ * Each straight edge pins a family whose role matches its kind. Bends and branches
+ * require connector vertices. Junction boxes are equipment with explicit named ports.
+ * Rectangular containment uses the same section frame as mechanical ducts.
+ * Systems are authored labels which must be supported by the pinned ports.
+ * Direction is explicit, never inferred from circuits or spatial contact.
+ */
+export declare const ElectricalTopologyDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"electrical">;
+    vertices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        systems: z.ZodRecord<z.ZodString, z.ZodString>;
+        kind: z.ZodEnum<{
+            equipment: "equipment";
+            fitting: "fitting";
+            transformer: "transformer";
+            mainBoard: "mainBoard";
+            distributionBoard: "distributionBoard";
+            mcbBox: "mcbBox";
+            junctionBox: "junctionBox";
+            switch: "switch";
+            outlet: "outlet";
+            light: "light";
+            load: "load";
+        }>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        system: z.ZodString;
+        curve: z.ZodObject<{
+            kind: z.ZodLiteral<"line">;
+        }, z.core.$strict>;
+        kind: z.ZodEnum<{
+            wire: "wire";
+            cable: "cable";
+            conduit: "conduit";
+            cableDuct: "cableDuct";
+            cableTray: "cableTray";
+        }>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    circuits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        loads: z.ZodArray<z.ZodString>;
+        routes: z.ZodArray<z.ZodString>;
+        voltage: z.ZodNumber;
+        phases: z.ZodNumber;
+        ratedAmps: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ElectricalTopologyDocument = z.infer<typeof ElectricalTopologyDocument>;
+export declare const AuthoredNetworkTopologyDocument: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    domain: z.ZodLiteral<"plumbing">;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    vertices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            equipment: "equipment";
+            fixture: "fixture";
+            tank: "tank";
+            pump: "pump";
+            valve: "valve";
+            manifold: "manifold";
+            fitting: "fitting";
+        }>;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        systems: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            pipe: "pipe";
+            riser: "riser";
+        }>;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        system: z.ZodString;
+        curve: z.ZodObject<{
+            kind: z.ZodLiteral<"line">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"mechanical">;
+    vertices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        kind: z.ZodEnum<{
+            equipment: "equipment";
+            fitting: "fitting";
+            terminal: "terminal";
+            damper: "damper";
+        }>;
+        systems: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            supplyAir: "supplyAir";
+            returnAir: "returnAir";
+            exhaustAir: "exhaustAir";
+            outsideAir: "outsideAir";
+            reliefAir: "reliefAir";
+        }>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        curve: z.ZodObject<{
+            kind: z.ZodLiteral<"line">;
+        }, z.core.$strict>;
+        kind: z.ZodEnum<{
+            duct: "duct";
+            riser: "riser";
+        }>;
+        system: z.ZodEnum<{
+            supplyAir: "supplyAir";
+            returnAir: "returnAir";
+            exhaustAir: "exhaustAir";
+            outsideAir: "outsideAir";
+            reliefAir: "reliefAir";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"electrical">;
+    vertices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        systems: z.ZodRecord<z.ZodString, z.ZodString>;
+        kind: z.ZodEnum<{
+            equipment: "equipment";
+            fitting: "fitting";
+            transformer: "transformer";
+            mainBoard: "mainBoard";
+            distributionBoard: "distributionBoard";
+            mcbBox: "mcbBox";
+            junctionBox: "junctionBox";
+            switch: "switch";
+            outlet: "outlet";
+            light: "light";
+            load: "load";
+        }>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        family: z.ZodObject<{
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        system: z.ZodString;
+        curve: z.ZodObject<{
+            kind: z.ZodLiteral<"line">;
+        }, z.core.$strict>;
+        kind: z.ZodEnum<{
+            wire: "wire";
+            cable: "cable";
+            conduit: "conduit";
+            cableDuct: "cableDuct";
+            cableTray: "cableTray";
+        }>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    circuits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        loads: z.ZodArray<z.ZodString>;
+        routes: z.ZodArray<z.ZodString>;
+        voltage: z.ZodNumber;
+        phases: z.ZodNumber;
+        ratedAmps: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "domain">;
+export type AuthoredNetworkTopologyDocument = z.infer<typeof AuthoredNetworkTopologyDocument>;
+/** Authored world-space connector. This is not a claim of certified family connector metadata. */
+export declare const NetworkPort: z.ZodObject<{
+    id: z.ZodString;
+    positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    system: z.ZodString;
+    sizeMm: z.ZodNumber;
+    heightMm: z.ZodOptional<z.ZodNumber>;
+    widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strict>;
+/** The agent supplies every route and section. The host does not size or route a network. */
+export declare const NetworkGeometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"family">;
+    definitionId: z.ZodString;
+    version: z.ZodNumber;
+    values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+    positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    ports: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        system: z.ZodString;
+        sizeMm: z.ZodNumber;
+        heightMm: z.ZodOptional<z.ZodNumber>;
+        widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"route">;
+    pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    system: z.ZodString;
+    section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"round">;
+        diameterMm: z.ZodNumber;
+        wallMm: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rectangular">;
+        widthMm: z.ZodNumber;
+        heightMm: z.ZodNumber;
+        wallMm: z.ZodNumber;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">;
+/** Electrical connectivity and circuit membership are distinct from physical route occupancy. */
+export declare const ElectricalGraphDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"electrical">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+                widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            wire: "wire";
+            cable: "cable";
+            conduit: "conduit";
+            cableDuct: "cableDuct";
+            cableTray: "cableTray";
+            equipment: "equipment";
+            fitting: "fitting";
+            transformer: "transformer";
+            mainBoard: "mainBoard";
+            distributionBoard: "distributionBoard";
+            mcbBox: "mcbBox";
+            junctionBox: "junctionBox";
+            switch: "switch";
+            outlet: "outlet";
+            light: "light";
+            load: "load";
+        }>;
+    }, z.core.$strict>>;
+    circuits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        loads: z.ZodArray<z.ZodString>;
+        routes: z.ZodArray<z.ZodString>;
+        voltage: z.ZodNumber;
+        phases: z.ZodNumber;
+        ratedAmps: z.ZodNumber;
+    }, z.core.$strict>>;
+    authored: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        label: z.ZodString;
+        architectureRevision: z.ZodString;
+        relationships: z.ZodArray<z.ZodObject<{
+            node: z.ZodString;
+            relation: z.ZodEnum<{
+                mountedOn: "mountedOn";
+                within: "within";
+                serves: "serves";
+                penetrates: "penetrates";
+            }>;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    topology: "topology";
+                    component: "component";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        domain: z.ZodLiteral<"electrical">;
+        vertices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            systems: z.ZodRecord<z.ZodString, z.ZodString>;
+            kind: z.ZodEnum<{
+                equipment: "equipment";
+                fitting: "fitting";
+                transformer: "transformer";
+                mainBoard: "mainBoard";
+                distributionBoard: "distributionBoard";
+                mcbBox: "mcbBox";
+                junctionBox: "junctionBox";
+                switch: "switch";
+                outlet: "outlet";
+                light: "light";
+                load: "load";
+            }>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            from: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            to: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            system: z.ZodString;
+            curve: z.ZodObject<{
+                kind: z.ZodLiteral<"line">;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                wire: "wire";
+                cable: "cable";
+                conduit: "conduit";
+                cableDuct: "cableDuct";
+                cableTray: "cableTray";
+            }>;
+            directed: z.ZodBoolean;
+        }, z.core.$strict>>;
+        circuits: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            loads: z.ZodArray<z.ZodString>;
+            routes: z.ZodArray<z.ZodString>;
+            voltage: z.ZodNumber;
+            phases: z.ZodNumber;
+            ratedAmps: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Plumbing uses explicit directed port connections; touching geometry never creates a connection. */
+export declare const PlumbingGraphDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"plumbing">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+                widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            pipe: "pipe";
+            equipment: "equipment";
+            fixture: "fixture";
+            tank: "tank";
+            pump: "pump";
+            valve: "valve";
+            manifold: "manifold";
+            fitting: "fitting";
+            riser: "riser";
+        }>;
+    }, z.core.$strict>>;
+    authored: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        domain: z.ZodLiteral<"plumbing">;
+        label: z.ZodString;
+        architectureRevision: z.ZodString;
+        relationships: z.ZodArray<z.ZodObject<{
+            node: z.ZodString;
+            relation: z.ZodEnum<{
+                mountedOn: "mountedOn";
+                within: "within";
+                serves: "serves";
+                penetrates: "penetrates";
+            }>;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    topology: "topology";
+                    component: "component";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        vertices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                equipment: "equipment";
+                fixture: "fixture";
+                tank: "tank";
+                pump: "pump";
+                valve: "valve";
+                manifold: "manifold";
+                fitting: "fitting";
+            }>;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            systems: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                pipe: "pipe";
+                riser: "riser";
+            }>;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            from: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            to: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            system: z.ZodString;
+            curve: z.ZodObject<{
+                kind: z.ZodLiteral<"line">;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Resolved HVAC snapshot for queries, commands and load. New submissions require v2 intent. */
+export declare const MechanicalGraphDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"mechanical">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        kind: z.ZodEnum<{
+            duct: "duct";
+            equipment: "equipment";
+            fitting: "fitting";
+            riser: "riser";
+            terminal: "terminal";
+            damper: "damper";
+        }>;
+        geometry: z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+                widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    authored: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        label: z.ZodString;
+        architectureRevision: z.ZodString;
+        relationships: z.ZodArray<z.ZodObject<{
+            node: z.ZodString;
+            relation: z.ZodEnum<{
+                mountedOn: "mountedOn";
+                within: "within";
+                serves: "serves";
+                penetrates: "penetrates";
+            }>;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    topology: "topology";
+                    component: "component";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        domain: z.ZodLiteral<"mechanical">;
+        vertices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            kind: z.ZodEnum<{
+                equipment: "equipment";
+                fitting: "fitting";
+                terminal: "terminal";
+                damper: "damper";
+            }>;
+            systems: z.ZodRecord<z.ZodString, z.ZodEnum<{
+                supplyAir: "supplyAir";
+                returnAir: "returnAir";
+                exhaustAir: "exhaustAir";
+                outsideAir: "outsideAir";
+                reliefAir: "reliefAir";
+            }>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            from: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            to: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            curve: z.ZodObject<{
+                kind: z.ZodLiteral<"line">;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                duct: "duct";
+                riser: "riser";
+            }>;
+            system: z.ZodEnum<{
+                supplyAir: "supplyAir";
+                returnAir: "returnAir";
+                exhaustAir: "exhaustAir";
+                outsideAir: "outsideAir";
+                reliefAir: "reliefAir";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NetworkGraphDocument: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"electrical">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+                widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            wire: "wire";
+            cable: "cable";
+            conduit: "conduit";
+            cableDuct: "cableDuct";
+            cableTray: "cableTray";
+            equipment: "equipment";
+            fitting: "fitting";
+            transformer: "transformer";
+            mainBoard: "mainBoard";
+            distributionBoard: "distributionBoard";
+            mcbBox: "mcbBox";
+            junctionBox: "junctionBox";
+            switch: "switch";
+            outlet: "outlet";
+            light: "light";
+            load: "load";
+        }>;
+    }, z.core.$strict>>;
+    circuits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        loads: z.ZodArray<z.ZodString>;
+        routes: z.ZodArray<z.ZodString>;
+        voltage: z.ZodNumber;
+        phases: z.ZodNumber;
+        ratedAmps: z.ZodNumber;
+    }, z.core.$strict>>;
+    authored: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        label: z.ZodString;
+        architectureRevision: z.ZodString;
+        relationships: z.ZodArray<z.ZodObject<{
+            node: z.ZodString;
+            relation: z.ZodEnum<{
+                mountedOn: "mountedOn";
+                within: "within";
+                serves: "serves";
+                penetrates: "penetrates";
+            }>;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    topology: "topology";
+                    component: "component";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        domain: z.ZodLiteral<"electrical">;
+        vertices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            systems: z.ZodRecord<z.ZodString, z.ZodString>;
+            kind: z.ZodEnum<{
+                equipment: "equipment";
+                fitting: "fitting";
+                transformer: "transformer";
+                mainBoard: "mainBoard";
+                distributionBoard: "distributionBoard";
+                mcbBox: "mcbBox";
+                junctionBox: "junctionBox";
+                switch: "switch";
+                outlet: "outlet";
+                light: "light";
+                load: "load";
+            }>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            from: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            to: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            system: z.ZodString;
+            curve: z.ZodObject<{
+                kind: z.ZodLiteral<"line">;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                wire: "wire";
+                cable: "cable";
+                conduit: "conduit";
+                cableDuct: "cableDuct";
+                cableTray: "cableTray";
+            }>;
+            directed: z.ZodBoolean;
+        }, z.core.$strict>>;
+        circuits: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            loads: z.ZodArray<z.ZodString>;
+            routes: z.ZodArray<z.ZodString>;
+            voltage: z.ZodNumber;
+            phases: z.ZodNumber;
+            ratedAmps: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"plumbing">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+                widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            pipe: "pipe";
+            equipment: "equipment";
+            fixture: "fixture";
+            tank: "tank";
+            pump: "pump";
+            valve: "valve";
+            manifold: "manifold";
+            fitting: "fitting";
+            riser: "riser";
+        }>;
+    }, z.core.$strict>>;
+    authored: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        domain: z.ZodLiteral<"plumbing">;
+        label: z.ZodString;
+        architectureRevision: z.ZodString;
+        relationships: z.ZodArray<z.ZodObject<{
+            node: z.ZodString;
+            relation: z.ZodEnum<{
+                mountedOn: "mountedOn";
+                within: "within";
+                serves: "serves";
+                penetrates: "penetrates";
+            }>;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    topology: "topology";
+                    component: "component";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        vertices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                equipment: "equipment";
+                fixture: "fixture";
+                tank: "tank";
+                pump: "pump";
+                valve: "valve";
+                manifold: "manifold";
+                fitting: "fitting";
+            }>;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            systems: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                pipe: "pipe";
+                riser: "riser";
+            }>;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            from: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            to: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            system: z.ZodString;
+            curve: z.ZodObject<{
+                kind: z.ZodLiteral<"line">;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            mountedOn: "mountedOn";
+            within: "within";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"mechanical">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        kind: z.ZodEnum<{
+            duct: "duct";
+            equipment: "equipment";
+            fitting: "fitting";
+            riser: "riser";
+            terminal: "terminal";
+            damper: "damper";
+        }>;
+        geometry: z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+                widthDirection: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    authored: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        label: z.ZodString;
+        architectureRevision: z.ZodString;
+        relationships: z.ZodArray<z.ZodObject<{
+            node: z.ZodString;
+            relation: z.ZodEnum<{
+                mountedOn: "mountedOn";
+                within: "within";
+                serves: "serves";
+                penetrates: "penetrates";
+            }>;
+            target: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    topology: "topology";
+                    component: "component";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        domain: z.ZodLiteral<"mechanical">;
+        vertices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            kind: z.ZodEnum<{
+                equipment: "equipment";
+                fitting: "fitting";
+                terminal: "terminal";
+                damper: "damper";
+            }>;
+            systems: z.ZodRecord<z.ZodString, z.ZodEnum<{
+                supplyAir: "supplyAir";
+                returnAir: "returnAir";
+                exhaustAir: "exhaustAir";
+                outsideAir: "outsideAir";
+                reliefAir: "reliefAir";
+            }>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            storey: z.ZodNumber;
+            family: z.ZodObject<{
+                definitionId: z.ZodString;
+                version: z.ZodNumber;
+                values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+            from: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            to: z.ZodObject<{
+                node: z.ZodString;
+                port: z.ZodString;
+            }, z.core.$strict>;
+            curve: z.ZodObject<{
+                kind: z.ZodLiteral<"line">;
+            }, z.core.$strict>;
+            kind: z.ZodEnum<{
+                duct: "duct";
+                riser: "riser";
+            }>;
+            system: z.ZodEnum<{
+                supplyAir: "supplyAir";
+                returnAir: "returnAir";
+                exhaustAir: "exhaustAir";
+                outsideAir: "outsideAir";
+                reliefAir: "reliefAir";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "domain">;
+export type NetworkGraphDocument = z.infer<typeof NetworkGraphDocument>;
+export type NetworkNode = NetworkGraphDocument["nodes"][number];
+export type NetworkPort = z.infer<typeof NetworkPort>;
+export type NetworkDomain = NetworkGraphDocument["domain"];
+/** JSON is an authored document, not a transport for live geometry handles. Maximum 2 MB characters. */
+export declare const NetworkValidateArgs: z.ZodObject<{
+    graphJson: z.ZodString;
+}, z.core.$strict>;
+export declare const NetworkCreateArgs: z.ZodObject<{
+    graphJson: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strict>;
+export declare const NetworkGetArgs: z.ZodObject<{
+    graphId: z.ZodString;
+}, z.core.$strict>;
+/** Displacement components are world millimetres, Y up, not Snaptrude units. */
+export declare const NetworkMoveEdgeArgs: z.ZodObject<{
+    graphId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    edgeId: z.ZodString;
+    displacement: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"vec3">, string>>;
+    requestId: z.ZodString;
+}, z.core.$strict>;
+export type NetworkMoveEdgeArgs = z.input<typeof NetworkMoveEdgeArgs>;
+export declare const NetworkMoveEdgeResult: z.ZodObject<{
+    graphId: z.ZodString;
+    revision: z.ZodNumber;
+    affectedComponentIds: z.ZodArray<z.ZodString>;
+    alreadyApplied: z.ZodBoolean;
+    saveStatus: z.ZodEnum<{
+        queued: "queued";
+        existing: "existing";
+    }>;
+}, z.core.$strict>;
+export type NetworkMoveEdgeResult = z.infer<typeof NetworkMoveEdgeResult>;
+/** Immutable receipts survive undo. Retrying a move never executes it again. */
+export declare const NetworkEditReceipt: z.ZodObject<{
+    requestId: z.ZodString;
+    fingerprint: z.ZodString;
+    revision: z.ZodNumber;
+    affectedComponentIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type NetworkEditReceipt = z.infer<typeof NetworkEditReceipt>;
+/** Each intentional apply/undo/redo has its own identity. Retries reuse it. */
+export declare const NetworkTransition: z.ZodObject<{
+    id: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    forward: z.ZodBoolean;
+}, z.core.$strict>;
+export type NetworkTransition = z.infer<typeof NetworkTransition>;
+export declare const NetworkTransitionReceipt: z.ZodObject<{
+    id: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    forward: z.ZodBoolean;
+    requestId: z.ZodString;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+export type NetworkTransitionReceipt = z.infer<typeof NetworkTransitionReceipt>;
+export declare const NetworkContextArgs: z.ZodObject<{
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    includeTopology: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const NetworkQueryArgs: z.ZodObject<{
+    graphId: z.ZodString;
+    revision: z.ZodNumber;
+    queryJson: z.ZodString;
+}, z.core.$strict>;
+export declare const NetworkQuery: z.ZodObject<{
+    kind: z.ZodEnum<{
+        ports: "ports";
+        relationships: "relationships";
+        circuits: "circuits";
+        nodes: "nodes";
+        connected: "connected";
+        upstream: "upstream";
+        downstream: "downstream";
+        nearestPort: "nearestPort";
+    }>;
+    node: z.ZodOptional<z.ZodString>;
+    pointMm: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    radiusMm: z.ZodOptional<z.ZodNumber>;
+    system: z.ZodOptional<z.ZodString>;
+    sizeMm: z.ZodOptional<z.ZodNumber>;
+    heightMm: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type NetworkQuery = z.infer<typeof NetworkQuery>;
+export interface NetworkDiagnostic {
+    path: string;
+    message: string;
+}
+export interface NetworkValidation {
+    ok: boolean;
+    diagnostics: NetworkDiagnostic[];
+    nodeCount: number;
+}
+/** Durable node-to-scene mapping. New family-backed nodes retain the original authorized pin;
+ * parameters and placement belong to the component, not a generated library family.
+ * Existing wrapper pins and v1 raw-route recipe pins remain readable, not newly authored.
+ */
+export declare const NetworkComponentBinding: z.ZodObject<{
+    nodeId: z.ZodString;
+    componentId: z.ZodString;
+    definitionId: z.ZodString;
+    definitionVersion: z.ZodNumber;
+}, z.core.$strict>;
+export type NetworkComponentBinding = z.infer<typeof NetworkComponentBinding>;
+export interface SavedNetworkGraph {
+    id: string;
+    domain: NetworkDomain;
+    revision: number;
+    requestId: string;
+    document: NetworkGraphDocument;
+    components: NetworkComponentBinding[];
+    edits?: NetworkEditReceipt[];
+    transitions?: NetworkTransitionReceipt[];
+}
+export interface NetworkCreateResult {
+    graphId: string;
+    revision: number;
+    components: NetworkComponentBinding[];
+    alreadyCreated: boolean;
+    /** Queue acceptance is not a durable database acknowledgement. */
+    saveStatus: "queued" | "existing";
+}
+/** Exact TopoGraph routing evidence, not a route planner or inferred enclosure.
+ * World mm, Y-up. A curve's axis is a unit direction, not a length.
+ * Shared region IDs mean a shared boundary, not permission to penetrate a wall.
+ * Regions preserve directed outer/hole loops. No vertical connectivity is inferred;
+ * use their curves and storey elevations to plan risers and explicit penetrations.
+ */
+export interface NetworkRoutingContext {
+    units: "mm";
+    edges: {
+        id: string;
+        curve: {
+            type: "line";
+            start: number[];
+            end: number[];
+        } | {
+            type: "arc";
+            start: number[];
+            end: number[];
+            centre: number[];
+            axis: number[];
+        };
+        wallId: string | null;
+        regionIds: string[];
+    }[];
+    regions: {
+        id: string;
+        /** Stable source component IDs; read label/storey from context.components. */
+        ownerIds: string[];
+        boundary: {
+            outer: {
+                edgeId: string;
+                direction: "forward" | "reverse";
+            }[];
+            holes: {
+                edgeId: string;
+                direction: "forward" | "reverse";
+            }[][];
+        };
+        floorId: string | null;
+        slabId: string | null;
+    }[];
+    /** Hosting is exact; bounds are only coarse avoidance data, not a penetration clearance check. */
+    openings: {
+        id: string;
+        wallId: string;
+        type: string;
+        minMm: number[];
+        maxMm: number[];
+    }[];
+}
+export interface NetworkContextResult {
+    proposalId: string;
+    buildingId: string | null;
+    revision: string;
+    /** PG2's native serialization uses Snaptrude units (1 SU = 254 mm). */
+    topologyUnits: "SU";
+    /** JSON array; empty when includeTopology is false. Prefer routing for network planning. */
+    topologyJson: string;
+    /** Each collection uses offset/limit independently. Follow nextOffset before resolving references.
+     * Empty regions mean topology is unavailable, not that bounds can substitute for room boundaries.
+     */
+    routing: NetworkRoutingContext;
+    nextOffset: number | null;
+    total: number;
+    storeys: {
+        number: number;
+        elevationMm: number;
+    }[];
+    components: {
+        id: string;
+        type: string;
+        label: string;
+        storey: number;
+        minMm: number[];
+        maxMm: number[];
+    }[];
+    /** Saved graph inventory, paged with topology/components. Use these IDs after reopening a project. */
+    networks: {
+        graphId: string;
+        domain: NetworkDomain;
+        revision: number;
+        label: string;
+        componentCount: number;
+    }[];
+}
+export interface NetworkQueryResult {
+    revision: number;
+    resultJson: string;
+    nextOffset: number | null;
+    total: number;
+}
+/** Shared transport only. Each domain retains a separate schema and semantics. */
+export declare abstract class PluginDomainNetworkApi {
+    /** Read the active proposal's architectural context before authoring. Keep one revision across pages. */
+    abstract context(args?: z.input<typeof NetworkContextArgs>): PluginApiReturn<NetworkContextResult>;
+    /** Validate authored JSON, pinned families and recipe evaluation without placing or saving anything.
+     * This does not build kernel meshes or certify engineering/code compliance.
+     */
+    abstract validate(args: z.input<typeof NetworkValidateArgs>): PluginApiReturn<NetworkValidation>;
+    /** Construct each node on its authored storey, with one undo command and queued project persistence.
+     * Networks can span storeys. Reuse requestId on retry; components returns the durable node mapping.
+     * Coordinates are world millimetres, Y-up; rotations are degrees. No engineering rules are inferred.
+     * Throws for stale architecture, invalid references/geometry or conflicting retries.
+     */
+    abstract create(args: z.input<typeof NetworkCreateArgs>): PluginApiReturn<NetworkCreateResult>;
+    /** Read one saved graph in the active proposal; null on miss. IDs are durable, not worker handles. */
+    abstract get(args: z.input<typeof NetworkGetArgs>): PluginApiReturn<SavedNetworkGraph | null>;
+    /** Read bounded authored topology in graph revision. Crossings do not connect. No clash/compliance claims. */
+    abstract query(args: z.input<typeof NetworkQueryArgs>): PluginApiReturn<NetworkQueryResult>;
+}
+/** Electrical equipment, physical routes and logical circuits, constructed from agent-authored intent. */
+export declare abstract class PluginElectricalApi extends PluginDomainNetworkApi {
+}
+/** Plumbing equipment and routed pipe networks, constructed from agent-authored intent. */
+export declare abstract class PluginPlumbingApi extends PluginDomainNetworkApi {
+    /** Offset one straight pipe perpendicular to its axis between two rigid 90-degree elbows.
+     * Resize adjacent pipes through instance length parameters. Out-of-plane offsets add
+     * one pinned elbow and straight pipe per affected end, preserving fixed outer ports
+     * and existing component identities. Rigid fittings only rotate and translate.
+     * Reject axial sliding, moving tees, constrained fittings,
+     * scene drift, stale revisions, and infeasible family geometry before mutation.
+     * @param args Graph/edge identity, current revision, displacement handle in world mm,
+     * and a unique retry identity. Identical retries return the original receipt after undo too.
+     * @returns Affected component IDs and revision in one undoable, queued transaction.
+     * @example
+     * const displacement = await snaptrude.core.math.vec3.new(0, 300, 0)
+     * await snaptrude.design.plumbing.moveEdge({ graphId, edgeId, expectedRevision,
+     *   displacement, requestId: crypto.randomUUID() })
+     */
+    abstract moveEdge(args: NetworkMoveEdgeArgs): PluginApiReturn<NetworkMoveEdgeResult>;
+}
+/** Family-backed air-side HVAC networks. The agent authors engineering intent; the host constructs it. */
+export declare abstract class PluginMechanicalApi extends PluginDomainNetworkApi {
+}
+//# sourceMappingURL=networks.d.ts.map