@enyo-energy/energy-app-sdk 0.0.126 → 0.0.127

package/dist/cjs/energy-app-package-definition.d.cts

@@ -61,8 +61,13 @@ export interface EnergyAppPackageOptionsDeviceDetectionOcpp {
     matchingValues: string[];
 }
 export interface EnergyAppPackageOptionsDeviceDetectionEebus {
-    /** field name in the boot notification */
-    field: 'vendor' | 'brand' | 'model';
+    /**
+     * Field name to match against from the remote node's EEBUS Node
+     * Identification (NID) data. `'deviceCode'` and `'manufacturerNodeIdentification'`
+     * map to the corresponding fields on `EebusNodeIdentity` and allow
+     * stable identification across firmware upgrades.
+     */
+    field: 'vendor' | 'brand' | 'model' | 'deviceCode' | 'manufacturerNodeIdentification';
     /** matching values, for example the vendor names or model names */
     matchingValues: string[];
 }

package/dist/cjs/energy-app.cjs

@@ -195,9 +195,15 @@ class EnergyApp {
     }
     /**
      * Gets the EEbus API for SHIP/SPINE device communication.
-     * Provides device pairing and discovery, low-level SPINE data access,
-     * and high-level convenience methods for power management and device classification.
-     * Supports both appliance and energy manager roles for bidirectional communication.
+     *
+     * The returned facade splits responsibilities across four sub-interfaces:
+     * - `devices` — SHIP-level device lifecycle (pairing, discovery, connection)
+     * - `identity` — EEBUS Node Identification (NID): observable identity, diagnosis, use-case discovery
+     * - `useCases` — typed use-case clients: LPC, LPP, MGCP, MPC, OHPCF
+     * - `spine` — low-level SPINE escape hatch for features not yet wrapped
+     *
+     * Use-case clients carry both Energy Management System and Controllable
+     * System methods; consumers act in whichever role(s) they need.
      * @returns The EEbus API instance
      */
     useEebus() {

package/dist/cjs/energy-app.d.cts

@@ -147,9 +147,15 @@ export declare class EnergyApp implements EnyoEnergyAppSdk {
     useModbusRtu(): EnergyAppModbusRtu;
     /**
      * Gets the EEbus API for SHIP/SPINE device communication.
-     * Provides device pairing and discovery, low-level SPINE data access,
-     * and high-level convenience methods for power management and device classification.
-     * Supports both appliance and energy manager roles for bidirectional communication.
+     *
+     * The returned facade splits responsibilities across four sub-interfaces:
+     * - `devices` — SHIP-level device lifecycle (pairing, discovery, connection)
+     * - `identity` — EEBUS Node Identification (NID): observable identity, diagnosis, use-case discovery
+     * - `useCases` — typed use-case clients: LPC, LPP, MGCP, MPC, OHPCF
+     * - `spine` — low-level SPINE escape hatch for features not yet wrapped
+     *
+     * Use-case clients carry both Energy Management System and Controllable
+     * System methods; consumers act in whichever role(s) they need.
      * @returns The EEbus API instance
      */
     useEebus(): EnergyAppEebus;

package/dist/cjs/index.cjs

@@ -48,6 +48,7 @@ __exportStar(require("./packages/energy-app-sequence-generator.cjs"), exports);
 __exportStar(require("./packages/energy-app-energy-prices.cjs"), exports);
 __exportStar(require("./packages/energy-app-modbus-rtu.cjs"), exports);
 __exportStar(require("./types/enyo-eebus.cjs"), exports);
+__exportStar(require("./types/enyo-eebus-use-cases.cjs"), exports);
 __exportStar(require("./packages/energy-app-eebus.cjs"), exports);
 __exportStar(require("./types/enyo-mqtt.cjs"), exports);
 __exportStar(require("./packages/energy-app-mqtt.cjs"), exports);

package/dist/cjs/index.d.cts

@@ -32,6 +32,7 @@ export * from './packages/energy-app-sequence-generator.cjs';
 export * from './packages/energy-app-energy-prices.cjs';
 export * from './packages/energy-app-modbus-rtu.cjs';
 export * from './types/enyo-eebus.cjs';
+export * from './types/enyo-eebus-use-cases.cjs';
 export * from './packages/energy-app-eebus.cjs';
 export * from './types/enyo-mqtt.cjs';
 export * from './packages/energy-app-mqtt.cjs';

package/dist/cjs/packages/eebus/eebus-device-management.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-device-management.d.cts

@@ -0,0 +1,78 @@
+import { EebusConnectionStatusEnum, EebusDevice, EebusDiscoveredDevice } from '../../types/enyo-eebus.cjs';
+/**
+ * SHIP-level device lifecycle management for EEbus devices.
+ *
+ * Handles discovery, pairing (trust establishment), connection control, and
+ * connection-status observation. This interface is concerned only with the
+ * underlying SHIP transport — application-level interactions (identity,
+ * use cases) live in {@link EebusIdentityService} and {@link EebusUseCaseRegistry}.
+ *
+ * @example
+ * ```typescript
+ * const eebus = energyApp.useEebus();
+ *
+ * const discovered = await eebus.devices.getDiscoveredDevices();
+ * const device = await eebus.devices.pairDevice(discovered[0].ski);
+ * await eebus.devices.connect(device.ski);
+ *
+ * const listenerId = eebus.devices.listenForConnectionStatusChange((ski, status) => {
+ *   console.log(`${ski} → ${status}`);
+ * });
+ * ```
+ */
+export interface EebusDeviceManagement {
+    /**
+     * Get all devices that have been successfully paired (trusted).
+     * @returns Array of paired EEbus devices with their current connection status
+     */
+    getPairedDevices: () => Promise<EebusDevice[]>;
+    /**
+     * Get devices currently visible on the network that have not yet been paired.
+     * Uses mDNS discovery to find EEbus-capable devices.
+     * @returns Array of discovered but unpaired EEbus devices
+     */
+    getDiscoveredDevices: () => Promise<EebusDiscoveredDevice[]>;
+    /**
+     * Initiate the EEbus pairing (trust) handshake with a device identified by its SKI.
+     * The device must have been previously discovered via {@link getDiscoveredDevices}.
+     * @param ski Subject Key Identifier of the device to pair with
+     * @returns The newly paired device
+     */
+    pairDevice: (ski: string) => Promise<EebusDevice>;
+    /**
+     * Remove the trust relationship and delete stored connection information for a paired device.
+     * If the device is currently connected, it will be disconnected first.
+     * @param ski Subject Key Identifier of the device to unpair
+     */
+    unpairDevice: (ski: string) => Promise<void>;
+    /**
+     * Establish an active SHIP connection to an already-paired device.
+     * The device must have been previously paired via {@link pairDevice}.
+     * @param ski Subject Key Identifier of the device to connect to
+     */
+    connect: (ski: string) => Promise<void>;
+    /**
+     * Safely disconnect from a currently connected device.
+     * @param ski Subject Key Identifier of the device to disconnect from
+     */
+    disconnect: (ski: string) => Promise<void>;
+    /**
+     * Check the current connection status of a device.
+     * @param ski Subject Key Identifier of the device to check
+     * @returns The current connection status (Connected, Disconnected, or Connecting)
+     */
+    getConnectionStatus: (ski: string) => Promise<EebusConnectionStatusEnum>;
+    /**
+     * Register a listener for connection status changes of EEbus devices.
+     * The listener is invoked whenever any paired device's connection status changes.
+     * @param listener Callback invoked with the device SKI and its new connection status
+     * @returns Listener ID that can be passed to {@link removeListener} to stop listening
+     */
+    listenForConnectionStatusChange: (listener: (ski: string, status: EebusConnectionStatusEnum) => void) => string;
+    /**
+     * Remove a connection-status listener previously registered via
+     * {@link listenForConnectionStatusChange}.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-identity-service.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-identity-service.d.cts

@@ -0,0 +1,66 @@
+import { EebusNodeIdentity, EebusUseCaseSupport } from '../../types/enyo-eebus.cjs';
+/**
+ * Identity service for the EEBUS Node Identification (NID) data of a remote node.
+ *
+ * NID is the SPINE-mandatory bootstrap exchange that every EEbus device performs
+ * after the SHIP handshake. It combines `NodeManagement.DetailedDiscoveryData` +
+ * `NodeManagement.UseCaseData` + `DeviceClassification.ManufacturerData`/`UserData`
+ * + `DeviceDiagnosis` (state + heartbeat).
+ *
+ * **Identity is observable, not one-shot.** The remote may reboot, update its
+ * firmware, change its `UserNodeIdentification`, or demote its operating state
+ * via a `DeviceDiagnosis` heartbeat at any time. Consumers that cache a
+ * Promise-resolved snapshot will ship UI bugs. Always pair {@link get} with
+ * {@link onIdentityChanged}.
+ *
+ * @example
+ * ```typescript
+ * const id = await eebus.identity.get(ski);
+ * console.log(`${id.brandName} ${id.deviceName} (${id.operatingState})`);
+ *
+ * eebus.identity.onIdentityChanged(ski, (next) => {
+ *   if (next.operatingState === EebusOperatingStateEnum.Failure) alert();
+ * });
+ *
+ * const supported = await eebus.identity.getSupportedUseCases(ski);
+ * if (supported.some(u => u.name === 'limitationOfPowerConsumption' && u.available)) {
+ *   await eebus.useCases.lpc(ski).setConsumptionLimit({ value: 11000, isActive: true });
+ * }
+ * ```
+ */
+export interface EebusIdentityService {
+    /**
+     * Get the current identity snapshot for a remote node.
+     * The snapshot reflects the most recent SPINE state observed by the SDK;
+     * it does not trigger a re-fetch from the remote. To observe live changes
+     * (firmware updates, operating-state demotions, heartbeat losses) use
+     * {@link onIdentityChanged}.
+     * @param ski Subject Key Identifier of the remote node
+     * @returns The current identity snapshot
+     */
+    get: (ski: string) => Promise<EebusNodeIdentity>;
+    /**
+     * Subscribe to identity changes for a remote node. The listener is invoked
+     * whenever any field of the node's identity changes — including firmware
+     * revisions, user node identification, operating state, and heartbeat.
+     * @param ski Subject Key Identifier of the remote node
+     * @param listener Callback invoked with the full updated identity snapshot
+     * @returns Listener ID that can be passed to {@link removeListener} to cancel
+     */
+    onIdentityChanged: (ski: string, listener: (identity: EebusNodeIdentity) => void) => string;
+    /**
+     * Enumerate the EEBUS use cases the remote node advertises in
+     * `NodeManagement.UseCaseData`. Call this before invoking any
+     * {@link EebusUseCaseRegistry} client to verify the remote actually
+     * implements the use case in the actor role you intend to use.
+     * @param ski Subject Key Identifier of the remote node
+     * @returns Array of supported use cases with actor, name, version, scenarios
+     */
+    getSupportedUseCases: (ski: string) => Promise<EebusUseCaseSupport[]>;
+    /**
+     * Remove an identity-change listener previously registered via
+     * {@link onIdentityChanged}.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-lpc-client.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-lpc-client.d.cts

@@ -0,0 +1,55 @@
+import { EebusLpcAck, EebusLpcFailsafe, EebusLpcLimit } from '../../types/enyo-eebus-use-cases.cjs';
+/**
+ * Client for the EEBUS **Limitation of Power Consumption (LPC)** use case.
+ *
+ * LPC is an *obligation*: when an Energy Management System (EMS) sends a limit,
+ * the receiving Controllable System (CS) MUST respect it. Compare with
+ * {@link EebusLppClient} which is a recommendation.
+ *
+ * The client exposes both actor roles on a single interface:
+ * - **EMS role (outbound):** {@link setConsumptionLimit}, {@link getActiveConsumptionLimit},
+ *   {@link getFailsafeLimit}
+ * - **CS role (inbound):** {@link onConsumptionLimitReceived}, {@link provideFailsafeLimit}
+ *
+ * Consumers that only act in one role simply never call the other half — there is
+ * no `asManager` / `asAppliance` split.
+ */
+export interface EebusLpcClient {
+    /**
+     * Send a consumption limit to the controllable system. The remote is
+     * obligated to respect the limit until it expires, is replaced, or is
+     * cleared by sending a limit with `isActive: false`.
+     * @param limit The consumption limit to apply
+     */
+    setConsumptionLimit: (limit: EebusLpcLimit) => Promise<void>;
+    /**
+     * Read the consumption limit currently active on the controllable system,
+     * if any. Useful for verifying that a previously-sent limit was applied,
+     * or for synchronising on reconnect.
+     * @returns The active limit, or `undefined` if no limit is currently active
+     */
+    getActiveConsumptionLimit: () => Promise<EebusLpcLimit | undefined>;
+    /**
+     * Read the failsafe limit the controllable system will fall back to if
+     * it loses the connection to this EMS.
+     */
+    getFailsafeLimit: () => Promise<EebusLpcFailsafe>;
+    /**
+     * Register a handler invoked when a remote EMS sends a consumption limit
+     * to this device. The handler MUST return an acknowledgement.
+     * @param handler Callback invoked with the incoming limit; returns the ack
+     * @returns Listener ID that can be passed to {@link removeListener} to deregister
+     */
+    onConsumptionLimitReceived: (handler: (limit: EebusLpcLimit) => Promise<EebusLpcAck>) => string;
+    /**
+     * Register a provider that supplies this device's current failsafe limit
+     * when a remote EMS reads it.
+     * @param provider Async callback returning the current failsafe configuration
+     */
+    provideFailsafeLimit: (provider: () => Promise<EebusLpcFailsafe>) => void;
+    /**
+     * Remove a handler previously registered via {@link onConsumptionLimitReceived}.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-lpp-client.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-lpp-client.d.cts

@@ -0,0 +1,50 @@
+import { EebusLppAck, EebusLppFailsafe, EebusLppLimit } from '../../types/enyo-eebus-use-cases.cjs';
+/**
+ * Client for the EEBUS **Limitation of Power Production (LPP)** use case.
+ *
+ * LPP is a *recommendation*: when an Energy Management System (EMS) sends a
+ * production limit, the producing Controllable System (CS) SHOULD respect it
+ * but is not contractually obligated. Compare with {@link EebusLpcClient} which
+ * is an obligation.
+ *
+ * The client exposes both actor roles on a single interface:
+ * - **EMS role (outbound):** {@link setProductionLimit}, {@link getActiveProductionLimit},
+ *   {@link getFailsafeLimit}
+ * - **CS role (inbound):** {@link onProductionLimitReceived}, {@link provideFailsafeLimit}
+ */
+export interface EebusLppClient {
+    /**
+     * Send a production limit recommendation to the producing controllable system.
+     * @param limit The production limit recommendation to apply
+     */
+    setProductionLimit: (limit: EebusLppLimit) => Promise<void>;
+    /**
+     * Read the production limit currently active on the controllable system,
+     * if any.
+     * @returns The active limit, or `undefined` if no limit is currently active
+     */
+    getActiveProductionLimit: () => Promise<EebusLppLimit | undefined>;
+    /**
+     * Read the failsafe limit the controllable system will fall back to if
+     * it loses the connection to this EMS.
+     */
+    getFailsafeLimit: () => Promise<EebusLppFailsafe>;
+    /**
+     * Register a handler invoked when a remote EMS sends a production limit
+     * recommendation to this device.
+     * @param handler Callback invoked with the incoming limit; returns the ack
+     * @returns Listener ID that can be passed to {@link removeListener} to deregister
+     */
+    onProductionLimitReceived: (handler: (limit: EebusLppLimit) => Promise<EebusLppAck>) => string;
+    /**
+     * Register a provider that supplies this device's current failsafe limit
+     * when a remote EMS reads it.
+     * @param provider Async callback returning the current failsafe configuration
+     */
+    provideFailsafeLimit: (provider: () => Promise<EebusLppFailsafe>) => void;
+    /**
+     * Remove a handler previously registered via {@link onProductionLimitReceived}.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-mgcp-client.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-mgcp-client.d.cts

@@ -0,0 +1,35 @@
+import { EebusMgcpReading } from '../../types/enyo-eebus-use-cases.cjs';
+/**
+ * Client for the EEBUS **Monitoring of Grid Connection Point (MGCP)** use case.
+ *
+ * MGCP is read-only telemetry from a smart meter / grid connection point.
+ * The CEM (Customer Energy Manager) actor consumes the readings; the GCP
+ * (Grid Connection Point) actor provides them.
+ *
+ * The client exposes both actor roles on a single interface:
+ * - **CEM role (consume):** {@link getReading}, {@link onReading}
+ * - **GCP role (provide):** {@link provideReading}
+ */
+export interface EebusMgcpClient {
+    /**
+     * Read the latest telemetry from the grid connection point.
+     */
+    getReading: () => Promise<EebusMgcpReading>;
+    /**
+     * Subscribe to updates whenever the grid connection point publishes new telemetry.
+     * @param listener Callback invoked with each new reading
+     * @returns Listener ID that can be passed to {@link removeListener} to cancel
+     */
+    onReading: (listener: (reading: EebusMgcpReading) => void) => string;
+    /**
+     * Register a provider that supplies the current grid connection point reading
+     * when a remote CEM reads it.
+     * @param provider Async callback returning the current reading
+     */
+    provideReading: (provider: () => Promise<EebusMgcpReading>) => void;
+    /**
+     * Remove a listener previously registered via {@link onReading}.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-mpc-client.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-mpc-client.d.cts

@@ -0,0 +1,34 @@
+import { EebusMpcReading } from '../../types/enyo-eebus-use-cases.cjs';
+/**
+ * Client for the EEBUS **Monitoring of Power Consumption (MPC)** use case.
+ *
+ * MPC is read-only telemetry from a controllable system reporting its own
+ * power consumption to the EMS.
+ *
+ * The client exposes both actor roles on a single interface:
+ * - **EMS role (consume):** {@link getReading}, {@link onReading}
+ * - **CS role (provide):** {@link provideReading}
+ */
+export interface EebusMpcClient {
+    /**
+     * Read the latest consumption telemetry from the controllable system.
+     */
+    getReading: () => Promise<EebusMpcReading>;
+    /**
+     * Subscribe to updates whenever the controllable system publishes new telemetry.
+     * @param listener Callback invoked with each new reading
+     * @returns Listener ID that can be passed to {@link removeListener} to cancel
+     */
+    onReading: (listener: (reading: EebusMpcReading) => void) => string;
+    /**
+     * Register a provider that supplies the current consumption reading
+     * when a remote EMS reads it.
+     * @param provider Async callback returning the current reading
+     */
+    provideReading: (provider: () => Promise<EebusMpcReading>) => void;
+    /**
+     * Remove a listener previously registered via {@link onReading}.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-ohpcf-client.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-ohpcf-client.d.cts

@@ -0,0 +1,64 @@
+import { EebusOhpcfFlexibility, EebusOhpcfIncentiveTable, EebusOhpcfPlanState } from '../../types/enyo-eebus-use-cases.cjs';
+/**
+ * Client for the EEBUS **Optimization of Self Consumption by Heat Pump
+ * Compressor Flexibility (OHPCF)** use case.
+ *
+ * OHPCF is an *incentive-driven* use case — the CEM (Customer Energy Manager)
+ * sends a time-varying price/cost table; the heat pump schedules its
+ * compressor to favour cheap or green windows without further coordination.
+ * This is structurally different from LPC/LPP (which use LoadControl). The
+ * CEM does not command the heat pump — it informs.
+ *
+ * The client exposes both actor roles on a single interface:
+ * - **CEM role:** {@link sendIncentiveTable}, {@link getCurrentPlanState},
+ *   {@link onFlexibilityUpdate}
+ * - **Heat Pump role:** {@link provideFlexibility}, {@link providePlanState},
+ *   {@link onIncentiveTableReceived}
+ *
+ * @see https://techdocs.wago.com/Software/EEBUS_Connector/en-US/3657311371.html
+ * @see https://github.com/enbility/eebus-go/pull/122
+ */
+export interface EebusOhpcfClient {
+    /**
+     * Send an incentive table to the heat pump. The heat pump will use
+     * the table to plan its compressor operation over the covered horizon.
+     * @param table The incentive table to send
+     */
+    sendIncentiveTable: (table: EebusOhpcfIncentiveTable) => Promise<void>;
+    /**
+     * Read the heat pump's current operational plan, generated in response
+     * to the most recent incentive table.
+     */
+    getCurrentPlanState: () => Promise<EebusOhpcfPlanState>;
+    /**
+     * Subscribe to compressor flexibility updates from the heat pump.
+     * Allows the CEM to track the operating band it can shift consumption within.
+     * @param listener Callback invoked with each new flexibility report
+     * @returns Listener ID that can be passed to {@link removeListener} to cancel
+     */
+    onFlexibilityUpdate: (listener: (flexibility: EebusOhpcfFlexibility) => void) => string;
+    /**
+     * Register a provider that reports the heat pump's current compressor
+     * flexibility when a remote CEM reads it.
+     * @param provider Async callback returning the current flexibility report
+     */
+    provideFlexibility: (provider: () => Promise<EebusOhpcfFlexibility>) => void;
+    /**
+     * Register a provider that reports the heat pump's current operational
+     * plan state when a remote CEM reads it.
+     * @param provider Async callback returning the current plan state
+     */
+    providePlanState: (provider: () => Promise<EebusOhpcfPlanState>) => void;
+    /**
+     * Register a handler invoked when a remote CEM sends a new incentive table
+     * to the heat pump.
+     * @param handler Async callback invoked with the incoming incentive table
+     * @returns Listener ID that can be passed to {@link removeListener} to deregister
+     */
+    onIncentiveTableReceived: (handler: (table: EebusOhpcfIncentiveTable) => Promise<void>) => string;
+    /**
+     * Remove a listener or handler previously registered on this client.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-spine-low-level.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-spine-low-level.d.cts

@@ -0,0 +1,53 @@
+import { EebusDataPoint } from '../../types/enyo-eebus.cjs';
+/**
+ * Low-level SPINE escape hatch for direct feature data access.
+ *
+ * The typed use-case clients ({@link EebusUseCaseRegistry}) cover the
+ * common cases — prefer them when they exist. Reach for this interface
+ * only when:
+ * - the remote exposes a SPINE feature not yet wrapped by a typed client
+ * - you need to interact with a custom or vendor-specific feature
+ * - you are prototyping a new use-case wrapper
+ *
+ * **Feature types are strings, not an enum.** SPINE defines roughly 80
+ * feature types and the catalog grows. The previous closed enum was
+ * removed because it silently blocked consumers from anything outside
+ * its 7 entries. Canonical feature-type names include
+ * `'DeviceClassification'`, `'DeviceDiagnosis'`, `'ElectricalConnection'`,
+ * `'Measurement'`, `'LoadControl'`, `'DeviceConfiguration'`,
+ * `'Identification'`, `'IncentiveTable'`, `'TimeSeries'`, `'Hvac'`,
+ * `'SmartEnergyManagementPs'`, and many more — consult the SPINE spec.
+ */
+export interface EebusSpineLowLevel {
+    /**
+     * Read specific data points from a SPINE feature on a remote device.
+     * @param ski Subject Key Identifier of the target device
+     * @param featureType SPINE feature type name (e.g. `'Measurement'`)
+     * @param functionName Specific function or data set to read (e.g. `'measurementListData'`)
+     * @returns The data point containing the raw value, timestamp, and optional unit
+     */
+    readData: (ski: string, featureType: string, functionName: string) => Promise<EebusDataPoint>;
+    /**
+     * Write data or send a command to a SPINE feature on a remote device.
+     * @param ski Subject Key Identifier of the target device
+     * @param featureType SPINE feature type name (e.g. `'LoadControl'`)
+     * @param functionName Specific function or command to invoke (e.g. `'loadControlLimitListData'`)
+     * @param payload The raw data payload to send — caller is responsible for matching the SPINE schema
+     */
+    writeData: (ski: string, featureType: string, functionName: string, payload: unknown) => Promise<void>;
+    /**
+     * Subscribe to automatic notifications when a SPINE feature's data changes.
+     * Sets up a SPINE binding so the local device is notified whenever the
+     * subscribed data changes.
+     * @param ski Subject Key Identifier of the target device
+     * @param featureType SPINE feature type name to subscribe to
+     * @param listener Callback invoked with updated data whenever the value changes
+     * @returns Listener ID that can be passed to {@link removeListener} to cancel the subscription
+     */
+    subscribe: (ski: string, featureType: string, listener: (data: EebusDataPoint) => void) => string;
+    /**
+     * Remove a subscription previously registered via {@link subscribe}.
+     * @param listenerId The ID returned by the registration method
+     */
+    removeListener: (listenerId: string) => void;
+}

package/dist/cjs/packages/eebus/eebus-use-case-registry.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-use-case-registry.d.cts

@@ -0,0 +1,72 @@
+import { EebusLpcClient } from './eebus-lpc-client.cjs';
+import { EebusLppClient } from './eebus-lpp-client.cjs';
+import { EebusMgcpClient } from './eebus-mgcp-client.cjs';
+import { EebusMpcClient } from './eebus-mpc-client.cjs';
+import { EebusOhpcfClient } from './eebus-ohpcf-client.cjs';
+/**
+ * Registry of typed EEBUS use-case clients, scoped per remote device (SKI).
+ *
+ * Each accessor returns a client interface that knows how to talk to the named
+ * use case on the given remote node, in both actor roles. Adding a new use
+ * case in the future is a mechanical change: add one type group to
+ * `enyo-eebus-use-cases.ts`, one client interface file under `packages/eebus/`,
+ * and one accessor here.
+ *
+ * Before invoking a use-case client, consider verifying that the remote
+ * actually advertises support for it via
+ * {@link EebusIdentityService.getSupportedUseCases}.
+ *
+ * @example
+ * ```typescript
+ * // Energy manager limits a wallbox to 11kW
+ * await eebus.useCases.lpc(wallboxSki).setConsumptionLimit({
+ *   value: 11000,
+ *   isActive: true,
+ * });
+ *
+ * // CEM streams grid-connection-point telemetry from the house meter
+ * eebus.useCases.mgcp(meterSki).onReading(r => {
+ *   chart.push({ t: r.timestamp, p: r.activePowerW });
+ * });
+ *
+ * // CEM coordinates a heat pump via incentive table
+ * await eebus.useCases.ohpcf(heatPumpSki).sendIncentiveTable({
+ *   currency: 'EUR',
+ *   unit: 'kWh',
+ *   tiers: hourlyPriceTiers,
+ * });
+ * ```
+ */
+export interface EebusUseCaseRegistry {
+    /**
+     * Get the **Limitation of Power Consumption** client for a remote node.
+     * LPC limits are obligations the remote MUST respect.
+     * @param ski Subject Key Identifier of the remote node
+     */
+    lpc: (ski: string) => EebusLpcClient;
+    /**
+     * Get the **Limitation of Power Production** client for a remote node.
+     * LPP limits are recommendations the remote SHOULD respect.
+     * @param ski Subject Key Identifier of the remote node
+     */
+    lpp: (ski: string) => EebusLppClient;
+    /**
+     * Get the **Monitoring of Grid Connection Point** client for a remote node.
+     * Read-only telemetry from a smart meter / grid connection point.
+     * @param ski Subject Key Identifier of the remote node
+     */
+    mgcp: (ski: string) => EebusMgcpClient;
+    /**
+     * Get the **Monitoring of Power Consumption** client for a remote node.
+     * Read-only telemetry from a controllable system reporting its own consumption.
+     * @param ski Subject Key Identifier of the remote node
+     */
+    mpc: (ski: string) => EebusMpcClient;
+    /**
+     * Get the **Optimization of Self Consumption by Heat Pump Compressor
+     * Flexibility** client for a remote node. Incentive-table-driven heat
+     * pump coordination.
+     * @param ski Subject Key Identifier of the remote node
+     */
+    ohpcf: (ski: string) => EebusOhpcfClient;
+}

package/dist/cjs/packages/eebus/energy-app-eebus.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });