@enyo-energy/energy-app-sdk 0.0.125 → 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() {
@@ -263,6 +269,15 @@ class EnergyApp {
     useUdp() {
         return this.energyAppSdk.useUdp();
     }
+    /**
+     * Gets the Grid Connection Point API for retrieving details about the
+     * site's grid connection (main fuse rating in amperes, number of phases,
+     * and maximum allowed grid power in watts).
+     * @returns The Grid Connection Point API instance
+     */
+    useGridConnectionPoint() {
+        return this.energyAppSdk.useGridConnectionPoint();
+    }
     /**
      * Gets the current SDK version.
      * @returns The semantic version string of the SDK

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

@@ -32,6 +32,7 @@ import { EnergyAppDiagnostics } from "./packages/energy-app-diagnostics.cjs";
 import { EnergyAppLearningPhase } from "./packages/energy-app-learning-phase.cjs";
 import { EnergyAppWifi } from "./packages/energy-app-wifi.cjs";
 import { EnergyAppUdp } from "./packages/energy-app-udp.cjs";
+import { EnergyAppGridConnectionPoint } from "./packages/energy-app-grid-connection-point.cjs";
 /**
  * Concrete implementation of {@link EnyoEnergyAppSdk} that delegates every call
  * to the runtime-provided `energyAppSdkInstance` global.
@@ -146,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;
@@ -200,6 +207,13 @@ export declare class EnergyApp implements EnyoEnergyAppSdk {
      *         is not granted.
      */
     useUdp(): EnergyAppUdp;
+    /**
+     * Gets the Grid Connection Point API for retrieving details about the
+     * site's grid connection (main fuse rating in amperes, number of phases,
+     * and maximum allowed grid power in watts).
+     * @returns The Grid Connection Point API instance
+     */
+    useGridConnectionPoint(): EnergyAppGridConnectionPoint;
     /**
      * Gets the current SDK version.
      * @returns The semantic version string of the SDK

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

@@ -31,6 +31,7 @@ import { EnergyAppDiagnostics } from "./packages/energy-app-diagnostics.cjs";
 import { EnergyAppLearningPhase } from "./packages/energy-app-learning-phase.cjs";
 import { EnergyAppWifi } from "./packages/energy-app-wifi.cjs";
 import { EnergyAppUdp } from "./packages/energy-app-udp.cjs";
+import { EnergyAppGridConnectionPoint } from "./packages/energy-app-grid-connection-point.cjs";
 export declare enum EnergyAppStateEnum {
     Launching = "launching",
     Running = "running",
@@ -121,4 +122,6 @@ export interface EnyoEnergyAppSdk {
     useWifi: () => EnergyAppWifi;
     /** Get the UDP communication API for binding sockets and exchanging datagrams */
     useUdp: () => EnergyAppUdp;
+    /** Get the Grid Connection Point API for retrieving fuse rating, phase count, and power limit of the site's grid connection */
+    useGridConnectionPoint: () => EnergyAppGridConnectionPoint;
 }

package/dist/cjs/implementations/appliances/appliance-manager.cjs

@@ -127,6 +127,7 @@ class ApplianceManager {
             inverter: appliance.inverter,
             temperatureSensor: appliance.temperatureSensor,
             airConditioning: appliance.airConditioning,
+            cloudPackageId: appliance.cloudPackageId,
         };
         // When updating an existing appliance, merge metadata to preserve existing keys
         let applianceData = newApplianceData;

package/dist/cjs/implementations/appliances/appliance-manager.d.cts

@@ -31,6 +31,12 @@ export interface ApplianceConfig {
     battery?: EnyoBatteryApplianceMetadata;
     temperatureSensor?: EnyoTemperatureSensorApplianceMetadata;
     airConditioning?: EnyoAirConditioningApplianceMetadata;
+    /**
+     * Optional identifier of the cloud-deployed energy app package that manages
+     * this appliance. Forwarded to {@link EnyoAppliance.cloudPackageId} when the
+     * appliance is created or updated.
+     */
+    cloudPackageId?: string;
 }
 /**
  * Configuration options for the ApplianceManager.
@@ -249,4 +255,9 @@ export interface PartialEnyoAppliance {
     airConditioning?: Partial<EnyoAirConditioningApplianceMetadata>;
     /** Optional custom name for the appliance, defined by the user */
     customName?: string;
+    /**
+     * Optional identifier of the cloud-deployed energy app package that manages
+     * this appliance. Mirrors {@link EnyoAppliance.cloudPackageId}.
+     */
+    cloudPackageId?: string;
 }

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);
@@ -60,6 +61,8 @@ __exportStar(require("./packages/energy-app-learning-phase.cjs"), exports);
 __exportStar(require("./types/enyo-wifi.cjs"), exports);
 __exportStar(require("./packages/energy-app-wifi.cjs"), exports);
 __exportStar(require("./packages/energy-app-udp.cjs"), exports);
+__exportStar(require("./types/enyo-grid-connection-point.cjs"), exports);
+__exportStar(require("./packages/energy-app-grid-connection-point.cjs"), exports);
 __exportStar(require("./types/enyo-air-conditioning-appliance.cjs"), exports);
 __exportStar(require("./types/enyo-onboarding.cjs"), exports);
 __exportStar(require("./packages/energy-app-onboarding.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';
@@ -44,6 +45,8 @@ export * from './packages/energy-app-learning-phase.cjs';
 export * from './types/enyo-wifi.cjs';
 export * from './packages/energy-app-wifi.cjs';
 export * from './packages/energy-app-udp.cjs';
+export * from './types/enyo-grid-connection-point.cjs';
+export * from './packages/energy-app-grid-connection-point.cjs';
 export * from './types/enyo-air-conditioning-appliance.cjs';
 export * from './types/enyo-onboarding.cjs';
 export * from './packages/energy-app-onboarding.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 });