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

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-hvac-client.cjs

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

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

@@ -0,0 +1,61 @@
+import { EebusHvacOperationMode, EebusHvacZoneState } from '../../types/enyo-eebus-use-cases.cjs';
+/**
+ * Client for the EEBUS **Hvac** feature.
+ *
+ * The Hvac feature reports heating/cooling operation mode and per-zone state
+ * (current temperature, active mode). Pair with the
+ * {@link EebusSetpointClient} Setpoint feature to read or write target values.
+ * Zone ids align with `Identification.identificationListData`, so callers can
+ * map zone state to human-readable zone names.
+ *
+ * The client exposes both actor roles on a single interface:
+ * - **EMS role (outbound):** {@link getOperationMode}, {@link setOperationMode},
+ *   {@link getZoneStates}, {@link onZoneStateChanged}
+ * - **CS role (inbound):** {@link provideOperationMode}, {@link provideZoneStates}
+ *
+ * Consumers that only act in one role simply never call the other half — there
+ * is no `asManager` / `asAppliance` split.
+ */
+export interface EebusHvacClient {
+    /**
+     * Read the active heating/cooling operation mode from the remote node.
+     */
+    getOperationMode: () => Promise<EebusHvacOperationMode>;
+    /**
+     * Request the remote node to switch to the given operation mode. The
+     * remote may reject modes it does not advertise — verify support via
+     * `EebusIdentityService.getSupportedUseCases` before calling.
+     * @param mode The operation mode to select on the remote
+     */
+    setOperationMode: (mode: EebusHvacOperationMode) => Promise<void>;
+    /**
+     * Read per-zone Hvac state (current temperature, active mode) from the
+     * remote node.
+     * @returns The state of each zone reported by the remote.
+     */
+    getZoneStates: () => Promise<EebusHvacZoneState[]>;
+    /**
+     * Subscribe to per-zone Hvac state updates. The listener fires once per
+     * zone whenever the remote republishes its state.
+     * @param listener Callback invoked with the updated zone state
+     * @returns Listener ID that can be passed to {@link removeListener} to cancel
+     */
+    onZoneStateChanged: (listener: (state: EebusHvacZoneState) => void) => string;
+    /**
+     * Register a provider that supplies this device's current operation mode
+     * when a remote EMS reads it.
+     * @param provider Async callback returning the active operation mode
+     */
+    provideOperationMode: (provider: () => Promise<EebusHvacOperationMode>) => void;
+    /**
+     * Register a provider that supplies this device's current per-zone state
+     * when a remote EMS reads it.
+     * @param provider Async callback returning the current zone-state list
+     */
+    provideZoneStates: (provider: () => Promise<EebusHvacZoneState[]>) => void;
+    /**
+     * Remove a listener previously registered via {@link onZoneStateChanged}.
+     * @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-setpoint-client.cjs

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

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

@@ -0,0 +1,59 @@
+import { EebusSetpointValue } from '../../types/enyo-eebus-use-cases.cjs';
+/**
+ * Client for the EEBUS **Setpoint** feature.
+ *
+ * The Setpoint feature carries the target value(s) of a controllable
+ * parameter on a remote node — most commonly the per-zone target temperature
+ * on a heat pump (paired with the {@link EebusHvacClient} Hvac feature for
+ * measured values). Setpoint ids align with the zone ids reported by
+ * `Identification.identificationListData`, so callers can map setpoints to
+ * human-readable zone names.
+ *
+ * The client exposes both actor roles on a single interface:
+ * - **EMS role (outbound):** {@link getSetpoints}, {@link setSetpoint},
+ *   {@link onSetpointsChanged}
+ * - **CS role (inbound):** {@link provideSetpoints}, {@link onSetpointReceived}
+ *
+ * Consumers that only act in one role simply never call the other half — there
+ * is no `asManager` / `asAppliance` split.
+ */
+export interface EebusSetpointClient {
+    /**
+     * Read the current setpoints reported by the remote node.
+     * @returns The full list of setpoints currently published by the remote.
+     */
+    getSetpoints: () => Promise<EebusSetpointValue[]>;
+    /**
+     * Send a setpoint to the remote node. The remote applies the value to the
+     * setpoint identified by {@link EebusSetpointValue.setpointId}; existing
+     * setpoints at other ids are left unchanged.
+     * @param value The setpoint to apply
+     */
+    setSetpoint: (value: EebusSetpointValue) => Promise<void>;
+    /**
+     * Subscribe to setpoint-list updates from the remote node. The listener is
+     * invoked with the full current list whenever the remote republishes.
+     * @param listener Callback invoked with the new setpoint list
+     * @returns Listener ID that can be passed to {@link removeListener} to cancel
+     */
+    onSetpointsChanged: (listener: (values: EebusSetpointValue[]) => void) => string;
+    /**
+     * Register a provider that supplies this device's current setpoints when a
+     * remote EMS reads them.
+     * @param provider Async callback returning the current setpoint list
+     */
+    provideSetpoints: (provider: () => Promise<EebusSetpointValue[]>) => void;
+    /**
+     * Register a handler invoked when a remote EMS writes a setpoint to this
+     * device. Implementations should apply the value to the local controller.
+     * @param handler Callback invoked with the incoming setpoint
+     * @returns Listener ID that can be passed to {@link removeListener} to deregister
+     */
+    onSetpointReceived: (handler: (value: EebusSetpointValue) => Promise<void>) => string;
+    /**
+     * Remove a listener previously registered via {@link onSetpointsChanged} or
+     * {@link onSetpointReceived}.
+     * @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 });