@enyo-energy/energy-app-sdk 0.0.109 → 0.0.111

package/README.md

@@ -9,6 +9,7 @@ The official TypeScript SDK for building Energy Apps on the enyo platform. Creat
 
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [Choosing the Right API](#choosing-the-right-api)
 - [Core Concepts](#core-concepts)
   - [Energy App Lifecycle](#energy-app-lifecycle)
   - [Package Definition](#package-definition)
@@ -22,6 +23,22 @@ The official TypeScript SDK for building Energy Apps on the enyo platform. Creat
   - [User Features](#user-features)
   - [App Intelligence](#app-intelligence)
 - [Advanced Modbus Integration](#advanced-modbus-integration)
+- [Device Integrations](#device-integrations)
+  - [IntegrationEnergyApp (Base Class)](#integrationenergyapp-base-class)
+  - [HeatpumpIntegrationEnergyApp](#heatpumpintegrationenergyapp)
+  - [WallboxIntegrationEnergyApp](#wallboxintegrationenergyapp)
+  - [StorageIntegrationEnergyApp](#storageintegrationenergyapp)
+  - [InverterIntegrationEnergyApp](#inverterintegrationenergyapp)
+  - [AirConditioningIntegrationEnergyApp](#airconditioningintegrationenergyapp)
+  - [EnergyManagerEnergyApp](#energymanagerenergyapp)
+- [Forecasting](#forecasting)
+  - [ForecastConfig](#forecastconfig)
+  - [PvProductionForecast](#pvproductionforecast)
+  - [BatteryForecast](#batteryforecast)
+  - [HomeConsumptionForecast](#homeconsumptionforecast)
+  - [EvChargingForecast](#evchargingforecast)
+  - [HeatpumpConsumptionForecast](#heatpumpconsumptionforecast)
+  - [HeatpumpDhwTemperatureForecast](#heatpumpdhwtemperatureforecast)
 - [Examples](#examples)
   - [Basic Energy App](#basic-energy-app)
   - [Device Integration](#device-integration)
@@ -76,6 +93,36 @@ async function startApp() {
 }
 ```
 
+## Choosing the Right API
+
+The SDK exposes several layered building blocks. Pick the one that matches the kind of app you are building before diving into the API reference:
+
+- **Core SDK (`EnergyApp`)** — the always-present facade for system lifecycle, storage, data bus, settings, notifications, and HTTP. Every Energy App uses it.
+- **Modbus helpers (`EnergyAppModbusInverter` / `Battery` / `Meter`)** — vendor-agnostic, configuration-driven Modbus access for raw register polling.
+- **Device Integrations (`*IntegrationEnergyApp`)** — *inbound* abstractions for apps that **drive a real device** (heatpump, wallbox, inverter, storage, air conditioning). They subscribe to the right data-bus commands, dispatch them to your handlers, auto-acknowledge, and expose typed `publish*` helpers for status updates.
+- **Forecasting (`*Forecast`, `EnergyManagerEnergyApp`)** — *outbound* abstractions for apps that **predict** future PV production, consumption, battery state, EV charging load, heatpump load, or DHW tank temperature using historical timeseries plus live data-bus updates.
+
+### Decision Matrix
+
+| If you want to… | Use |
+|---|---|
+| React to system lifecycle, store data, send notifications | [`EnergyApp`](#api-reference) |
+| Talk to a Modbus device through configuration only | [`EnergyAppModbusInverter` / `Battery` / `Meter`](#advanced-modbus-integration) |
+| Build a **device integration** for a heatpump | [`HeatpumpIntegrationEnergyApp`](#heatpumpintegrationenergyapp) |
+| Build a **device integration** for an EV wallbox | [`WallboxIntegrationEnergyApp`](#wallboxintegrationenergyapp) |
+| Build a **device integration** for a battery / storage system | [`StorageIntegrationEnergyApp`](#storageintegrationenergyapp) |
+| Build a **device integration** for a PV inverter | [`InverterIntegrationEnergyApp`](#inverterintegrationenergyapp) |
+| Build a **device integration** for an air-conditioning unit | [`AirConditioningIntegrationEnergyApp`](#airconditioningintegrationenergyapp) |
+| Build an **energy manager** that orchestrates many forecasters | [`EnergyManagerEnergyApp`](#energymanagerenergyapp) |
+| Forecast PV production for a single inverter | [`PvProductionForecast`](#pvproductionforecast) |
+| Forecast battery state-of-charge | [`BatteryForecast`](#batteryforecast) |
+| Forecast total household consumption | [`HomeConsumptionForecast`](#homeconsumptionforecast) |
+| Forecast EV charging demand | [`EvChargingForecast`](#evchargingforecast) |
+| Forecast heatpump electrical consumption | [`HeatpumpConsumptionForecast`](#heatpumpconsumptionforecast) |
+| Forecast heatpump DHW tank temperature | [`HeatpumpDhwTemperatureForecast`](#heatpumpdhwtemperatureforecast) |
+
+> **Rule of thumb:** if your app *receives* commands and drives hardware, you want an **Integration**. If your app *produces* predictions, you want a **Forecast** (and likely an `EnergyManagerEnergyApp` to wire several together).
+
 ## Core Concepts
 
 ### Energy App Lifecycle
@@ -859,6 +906,333 @@ The Modbus implementation follows a clean, modular architecture:
 
 This modular design ensures maintainability, testability, and extensibility for future enhancements.
 
+## Device Integrations
+
+Device Integrations are the high-level building blocks for apps that **drive a real device** — a heatpump, EV wallbox, PV inverter, battery storage system, or air-conditioning unit. Each integration class hides the data-bus plumbing for its appliance type so you only implement the business logic that physically controls the device.
+
+### ✨ What the integration framework does for you
+
+- **Subscribes** to the relevant `*CommandV1` data-bus messages for the appliance type.
+- **Dispatches** each command to the async handler you register.
+- **Auto-acknowledges** every command via a `CommandAcknowledgeV1` response containing your `Accepted` / `Rejected` / `NotSupported` answer.
+- **Handles broadcast `GridOperatorPowerLimitationV1`** (§14a EnWG) and routes it once per managed appliance.
+- **Manages lifecycle** — auto-starts on construction and auto-stops on shutdown by default.
+- **Exposes typed `publish*` helpers** so your handler implementations can broadcast status updates back to the system without hand-building messages.
+
+### 🚀 Quick Start
+
+```typescript
+import {
+    HeatpumpIntegrationEnergyApp,
+    EnyoSourceEnum,
+    EnyoCommandAcknowledgeAnswerEnum,
+    ApplianceManager,
+} from '@enyo-energy/energy-app-sdk';
+
+class MyHeatpumpApp extends HeatpumpIntegrationEnergyApp {
+    constructor(applianceManager: ApplianceManager) {
+        super({ source: EnyoSourceEnum.Device, applianceManager });
+    }
+
+    protected async handleHeatpumpOverheating(message) {
+        await driveOverheating(message.data);
+        return { answer: EnyoCommandAcknowledgeAnswerEnum.Accepted };
+    }
+
+    protected async handleHeatpumpAvailablePowerAnnouncement(message) {
+        await scaleHeatpumpToEnvelope(message.data);
+        return { answer: EnyoCommandAcknowledgeAnswerEnum.Accepted };
+    }
+
+    protected async handleGridOperatorPowerLimitation(message, applianceId) {
+        await applyGridLimit(applianceId, message.data);
+        return { applianceId, answer: EnyoCommandAcknowledgeAnswerEnum.Accepted };
+    }
+}
+```
+
+### IntegrationEnergyApp (Base Class)
+
+`IntegrationEnergyApp` is the abstract base every device integration extends. It owns the data-bus subscription/acknowledgment loop and the broadcast routing so subclasses only declare *what* commands they care about and *how* to fulfil them.
+
+**Constructor options (`IntegrationEnergyAppOptions`)**
+
+| Field | Type | Default | Purpose |
+|---|---|---|---|
+| `source` | `EnyoSourceEnum` | required | Source identifier for outbound messages (typically `Device`). |
+| `applianceManager` | `ApplianceManager` | optional | Lookup all appliances of the integration's `managedApplianceType`. |
+| `applianceIds` | `string[]` | optional | Explicit list of appliance IDs to manage. Overrides the manager-based lookup. |
+| `autoStart` | `boolean` | `true` | Subscribe to the data bus immediately after construction. |
+| `autoStopOnShutdown` | `boolean` | `true` | Register an SDK shutdown hook to release listeners. |
+
+**Lifecycle**
+
+- `start(): void` — idempotent; registers all command handlers via the subclass's `registerHandlers()`.
+- `stop(): void` — releases listeners and disposes the outbound command handler.
+
+**For subclass authors**
+
+- `protected abstract registerHandlers(): void` — call `registerCommandHandler(messageType, handler)` for each command you want to receive.
+- `protected abstract handleGridOperatorPowerLimitation(message, applianceId)` — handle the §14a EnWG broadcast per managed appliance.
+- `protected abstract get managedApplianceType(): EnyoApplianceTypeEnum` — used to resolve appliance IDs when no explicit list is given.
+
+### HeatpumpIntegrationEnergyApp
+
+Drives a heatpump. Manages building / DHW overheating commands and grid-power-availability announcements.
+
+- **Subscribed commands:** `HeatpumpOverheatingV1`, `HeatpumpAvailablePowerAnnouncementV1`, `GridOperatorPowerLimitationV1` (broadcast)
+- **Implement:** `handleHeatpumpOverheating`, `handleHeatpumpAvailablePowerAnnouncement`, `handleGridOperatorPowerLimitation`
+- **Publish helpers:**
+  - `publishHeatpumpValuesUpdate(applianceId, values)` — operation mode, electrical and thermal power, energies.
+  - `publishHeatpumpTemperatures(applianceId, temperatures)` — outdoor, flow, return, DHW tanks, heating circuits, buffer tank.
+
+### WallboxIntegrationEnergyApp
+
+Drives an EV wallbox / charger. Has the richest command surface of all integrations.
+
+- **Subscribed commands:** `StartChargeV1`, `StopChargeV1`, `PauseChargingV1`, `ResumeChargingV1`, `ChangeChargingPowerV1`, `SetChargingScheduleV1`, `ResetChargerV1`, `RebootChargerV1`, `RequestChargerLogsV1`, `ClearChargingProfilesV1`, `GridOperatorPowerLimitationV1` (broadcast)
+- **Implement:** one `handle*` method per command listed above plus `handleGridOperatorPowerLimitation`.
+- **Publish helpers:**
+  - `publishChargingStarted(applianceId, data)` / `publishChargingStopped(applianceId, data)`
+  - `publishChargingMeterValues(applianceId, data)` — periodic meter values during a session.
+  - `publishMaxChargingPowerChanged(applianceId, maxChargingPowerKw)` — e.g. on thermal derating.
+  - `publishChargerStatusChanged(applianceId, data)` — OCPP-style status changes.
+
+```typescript
+class MyWallbox extends WallboxIntegrationEnergyApp {
+    constructor(applianceManager: ApplianceManager) {
+        super({ source: EnyoSourceEnum.Device, applianceManager });
+    }
+
+    protected async handleStartCharge(message) {
+        const txId = await this.driver.start(message.data);
+        this.publishChargingStarted(message.applianceId, { transactionId: txId });
+        return { answer: EnyoCommandAcknowledgeAnswerEnum.Accepted };
+    }
+    // ... other handlers
+}
+```
+
+### StorageIntegrationEnergyApp
+
+Drives a battery / storage system. Controls grid-charging windows and discharge limits.
+
+- **Subscribed commands:** `StartStorageGridChargeV1`, `StopStorageGridChargeV1`, `SetStorageDischargeLimitV1`, `GridOperatorPowerLimitationV1` (broadcast)
+- **Implement:** `handleStartStorageGridCharge`, `handleStopStorageGridCharge`, `handleSetStorageDischargeLimit`, `handleGridOperatorPowerLimitation`.
+- **Publish helpers:**
+  - `publishBatteryValuesUpdate(applianceId, data)` — state, power, SoC.
+  - `publishMaxDischargePowerChanged(applianceId, maxDischargePowerKw)` — discharge-limit changes.
+
+### InverterIntegrationEnergyApp
+
+Drives a PV inverter. Controls grid feed-in limits and publishes electrical metrics.
+
+- **Subscribed commands:** `SetInverterFeedInLimitV1`, `GridOperatorPowerLimitationV1` (broadcast)
+- **Implement:** `handleSetInverterFeedInLimit` (`data.feedInLimitW` may be `null` to clear), `handleGridOperatorPowerLimitation`.
+- **Publish helpers:**
+  - `publishInverterValuesUpdate(applianceId, data)` — DC strings, AC voltages, total PV power, operating state.
+
+### AirConditioningIntegrationEnergyApp
+
+Drives an air-conditioning unit. Starts and stops heating or cooling modes.
+
+- **Subscribed commands:** `StartAirConditioningV1`, `StopAirConditioningV1`, `GridOperatorPowerLimitationV1` (broadcast)
+- **Implement:** `handleStartAirConditioning` (mode is `Heating` or `Cooling`), `handleStopAirConditioning`, `handleGridOperatorPowerLimitation`.
+- **Publish helpers:**
+  - `publishAirConditioningValues(applianceId, values)` — current operation mode and electrical consumption.
+  - `publishAirConditioningTemperatures(applianceId, data)` — current and target temperatures per room.
+
+### EnergyManagerEnergyApp
+
+`EnergyManagerEnergyApp` is the **counterpart** to the device integrations: instead of receiving commands, it produces forecasts. It is the recommended entry point when your app needs **multiple forecasters** wired together — it lazily creates each forecaster on first request, caches it, and disposes them all on shutdown.
+
+**Constructor**
+
+```typescript
+new EnergyManagerEnergyApp({
+    source: EnyoSourceEnum.Device,
+    forecastConfig?: ForecastConfig,   // applied to every forecaster unless overridden per call
+    autoStopOnShutdown?: boolean,      // default true
+});
+```
+
+**Lazy forecaster factories** — each returns a ready-to-use forecaster (history loaded, live listeners attached):
+
+- `getPvProductionForecast(applianceId, config?)`
+- `getBatteryForecast(applianceId, config?)`
+- `getHomeConsumptionForecast(config?)` — system-wide, no appliance ID
+- `getEvChargingForecast(applianceId, config?)`
+- `getHeatpumpConsumptionForecast(applianceId, config?)`
+- `getHeatpumpDhwTemperatureForecast(applianceId, config?)`
+
+**Lifecycle**
+
+- `stop(): void` — disposes every cached forecaster.
+
+```typescript
+const manager = new EnergyManagerEnergyApp({ source: EnyoSourceEnum.Device });
+
+const pv = await manager.getPvProductionForecast('inverter-1');
+const battery = await manager.getBatteryForecast('battery-1');
+
+const pvForecast = pv.getForecast();
+const batteryForecast = battery.getForecast();
+```
+
+## Forecasting
+
+The forecasting module provides 24-hour predictions across the energy domains the SDK already understands (PV, battery, home consumption, EV charging, heatpump consumption, DHW temperature). Every forecaster follows the same lifecycle and shares the same configuration shape, so once you've used one you've used them all.
+
+### ✨ Common pattern
+
+1. Construct the forecaster with the SDK app, the appliance ID (where applicable), and an optional `ForecastConfig`.
+2. `await initialize()` — pulls historical timeseries and subscribes to live data-bus updates.
+3. Call `getForecast()` whenever you need a fresh prediction (cheap; uses in-memory state).
+4. Optionally call `publishForecast()` to manually push to the data bus (or rely on auto-publish).
+5. `dispose()` to release listeners on shutdown.
+
+All forecasters compute **same-weekday recency-weighted averages** at 15-minute resolution and optionally smooth the first ~2 hours toward recent actuals. `PvProductionForecast` is the exception — sun position is weekday-independent, so it weights all days equally.
+
+### ForecastConfig
+
+The shared configuration applied to every forecaster.
+
+| Field | Type | Default | Purpose |
+|---|---|---|---|
+| `historyDays` | `number` | `7` | Lookback window for historical timeseries. |
+| `resolution` | `'1m' \| '15m'` | `'15m'` | Slot granularity for both history and forecast. |
+| `horizonHours` | `number` | `24` | How far ahead to forecast. |
+| `alignToRecentActuals` | `boolean` | `true` | Smoothly join the first ~2 forecast hours to recent observations. |
+| `publishToBus` | `boolean` | `true` | Auto-publish to the data bus on every refresh. |
+
+> **Per-forecaster overrides:** `PvProductionForecast` defaults to **4 days** (sun-driven, recency matters most). `BatteryForecast`, `EvChargingForecast`, and `HomeConsumptionForecast` default to **14 days** (strongly weekday-cyclic).
+
+All forecasters return a `BaseForecast<D>`-shaped object:
+
+```typescript
+{
+    generatedAtIso: string;      // ISO timestamp of computation
+    data: {
+        resolution: '1m' | '15m';
+        entries: Array<{ startIso: string; /* per-class fields */ }>;
+    };
+}
+```
+
+### PvProductionForecast
+
+Forecasts the AC power output of a single PV inverter.
+
+```typescript
+new PvProductionForecast(app, applianceId, { source: EnyoSourceEnum.Device, config? });
+```
+
+- **Output per slot:** `{ powerW: number; powerWh: number }`
+- **History default:** 4 days, all-day weighting.
+- **Live source:** `InverterValuesUpdateV1`.
+
+### BatteryForecast
+
+Forecasts state-of-charge (and derived stored energy) for a single battery.
+
+```typescript
+new BatteryForecast(app, applianceId, {
+    source: EnyoSourceEnum.Device,
+    config?: { ratedCapacityWh?: number, ...ForecastConfig }
+});
+```
+
+- **Output per slot:** `{ socPercent: number; capacityWh: number }` (SoC clamped to `[0, 100]`).
+- **History default:** 14 days.
+- **Notable config:** `ratedCapacityWh` is auto-loaded from the appliance metadata if omitted.
+- **Live source:** `BatteryValuesUpdateV1`.
+
+### HomeConsumptionForecast
+
+Forecasts total household electrical consumption — system-wide, no appliance ID.
+
+```typescript
+new HomeConsumptionForecast(app, { source: EnyoSourceEnum.Device, config? });
+```
+
+- **Output per slot:** `{ powerW: number; powerWh: number }`
+- **History default:** 14 days (household routines are strongly weekday-cyclic).
+- **Live source:** `AggregatedStateUpdateV1`.
+
+### EvChargingForecast
+
+Forecasts EV charging power for a single charger.
+
+```typescript
+new EvChargingForecast(app, applianceId, { source: EnyoSourceEnum.Device, config? });
+```
+
+- **Output per slot:** `{ powerW: number; powerWh: number }`
+- **History default:** 14 days.
+- **Live source:** `ChargingMeterValuesUpdateV1`.
+
+### HeatpumpConsumptionForecast
+
+Forecasts the electrical consumption of a heatpump (heating + cooling combined).
+
+```typescript
+new HeatpumpConsumptionForecast(app, applianceId, { source: EnyoSourceEnum.Device, config? });
+```
+
+- **Output per slot:** `{ powerW: number; powerWh: number }`
+- **History default:** 7 days.
+- **Live source:** `HeatpumpValuesUpdateV1`.
+- **Note:** does not adjust for forecasted weather; layer COP-based correction on top if you need that.
+
+### HeatpumpDhwTemperatureForecast
+
+Forecasts the temperature of a heatpump's domestic-hot-water tank.
+
+```typescript
+new HeatpumpDhwTemperatureForecast(app, applianceId, {
+    source: EnyoSourceEnum.Device,
+    config?: { dhwTankIndex?: number, ...ForecastConfig }
+});
+```
+
+- **Output per slot:** `{ temperatureC: number }` (rounded to 0.1 °C).
+- **History default:** 7 days.
+- **Notable config:** `dhwTankIndex` selects a specific tank (zero-based); omit to average across all tanks.
+- **Live source:** heatpump temperature timeseries / live updates.
+
+### 🚀 Common usage example
+
+```typescript
+import {
+    PvProductionForecast,
+    BatteryForecast,
+    EnyoSourceEnum,
+} from '@enyo-energy/energy-app-sdk';
+
+const pv = new PvProductionForecast(energyApp, 'inverter-1', {
+    source: EnyoSourceEnum.Device,
+});
+const battery = new BatteryForecast(energyApp, 'battery-1', {
+    source: EnyoSourceEnum.Device,
+    config: { ratedCapacityWh: 10_000 },
+});
+
+await Promise.all([pv.initialize(), battery.initialize()]);
+
+energyApp.useInterval().createInterval('15m', () => {
+    const pvNext24h = pv.getForecast();
+    const batteryNext24h = battery.getForecast();
+    runDispatch(pvNext24h, batteryNext24h);
+});
+
+energyApp.onShutdown(async () => {
+    pv.dispose();
+    battery.dispose();
+});
+```
+
+> **Tip:** if your app needs more than one forecaster, prefer [`EnergyManagerEnergyApp`](#energymanagerenergyapp) — it manages construction, caching, and disposal for you.
+
 ## Examples
 
 ### Basic Energy App

package/dist/cjs/energy-app.cjs

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnergyApp = void 0;
+const version_js_1 = require("./version.cjs");
+/**
+ * Concrete implementation of {@link EnyoEnergyAppSdk} that delegates every call
+ * to the runtime-provided `energyAppSdkInstance` global.
+ *
+ * This class is the canonical entry point for an energy app: an integrator
+ * instantiates one `EnergyApp`, then either consumes its `use*()` accessors
+ * directly or extends one of the specialized abstract integration classes
+ * (e.g. `HeatpumpIntegrationEnergyApp`) which build on top of this class.
+ *
+ * @example
+ * ```ts
+ * const app = new EnergyApp();
+ * app.register((packageName, version, channel, deviceId) => {
+ *   // perform initialization
+ * });
+ * ```
+ */
+class EnergyApp {
+    energyAppSdk;
+    constructor() {
+        // in our runtime, there is an instance of energyAppSdk available which needs to be used here
+        // if the energyAppSdk is not available, instantiate a mocked version for local development
+        // @ts-ignore
+        if (energyAppSdkInstance === undefined || energyAppSdkInstance === null) {
+            throw new Error('Missing energyAppSdk instance');
+        }
+        else {
+            // @ts-ignore
+            this.energyAppSdk = energyAppSdkInstance;
+        }
+    }
+    isSystemOnline() {
+        return this.energyAppSdk.isSystemOnline();
+    }
+    /**
+     * Registers a listener that gets called when the network status changes.
+     * @param listener - Callback invoked with `true` when the system goes online, `false` when it goes offline
+     * @returns A unique listener ID that can be used to remove the listener
+     */
+    onNetworkStatusChanged(listener) {
+        return this.energyAppSdk.onNetworkStatusChanged(listener);
+    }
+    updateEnergyAppState(state) {
+        this.energyAppSdk.updateEnergyAppState(state);
+    }
+    register(callback) {
+        // This registers the package with the enyo system
+        this.energyAppSdk.register(callback);
+    }
+    onShutdown(callback) {
+        process.on('beforeExit', async (code) => {
+            await callback();
+        });
+        process.on('exit', async (code) => {
+            await callback();
+        });
+    }
+    useFetch() {
+        return this.energyAppSdk.useFetch();
+    }
+    useInterval() {
+        return this.energyAppSdk.useInterval();
+    }
+    useModbus() {
+        return this.energyAppSdk.useModbus();
+    }
+    useNetworkDevices() {
+        return this.energyAppSdk.useNetworkDevices();
+    }
+    useStorage() {
+        return this.energyAppSdk.useStorage();
+    }
+    useAppliances() {
+        return this.energyAppSdk.useAppliances();
+    }
+    useDataBus() {
+        return this.energyAppSdk.useDataBus();
+    }
+    useOcpp() {
+        return this.energyAppSdk.useOcpp();
+    }
+    useVehicle() {
+        return this.energyAppSdk.useVehicle();
+    }
+    useChargingCard() {
+        return this.energyAppSdk.useChargingCard();
+    }
+    useCharge() {
+        return this.energyAppSdk.useCharge();
+    }
+    useAuthentication() {
+        return this.energyAppSdk.useAuthentication();
+    }
+    useSettings() {
+        return this.energyAppSdk.useSettings();
+    }
+    useElectricityPrices() {
+        return this.energyAppSdk.useElectricityPrices();
+    }
+    useNotification() {
+        return this.energyAppSdk.useNotification();
+    }
+    useOnboarding() {
+        return this.energyAppSdk.useOnboarding();
+    }
+    /**
+     * Gets the Secret Manager API for retrieving secrets from the developer organization.
+     * Provides methods to fetch secrets that have been configured in the developer org's secret store.
+     * @returns The Secret Manager API instance
+     */
+    useSecretManager() {
+        return this.energyAppSdk.useSecretManager();
+    }
+    /**
+     * Gets the Location API for retrieving device location information.
+     * Provides methods to fetch location with varying levels of detail based on permissions.
+     * @returns The Location API instance
+     */
+    useLocation() {
+        return this.energyAppSdk.useLocation();
+    }
+    /**
+     * Gets the Timeseries API for querying historical energy data.
+     * Provides methods to retrieve aggregated timeseries data with 15-minute bucket granularity
+     * for various energy metrics including PV production, battery state, meter values, and grid power.
+     * @returns The Timeseries API instance
+     */
+    useTimeseries() {
+        return this.energyAppSdk.useTimeseries();
+    }
+    /**
+     * Gets the Energy Manager API for retrieving information about the active energy manager.
+     * Provides methods to check the current energy manager and its supported features.
+     * @returns The Energy Manager API instance
+     */
+    useEnergyManager() {
+        return this.energyAppSdk.useEnergyManager();
+    }
+    /**
+     * Gets the Electricity Tariff API for managing electricity tariffs.
+     * Provides methods to register, retrieve, and remove electricity tariffs
+     * used for energy pricing and consumption calculations.
+     * @returns The Electricity Tariff API instance
+     */
+    useElectricityTariff() {
+        return this.energyAppSdk.useElectricityTariff();
+    }
+    /**
+     * Gets the Weather Forecasting API for managing weather forecast providers and retrieving weather forecasts.
+     * Provides methods to register/deregister weather forecast providers, list available providers,
+     * and fetch weather forecasts by zip code or coordinates.
+     * @returns The Weather Forecasting API instance
+     */
+    useWeatherForecasting() {
+        return this.energyAppSdk.useWeatherForecasting();
+    }
+    /**
+     * Gets the PV Forecasting API for managing PV forecast providers and retrieving PV forecasts.
+     * Provides methods to register/deregister PV forecast providers and fetch power production forecasts.
+     * @returns The PV Forecasting API instance
+     */
+    usePvForecasting() {
+        return this.energyAppSdk.usePvForecasting();
+    }
+    /**
+     * Gets the PV System API for managing PV system registrations and configurations.
+     * Provides methods to register, retrieve, update, and remove PV systems
+     * including DC string orientations, peak power, associated appliances, and feature flags.
+     * @returns The PV System API instance
+     */
+    usePvSystem() {
+        return this.energyAppSdk.usePvSystem();
+    }
+    /**
+     * Gets the Sequence Generator API for generating unique sequential numbers per named sequence.
+     * Each sequence is identified by a string name and maintains its own independent counter.
+     * @returns The Sequence Generator API instance
+     */
+    useSequenceGenerator() {
+        return this.energyAppSdk.useSequenceGenerator();
+    }
+    /**
+     * Gets the Modbus RTU serial communication API.
+     * Provides methods to connect to Modbus RTU devices over serial ports
+     * and read/write registers using slave IDs.
+     * @returns The Modbus RTU API instance
+     */
+    useModbusRtu() {
+        return this.energyAppSdk.useModbusRtu();
+    }
+    /**
+     * 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.
+     * @returns The EEbus API instance
+     */
+    useEebus() {
+        return this.energyAppSdk.useEebus();
+    }
+    /**
+     * Gets the MQTT communication API.
+     * Provides methods to connect to the SDK-provided internal MQTT broker
+     * or external custom brokers for publishing and subscribing to topics.
+     * @returns The MQTT API instance
+     */
+    useMqtt() {
+        return this.energyAppSdk.useMqtt();
+    }
+    /**
+     * Gets the Diagnostics API for submitting energy manager diagnostics data.
+     * Allows energy managers to report current state, forecast, and control plan
+     * for internal processing and analysis.
+     * @returns The Diagnostics API instance
+     */
+    useDiagnostics() {
+        return this.energyAppSdk.useDiagnostics();
+    }
+    /**
+     * Gets the Learning Phase API for registering and tracking learning phases.
+     * Provides methods to register new learning phases, check their status,
+     * and retrieve learning phase history for the package or specific appliances.
+     * @returns The Learning Phase API instance
+     */
+    useLearningPhase() {
+        return this.energyAppSdk.useLearningPhase();
+    }
+    /**
+     * Gets the current SDK version.
+     * @returns The semantic version string of the SDK
+     */
+    getSdkVersion() {
+        return (0, version_js_1.getSdkVersion)();
+    }
+}
+exports.EnergyApp = EnergyApp;