@enyo-energy/energy-app-sdk 1.45.0 → 1.47.0

package/README.md

@@ -1282,6 +1282,41 @@ settings.listenForSettingsChanges((event) => {
 });
 ```
 
+##### Expert settings and onboarding
+
+These two optional flags work on a single setting and on a setting group:
+
+- `expertSetting: true` hides the setting from the default view and shows it only in the expert / advanced section,
+  e.g. for installers.
+- `showInOnboarding: true` shows the setting during onboarding, so the user can set it while setting up the app.
+
+A setting without its own value inherits the flag from its group. A value set on the setting overrides the group's.
+Both default to `false`.
+
+```typescript
+await settings.addSettingGroup({
+    groupName: 'modbus',
+    caption: [{ language: 'en', value: 'Modbus' }, { language: 'de', value: 'Modbus' }],
+    expertSetting: true,                 // all settings of the group are expert settings ...
+    settings: [
+        {
+            name: 'modbus-host',
+            type: 'text',
+            required: true,
+            fieldName: [{ language: 'en', value: 'IP address' }, { language: 'de', value: 'IP-Adresse' }],
+            expertSetting: false,        // ... except this one, which overrides the group
+            showInOnboarding: true,
+        },
+        {
+            name: 'modbus-unit-id',
+            type: 'integer',
+            required: false,
+            fieldName: [{ language: 'en', value: 'Unit ID' }, { language: 'de', value: 'Unit-ID' }],
+        },
+    ],
+});
+```
+
 #### `useConfigurationManager(): EnergyAppConfigurationManager`
 
 Register **internal**, non user-facing configurations for your package and react to value changes. Unlike `useSettings()`, configurations registered here are NOT rendered in the Energy App UI — they are intended for values the package itself reads and writes at runtime (e.g. internal feature toggles, tuning parameters, calibration values) and need to be persisted across restarts.
@@ -4068,6 +4103,7 @@ Drives a PV inverter. Controls grid feed-in limits and publishes electrical metr
 - **Implement:** `handleSetInverterFeedInLimit` (`data.feedInLimitW` may be `null` to clear), `handleGridOperatorPowerLimitation`.
 - **Publish helpers:**
   - `publishInverterValuesUpdate(applianceId, data)` — DC strings, AC voltages, total PV power, operating state.
+  - `publishGridStatusUpdate(applianceId, data)` — grid outage detection: reports `EnyoGridStatusEnum.OnGrid` / `OffGrid` (plus optional `sinceIso` and `backupPowerActive`) as a `GridStatusUpdateV1` message. Only for inverters declaring `EnyoInverterApplianceAvailableFeaturesEnum.GridOutageDetection`; publish on every status change and once on startup.
 
 ### AirConditioningIntegrationEnergyApp
 
@@ -4380,6 +4416,26 @@ Two charger facts belong on the appliance rather than on a forecast, and `EnyoCh
 
 Both are for marking on the same power scale a consumer already draws from `maxChargingPowerKw`, instead of hard-coding thresholds only the EMS knows.
 
+**DC chargers.** A DC charger (CCS, CHAdeMO) declares the `DcCharging` feature in `availableFeatures`. The EMS
+controls it by power in watts, not by current per phase. These fields apply:
+- `minChargingPowerKw`: the DC minimum, often several kW.
+- `maxChargingPowerKw`: the maximum power.
+- `powerStepW`: the granularity of power setpoints, e.g. `500` for 0.5 kW steps. Omit it when the charger accepts
+  any watt value.
+
+The current- and phase-based fields (`minChargingCurrentAmpere`, `ampereStep`, `availablePhases`, phase switching)
+do not apply to DC chargers.
+
+```typescript
+charger: {
+    availableFeatures: [EnyoChargerApplianceAvailableFeaturesEnum.DcCharging, EnyoChargerApplianceAvailableFeaturesEnum.PowerLimitation],
+    minChargingPowerKw: 5,
+    maxChargingPowerKw: 22,
+    powerStepW: 500,
+    // status, authorizationMode, ...
+}
+```
+
 ### BatteryCommandForecast
 
 A discriminated union on `mode`:
@@ -5099,6 +5155,46 @@ A session kept running because it **must not be paused** at all — the charger'
 
 **Fluctuating PV surplus.** When the surplus jumps around (clouds passing) and the energy manager holds an appliance's power steady instead of following every dip, state `PvSurplusFluctuating` (category `PvSurplus`) with `powerW` set to the power being held — e.g. "Charging power held steady while clouds pass." / "Ladeleistung wird gehalten, solange Wolken durchziehen." It is a smoothing decision, told apart from `PvSurplusAvailable` / `PvSurplusUnavailable`.
 
+## Battery Charge Now
+
+A one-time user request to charge a home battery to full — or to a target SoC — right now. The request is a data bus message **addressed to the battery appliance** but **handled by the energy manager**. The battery integration ignores it, and the energy manager charges the battery with its regular storage commands. If the request went to the battery integration directly, the energy manager's next optimization cycle would override it.
+
+```
+App ──RequestBatteryChargeNowV1 (applianceId = battery)──▶ Energy manager ──SetStorageControlV2 (Charge, reason UserRequest)──▶ Battery integration
+ ▲                                                              │
+ └──────────────BatteryChargeNowStatusV1 (accepted → running → completed / cancelled / aborted / rejected)
+```
+
+| Message | Sent by | Purpose |
+|---|---|---|
+| `RequestBatteryChargeNowV1` | app / core | Start: optional `targetSocPercent` (default 100), `allowGridCharging` (default: allowed), `maxDurationMinutes` (safety stop) |
+| `CancelBatteryChargeNowV1` | app / core | Stop early. Optional `requestMessageId` to cancel only that request. Idempotent |
+| `BatteryChargeNowStatusV1` | energy manager | Progress for the request's `id`: `state`, `stopReason`, `effectiveTargetSocPercent`, `currentSocPercent`, `chargingPowerW`, `estimatedCompletionIso` |
+
+**Offer the button only when someone will act on it.** The app shows "charge battery full now" only if the active energy manager declares `EnergyManagerFeatureEnum.BatteryChargeNow` (check `EnergyManagerInfo.features`) and the battery allows control (`controlAllowed` is not `false`, and its `features` include `ManualCharge` when the list is given).
+
+**What the energy manager must do:**
+
+- Validate the request with `validateBatteryChargeNowRequest(message, metadata, currentSoc)` and publish the result as the first status: `Accepted`, or `Rejected` with a `stopReason`.
+- Rank the request above regular optimization (arbitrage, PV priority, EV discharge rules), but below a grid operator limitation (§14a) and device protection. While one of those caps the battery, the request stays `Running`.
+- Charge with `SetStorageControlV2` (`Controlled` / `Charge`, maximum charging power, reason `UserRequest`). Charge from the grid unless the request says `allowGridCharging: false`. The explicit request overrides the general `BatteryChargeFromGrid` setting.
+- End with `Completed` when the effective target is reached (the requested target, capped at `maxSoC`), with `Aborted` + `MaxDurationReached` / `BatteryStoppedCharging` / `ApplianceOffline` when it can't be finished, or with `Cancelled` on `CancelBatteryChargeNowV1`. Then return to regular planning.
+- Keep at most one request per battery: a new request replaces the running one, which ends `Aborted` + `Superseded`.
+
+```typescript
+em.registerFeatures([EnergyManagerFeatureEnum.BatteryChargeNow]);
+
+dataBus.listenForMessages([EnyoDataBusMessageEnum.RequestBatteryChargeNowV1], (msg) => {
+    const request = msg as EnyoDataBusRequestBatteryChargeNowV1;
+    const battery = appliances.get(request.applianceId);
+    const result = validateBatteryChargeNowRequest(request, battery?.metadata?.battery, currentSoc(request.applianceId));
+    publishStatus(request, result.state, result.stopReason, result.effectiveTargetSocPercent);
+    if (result.state === EnyoBatteryChargeNowStateEnum.Accepted) {
+        startChargeNow(request, result.effectiveTargetSocPercent!);
+    }
+});
+```
+
 ## Dynamic Grid Fees & Tariff Bonuses
 
 An electricity price is rarely one number. It is the energy price, plus the grid operator's network

package/dist/cjs/energy-app-model-feature.enum.cjs

@@ -23,6 +23,8 @@ var EnergyAppModelFeatureEnum;
     EnergyAppModelFeatureEnum["PvFeedInLimitation"] = "pv-feed-in-limitation";
     /** The inverter active power output can be limited */
     EnergyAppModelFeatureEnum["InverterPowerLimitation"] = "inverter-power-limitation";
+    /** The inverter detects grid outages and reports on grid / off grid status */
+    EnergyAppModelFeatureEnum["InverterGridOutageDetection"] = "inverter-grid-outage-detection";
     // Wallbox / Charging
     /** Charging can be started and stopped remotely */
     EnergyAppModelFeatureEnum["ChargingStartStop"] = "charging-start-stop";

package/dist/cjs/energy-app-model-feature.enum.d.cts

@@ -17,6 +17,8 @@ export declare enum EnergyAppModelFeatureEnum {
     PvFeedInLimitation = "pv-feed-in-limitation",
     /** The inverter active power output can be limited */
     InverterPowerLimitation = "inverter-power-limitation",
+    /** The inverter detects grid outages and reports on grid / off grid status */
+    InverterGridOutageDetection = "inverter-grid-outage-detection",
     /** Charging can be started and stopped remotely */
     ChargingStartStop = "charging-start-stop",
     /** The charging power (in Ampere or Watt) can be limited */

package/dist/cjs/implementations/storage/battery-charge-now-validators.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BATTERY_CHARGE_NOW_TARGET_SOC_PERCENT = void 0;
+exports.validateBatteryChargeNowRequest = validateBatteryChargeNowRequest;
+exports.resolveBatteryChargeNowTargetSoc = resolveBatteryChargeNowTargetSoc;
+const enyo_data_bus_value_js_1 = require("../../types/enyo-data-bus-value.cjs");
+const enyo_battery_appliance_js_1 = require("../../types/enyo-battery-appliance.cjs");
+/** Target SoC in percent a `RequestBatteryChargeNowV1` charges to when it names none. */
+exports.DEFAULT_BATTERY_CHARGE_NOW_TARGET_SOC_PERCENT = 100;
+/**
+ * Validates a `RequestBatteryChargeNowV1` against the battery's metadata and
+ * current state of charge, and returns whether an energy manager should accept
+ * it — the answer to publish as the first `BatteryChargeNowStatusV1`.
+ *
+ * Rules, in order — the first that fails decides:
+ * 1. `targetSocPercent`, when given, is a finite number from 1 to 100, and
+ *    `maxDurationMinutes`, when given, is a finite positive number
+ *    (**InvalidRequest**).
+ * 2. The battery's metadata sets `controlAllowed: false`, or lists `features`
+ *    without {@link EnyoBatteryFeature.ManualCharge} (**ControlNotAllowed**).
+ *    A battery without a `features` list is not rejected, since the list is
+ *    optional.
+ * 3. The current SoC is at or above the effective target (**AlreadyAtTarget**).
+ *
+ * Without metadata only rule 1 and, given the SoC, rule 3 are checked. Runtime
+ * conditions the metadata cannot tell — the battery being offline, battery
+ * control switched off in the energy manager settings, no PV surplus for a
+ * battery without grid charging — are left to the energy manager.
+ *
+ * @param message - The request to validate.
+ * @param metadata - The battery's metadata, if known.
+ * @param currentSocPercent - The battery's current state of charge in percent, if known.
+ * @returns `Accepted` with the effective target when every rule holds, otherwise `Rejected` with the reason.
+ */
+function validateBatteryChargeNowRequest(message, metadata, currentSocPercent) {
+    const { targetSocPercent, maxDurationMinutes } = message.data;
+    const targetValid = targetSocPercent === undefined
+        || (Number.isFinite(targetSocPercent) && targetSocPercent >= 1 && targetSocPercent <= 100);
+    const durationValid = maxDurationMinutes === undefined
+        || (Number.isFinite(maxDurationMinutes) && maxDurationMinutes > 0);
+    if (!targetValid || !durationValid) {
+        return reject(enyo_data_bus_value_js_1.EnyoBatteryChargeNowStopReasonEnum.InvalidRequest);
+    }
+    const effectiveTargetSocPercent = resolveBatteryChargeNowTargetSoc(targetSocPercent, metadata);
+    if (metadata) {
+        const lacksManualCharge = metadata.features !== undefined
+            && !metadata.features.includes(enyo_battery_appliance_js_1.EnyoBatteryFeature.ManualCharge);
+        if (metadata.controlAllowed === false || lacksManualCharge) {
+            return reject(enyo_data_bus_value_js_1.EnyoBatteryChargeNowStopReasonEnum.ControlNotAllowed, effectiveTargetSocPercent);
+        }
+    }
+    if (currentSocPercent !== undefined && Number.isFinite(currentSocPercent)
+        && currentSocPercent >= effectiveTargetSocPercent) {
+        return reject(enyo_data_bus_value_js_1.EnyoBatteryChargeNowStopReasonEnum.AlreadyAtTarget, effectiveTargetSocPercent);
+    }
+    return { state: enyo_data_bus_value_js_1.EnyoBatteryChargeNowStateEnum.Accepted, effectiveTargetSocPercent };
+}
+/**
+ * The SoC in percent a `RequestBatteryChargeNowV1` actually charges to: the
+ * requested target (default {@link DEFAULT_BATTERY_CHARGE_NOW_TARGET_SOC_PERCENT}),
+ * lowered to the battery's `maxSoC` when that is lower.
+ *
+ * @param targetSocPercent - The request's `targetSocPercent`, if given.
+ * @param metadata - The battery's metadata, if known.
+ * @returns The effective target SoC in percent.
+ */
+function resolveBatteryChargeNowTargetSoc(targetSocPercent, metadata) {
+    const requested = targetSocPercent ?? exports.DEFAULT_BATTERY_CHARGE_NOW_TARGET_SOC_PERCENT;
+    const maxSoC = metadata?.maxSoC;
+    return maxSoC !== undefined && Number.isFinite(maxSoC) ? Math.min(requested, maxSoC) : requested;
+}
+/**
+ * Builds a rejected {@link BatteryChargeNowValidationResult}.
+ *
+ * @param stopReason - Why the request is rejected.
+ * @param effectiveTargetSocPercent - The effective target, when it could be resolved.
+ * @returns The rejected result.
+ */
+function reject(stopReason, effectiveTargetSocPercent) {
+    return { state: enyo_data_bus_value_js_1.EnyoBatteryChargeNowStateEnum.Rejected, stopReason, effectiveTargetSocPercent };
+}

package/dist/cjs/implementations/storage/battery-charge-now-validators.d.cts

@@ -0,0 +1,57 @@
+import { EnyoBatteryChargeNowStateEnum, EnyoBatteryChargeNowStopReasonEnum, EnyoDataBusRequestBatteryChargeNowV1 } from '../../types/enyo-data-bus-value.cjs';
+import { EnyoBatteryApplianceMetadata } from '../../types/enyo-battery-appliance.cjs';
+/** Target SoC in percent a `RequestBatteryChargeNowV1` charges to when it names none. */
+export declare const DEFAULT_BATTERY_CHARGE_NOW_TARGET_SOC_PERCENT = 100;
+/**
+ * Outcome of {@link validateBatteryChargeNowRequest}: whether an energy manager
+ * should take a `RequestBatteryChargeNowV1` on, and the target it charges to.
+ */
+export interface BatteryChargeNowValidationResult {
+    /** {@link EnyoBatteryChargeNowStateEnum.Accepted} or {@link EnyoBatteryChargeNowStateEnum.Rejected}. */
+    state: EnyoBatteryChargeNowStateEnum.Accepted | EnyoBatteryChargeNowStateEnum.Rejected;
+    /** Why the request is rejected. Set exactly when {@link state} is `Rejected`. */
+    stopReason?: EnyoBatteryChargeNowStopReasonEnum;
+    /**
+     * The SoC in percent to charge to: the requested target (default
+     * {@link DEFAULT_BATTERY_CHARGE_NOW_TARGET_SOC_PERCENT}), lowered to the
+     * battery's `maxSoC` when that is lower. Absent when the request is
+     * malformed.
+     */
+    effectiveTargetSocPercent?: number;
+}
+/**
+ * Validates a `RequestBatteryChargeNowV1` against the battery's metadata and
+ * current state of charge, and returns whether an energy manager should accept
+ * it — the answer to publish as the first `BatteryChargeNowStatusV1`.
+ *
+ * Rules, in order — the first that fails decides:
+ * 1. `targetSocPercent`, when given, is a finite number from 1 to 100, and
+ *    `maxDurationMinutes`, when given, is a finite positive number
+ *    (**InvalidRequest**).
+ * 2. The battery's metadata sets `controlAllowed: false`, or lists `features`
+ *    without {@link EnyoBatteryFeature.ManualCharge} (**ControlNotAllowed**).
+ *    A battery without a `features` list is not rejected, since the list is
+ *    optional.
+ * 3. The current SoC is at or above the effective target (**AlreadyAtTarget**).
+ *
+ * Without metadata only rule 1 and, given the SoC, rule 3 are checked. Runtime
+ * conditions the metadata cannot tell — the battery being offline, battery
+ * control switched off in the energy manager settings, no PV surplus for a
+ * battery without grid charging — are left to the energy manager.
+ *
+ * @param message - The request to validate.
+ * @param metadata - The battery's metadata, if known.
+ * @param currentSocPercent - The battery's current state of charge in percent, if known.
+ * @returns `Accepted` with the effective target when every rule holds, otherwise `Rejected` with the reason.
+ */
+export declare function validateBatteryChargeNowRequest(message: EnyoDataBusRequestBatteryChargeNowV1, metadata?: EnyoBatteryApplianceMetadata, currentSocPercent?: number): BatteryChargeNowValidationResult;
+/**
+ * The SoC in percent a `RequestBatteryChargeNowV1` actually charges to: the
+ * requested target (default {@link DEFAULT_BATTERY_CHARGE_NOW_TARGET_SOC_PERCENT}),
+ * lowered to the battery's `maxSoC` when that is lower.
+ *
+ * @param targetSocPercent - The request's `targetSocPercent`, if given.
+ * @param metadata - The battery's metadata, if known.
+ * @returns The effective target SoC in percent.
+ */
+export declare function resolveBatteryChargeNowTargetSoc(targetSocPercent: number | undefined, metadata?: EnyoBatteryApplianceMetadata): number;

package/dist/cjs/index.cjs

@@ -36,6 +36,7 @@ __exportStar(require("./implementations/appliances/identifier-strategies.cjs"),
 __exportStar(require("./implementations/network-devices/network-access-guard.cjs"), exports);
 __exportStar(require("./implementations/network-devices/network-device-manager.cjs"), exports);
 __exportStar(require("./implementations/storage/storage-schedule-handler.cjs"), exports);
+__exportStar(require("./implementations/storage/battery-charge-now-validators.cjs"), exports);
 __exportStar(require("./enyo-package-channel.cjs"), exports);
 __exportStar(require("./enyo-energy-app-environment.cjs"), exports);
 __exportStar(require("./types/enyo-timeseries.cjs"), exports);

package/dist/cjs/index.d.cts

@@ -20,6 +20,7 @@ export * from './implementations/appliances/identifier-strategies.cjs';
 export * from './implementations/network-devices/network-access-guard.cjs';
 export * from './implementations/network-devices/network-device-manager.cjs';
 export * from './implementations/storage/storage-schedule-handler.cjs';
+export * from './implementations/storage/battery-charge-now-validators.cjs';
 export * from './enyo-package-channel.cjs';
 export * from './enyo-energy-app-environment.cjs';
 export * from './types/enyo-timeseries.cjs';

package/dist/cjs/integrations/inverter-integration-energy-app.cjs

@@ -40,5 +40,25 @@ class InverterIntegrationEnergyApp extends integration_energy_app_js_1.Integrati
         };
         this.useDataBus().sendMessage([msg]);
     }
+    /**
+     * Publishes a `GridStatusUpdateV1` message reporting whether the site is
+     * on grid or off grid (grid outage), as detected by the inverter.
+     *
+     * Only for inverters declaring the `GridOutageDetection` feature. Call it
+     * whenever the detected grid status changes, and once on startup.
+     */
+    publishGridStatusUpdate(applianceId, data) {
+        const msg = {
+            id: this.generateMessageId(),
+            type: 'message',
+            message: enyo_data_bus_value_js_1.EnyoDataBusMessageEnum.GridStatusUpdateV1,
+            source: this.source,
+            applianceId,
+            timestampIso: new Date().toISOString(),
+            resolution: 'dynamic',
+            data
+        };
+        this.useDataBus().sendMessage([msg]);
+    }
 }
 exports.InverterIntegrationEnergyApp = InverterIntegrationEnergyApp;

package/dist/cjs/integrations/inverter-integration-energy-app.d.cts

@@ -1,7 +1,7 @@
 import { IntegrationEnergyApp } from "./integration-energy-app.cjs";
 import { IntegrationCommandResponse, IntegrationEnergyAppOptions } from "./integration-types.cjs";
 import { EnyoApplianceTypeEnum } from "../types/enyo-appliance.cjs";
-import { EnyoDataBusGridOperatorPowerLimitationV1, EnyoDataBusInverterValuesV1, EnyoDataBusSetInverterFeedInLimitV1 } from "../types/enyo-data-bus-value.cjs";
+import { EnyoDataBusGridOperatorPowerLimitationV1, EnyoDataBusGridStatusUpdateV1, EnyoDataBusInverterValuesV1, EnyoDataBusSetInverterFeedInLimitV1 } from "../types/enyo-data-bus-value.cjs";
 /**
  * Abstract base class for PV inverter integrations.
  *
@@ -31,4 +31,12 @@ export declare abstract class InverterIntegrationEnergyApp extends IntegrationEn
      * current state, PV power, voltages, and string values.
      */
     publishInverterValuesUpdate(applianceId: string, data: EnyoDataBusInverterValuesV1['data']): void;
+    /**
+     * Publishes a `GridStatusUpdateV1` message reporting whether the site is
+     * on grid or off grid (grid outage), as detected by the inverter.
+     *
+     * Only for inverters declaring the `GridOutageDetection` feature. Call it
+     * whenever the detected grid status changes, and once on startup.
+     */
+    publishGridStatusUpdate(applianceId: string, data: EnyoDataBusGridStatusUpdateV1['data']): void;
 }

package/dist/cjs/types/enyo-charger-appliance.cjs

@@ -75,4 +75,17 @@ var EnyoChargerApplianceAvailableFeaturesEnum;
      * started remotely; the customer has to unplug the vehicle and plug it in again.
      */
     EnyoChargerApplianceAvailableFeaturesEnum["DisconnectToRestartCharge"] = "DisconnectToRestartCharge";
+    /**
+     * If the charger is a DC charger (e.g. CCS or CHAdeMO), converting to DC
+     * itself instead of feeding AC to the vehicle's on-board charger.
+     *
+     * A DC charger is controlled by power in Watts, not by current per phase:
+     * the EMS uses {@link EnyoChargerApplianceMetadata.minChargingPowerKw},
+     * {@link EnyoChargerApplianceMetadata.maxChargingPowerKw} and
+     * {@link EnyoChargerApplianceMetadata.powerStepW}, and ignores the
+     * Ampere-based fields ({@link EnyoChargerApplianceMetadata.minChargingCurrentAmpere},
+     * {@link EnyoChargerApplianceMetadata.ampereStep}) and phase switching
+     * ({@link EnyoChargerApplianceMetadata.availablePhases}).
+     */
+    EnyoChargerApplianceAvailableFeaturesEnum["DcCharger"] = "DcCharger";
 })(EnyoChargerApplianceAvailableFeaturesEnum || (exports.EnyoChargerApplianceAvailableFeaturesEnum = EnyoChargerApplianceAvailableFeaturesEnum = {}));

package/dist/cjs/types/enyo-charger-appliance.d.cts

@@ -88,7 +88,20 @@ export declare enum EnyoChargerApplianceAvailableFeaturesEnum {
      * Once the charger is in {@link EnyoChargerApplianceStatusEnum.Finishing}, no new charge can be
      * started remotely; the customer has to unplug the vehicle and plug it in again.
      */
-    DisconnectToRestartCharge = "DisconnectToRestartCharge"
+    DisconnectToRestartCharge = "DisconnectToRestartCharge",
+    /**
+     * If the charger is a DC charger (e.g. CCS or CHAdeMO), converting to DC
+     * itself instead of feeding AC to the vehicle's on-board charger.
+     *
+     * A DC charger is controlled by power in Watts, not by current per phase:
+     * the EMS uses {@link EnyoChargerApplianceMetadata.minChargingPowerKw},
+     * {@link EnyoChargerApplianceMetadata.maxChargingPowerKw} and
+     * {@link EnyoChargerApplianceMetadata.powerStepW}, and ignores the
+     * Ampere-based fields ({@link EnyoChargerApplianceMetadata.minChargingCurrentAmpere},
+     * {@link EnyoChargerApplianceMetadata.ampereStep}) and phase switching
+     * ({@link EnyoChargerApplianceMetadata.availablePhases}).
+     */
+    DcCharger = "DcCharger"
 }
 /**
  * Phase configurations a charger can operate in.
@@ -126,7 +139,9 @@ export interface EnyoChargerApplianceMetadata {
      * Lowest power the charger can hold a session at, in kilowatts.
      *
      * The floor below which a session cannot be throttled but only paused —
-     * typically 6 A on one phase (≈ 1.4 kW). Consumers mark it on the power
+     * typically 6 A on one phase (≈ 1.4 kW) on an AC charger. A DC charger
+     * ({@link EnyoChargerApplianceAvailableFeaturesEnum.DcCharger}) states its
+     * own DC minimum here, often several kW. Consumers mark it on the power
      * scale so an owner can see why a plan pauses instead of trickling, and
      * the EMS must not issue a non-zero setpoint below it.
      */
@@ -195,6 +210,18 @@ export interface EnyoChargerApplianceMetadata {
      * @default 1
      */
     ampereStep?: number;
+    /**
+     * Granularity, in Watts, at which the charging power can be set on this
+     * charger. Any non-zero power the EMS issues
+     * ({@link EnyoDataBusSetChargerAvailablePowerV2}) should be a multiple of
+     * this step, e.g. `500` for a DC charger that regulates in 0.5 kW steps.
+     *
+     * The power counterpart of {@link ampereStep}, used by chargers controlled
+     * by power rather than current — above all DC chargers
+     * ({@link EnyoChargerApplianceAvailableFeaturesEnum.DcCharging}). Omit when
+     * the charger accepts any Watt value.
+     */
+    powerStepW?: number;
     /**
      * Phase configurations the charger supports. Each value indicates
      * a phase mode the hardware can operate in:

package/dist/cjs/types/enyo-data-bus-value.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnyoHeatpumpControlActionStateEnum = exports.EnyoHeatpumpControlTargetEnum = exports.EnyoPowerSourceEnum = exports.EnyoHeatpumpHeatSourceEnum = exports.EnyoHeatpumpControlPurposeEnum = exports.EnyoChargingProfileTypeEnum = exports.EnyoCommandAcknowledgeAnswerEnum = exports.EnyoStorageControlDirectionEnum = exports.EnyoStorageControlModeEnum = exports.EnyoStorageScheduleDirectionEnum = exports.EnyoStorageScheduleModeEnum = exports.EnyoChargingLimitRequestResultEnum = exports.EnyoDataBusMessageEnum = exports.EnyoChargeInitiatorEnum = exports.EnyoPriceLimitModeEnum = exports.EnyoChargeModeEnum = exports.EnyoChargingStopReason = exports.EnyoChargingMeterValueContext = exports.EnyoStringStateEnum = exports.EnyoHeatingRodStateEnum = exports.EnyoInverterStateEnum = exports.EnyoBatteryStateEnum = exports.EnyoGridOperatorLimitTypeEnum = exports.EnyoSwitchingProtectionHoldEnum = exports.EnyoBatteryToEvHoldTriggerEnum = exports.EnyoInstallationLimitSourceEnum = exports.EnyoDataBusCommandReasonCategoryEnum = exports.EnyoDataBusCommandReasonTypeEnum = void 0;
+exports.EnyoHeatpumpControlActionStateEnum = exports.EnyoHeatpumpControlTargetEnum = exports.EnyoPowerSourceEnum = exports.EnyoHeatpumpHeatSourceEnum = exports.EnyoHeatpumpControlPurposeEnum = exports.EnyoChargingProfileTypeEnum = exports.EnyoCommandAcknowledgeAnswerEnum = exports.EnyoBatteryChargeNowStopReasonEnum = exports.EnyoBatteryChargeNowStateEnum = exports.EnyoStorageControlDirectionEnum = exports.EnyoStorageControlModeEnum = exports.EnyoStorageScheduleDirectionEnum = exports.EnyoStorageScheduleModeEnum = exports.EnyoChargingLimitRequestResultEnum = exports.EnyoDataBusMessageEnum = exports.EnyoChargeInitiatorEnum = exports.EnyoPriceLimitModeEnum = exports.EnyoChargeModeEnum = exports.EnyoChargingStopReason = exports.EnyoChargingMeterValueContext = exports.EnyoStringStateEnum = exports.EnyoHeatingRodStateEnum = exports.EnyoGridStatusEnum = exports.EnyoInverterStateEnum = exports.EnyoBatteryStateEnum = exports.EnyoGridOperatorLimitTypeEnum = exports.EnyoSwitchingProtectionHoldEnum = exports.EnyoBatteryToEvHoldTriggerEnum = exports.EnyoInstallationLimitSourceEnum = exports.EnyoDataBusCommandReasonCategoryEnum = exports.EnyoDataBusCommandReasonTypeEnum = void 0;
 /**
  * Enum representing the reason type for why a data bus command was issued.
  * Used to attach context to commands for logging, debugging, and UI display.
@@ -593,6 +593,23 @@ var EnyoInverterStateEnum;
     EnyoInverterStateEnum["Fault"] = "fault";
     EnyoInverterStateEnum["Standby"] = "standby";
 })(EnyoInverterStateEnum || (exports.EnyoInverterStateEnum = EnyoInverterStateEnum = {}));
+/**
+ * Whether the public grid is available at the site, as detected by an
+ * appliance declaring
+ * {@link EnyoInverterApplianceAvailableFeaturesEnum.GridOutageDetection}.
+ * Reported on the data bus via {@link EnyoDataBusGridStatusUpdateV1}.
+ */
+var EnyoGridStatusEnum;
+(function (EnyoGridStatusEnum) {
+    /** The public grid is available and the site is connected to it */
+    EnyoGridStatusEnum["OnGrid"] = "on-grid";
+    /**
+     * The public grid is not available (grid outage) — the site is
+     * disconnected from it and, where supported, running in backup / island
+     * operation
+     */
+    EnyoGridStatusEnum["OffGrid"] = "off-grid";
+})(EnyoGridStatusEnum || (exports.EnyoGridStatusEnum = EnyoGridStatusEnum = {}));
 /**
  * Operating state of a heating rod as reported on the data bus via
  * {@link EnyoDataBusHeatingRodValuesV1}.
@@ -823,6 +840,8 @@ var EnyoDataBusMessageEnum;
     EnyoDataBusMessageEnum["SetStorageChargeLimitV1"] = "SetStorageChargeLimitV1";
     EnyoDataBusMessageEnum["SetStorageScheduleV1"] = "SetStorageScheduleV1";
     EnyoDataBusMessageEnum["SetInverterFeedInLimitV1"] = "SetInverterFeedInLimitV1";
+    /** An appliance capable of grid outage detection reports whether the site is on grid or off grid (grid outage). */
+    EnyoDataBusMessageEnum["GridStatusUpdateV1"] = "GridStatusUpdateV1";
     EnyoDataBusMessageEnum["CommandAcknowledgeV1"] = "CommandAcknowledgeV1";
     EnyoDataBusMessageEnum["TemperatureSensorValuesUpdateV1"] = "TemperatureSensorValuesUpdateV1";
     EnyoDataBusMessageEnum["HeatpumpTemperaturesUpdateV1"] = "HeatpumpTemperaturesUpdateV1";
@@ -868,6 +887,12 @@ var EnyoDataBusMessageEnum;
     EnyoDataBusMessageEnum["SetHeatingRodAvailablePowerV2"] = "SetHeatingRodAvailablePowerV2";
     /** V2 control command: prescribe a single-setpoint control (mode + direction + power) to a battery/storage appliance. */
     EnyoDataBusMessageEnum["SetStorageControlV2"] = "SetStorageControlV2";
+    /** One-time user request: charge a battery appliance to full (or a target SoC) now. Handled by the energy manager. */
+    EnyoDataBusMessageEnum["RequestBatteryChargeNowV1"] = "RequestBatteryChargeNowV1";
+    /** Cancel a running {@link EnyoDataBusMessageEnum.RequestBatteryChargeNowV1} request on a battery appliance. */
+    EnyoDataBusMessageEnum["CancelBatteryChargeNowV1"] = "CancelBatteryChargeNowV1";
+    /** The energy manager reports how a {@link EnyoDataBusMessageEnum.RequestBatteryChargeNowV1} request progresses. */
+    EnyoDataBusMessageEnum["BatteryChargeNowStatusV1"] = "BatteryChargeNowStatusV1";
     /** Live values of a smart plug: relay state, power draw and energy meter reading. */
     EnyoDataBusMessageEnum["SmartPlugValuesUpdateV1"] = "SmartPlugValuesUpdateV1";
     /** Control command: switch a smart plug / relay channel on or off. */
@@ -993,6 +1018,69 @@ var EnyoStorageControlDirectionEnum;
      */
     EnyoStorageControlDirectionEnum["Hold"] = "hold";
 })(EnyoStorageControlDirectionEnum || (exports.EnyoStorageControlDirectionEnum = EnyoStorageControlDirectionEnum = {}));
+/**
+ * Where a {@link EnyoDataBusRequestBatteryChargeNowV1} request stands.
+ *
+ * `Accepted` and `Running` are intermediate; `Completed`, `Cancelled`,
+ * `Aborted` and `Rejected` are final — no further status follows for that
+ * request.
+ */
+var EnyoBatteryChargeNowStateEnum;
+(function (EnyoBatteryChargeNowStateEnum) {
+    /** The energy manager took the request on but is not charging yet. */
+    EnyoBatteryChargeNowStateEnum["Accepted"] = "accepted";
+    /**
+     * The battery is being charged for the request — or would be, but a grid
+     * operator limitation or device protection is capping it right now.
+     */
+    EnyoBatteryChargeNowStateEnum["Running"] = "running";
+    /** The battery reached the target SoC (or its `maxSoC`, or reported full). Final. */
+    EnyoBatteryChargeNowStateEnum["Completed"] = "completed";
+    /** The request was cancelled via {@link EnyoDataBusCancelBatteryChargeNowV1}. Final. */
+    EnyoBatteryChargeNowStateEnum["Cancelled"] = "cancelled";
+    /** The request started but ended before reaching the target. See the stop reason. Final. */
+    EnyoBatteryChargeNowStateEnum["Aborted"] = "aborted";
+    /** The request was refused and never started. See the stop reason. Final. */
+    EnyoBatteryChargeNowStateEnum["Rejected"] = "rejected";
+})(EnyoBatteryChargeNowStateEnum || (exports.EnyoBatteryChargeNowStateEnum = EnyoBatteryChargeNowStateEnum = {}));
+/**
+ * Why a {@link EnyoDataBusRequestBatteryChargeNowV1} request was
+ * {@link EnyoBatteryChargeNowStateEnum.Rejected} or
+ * {@link EnyoBatteryChargeNowStateEnum.Aborted}.
+ */
+var EnyoBatteryChargeNowStopReasonEnum;
+(function (EnyoBatteryChargeNowStopReasonEnum) {
+    /** The request itself is malformed — e.g. `targetSocPercent` outside 1–100 or a non-positive `maxDurationMinutes`. */
+    EnyoBatteryChargeNowStopReasonEnum["InvalidRequest"] = "invalid-request";
+    /** No battery appliance with the given `applianceId` exists. */
+    EnyoBatteryChargeNowStopReasonEnum["ApplianceNotFound"] = "appliance-not-found";
+    /** The battery is offline / unreachable. */
+    EnyoBatteryChargeNowStopReasonEnum["ApplianceOffline"] = "appliance-offline";
+    /**
+     * The battery integration does not permit control (`controlAllowed` is
+     * `false`) or does not declare {@link EnyoBatteryFeature.ManualCharge}.
+     */
+    EnyoBatteryChargeNowStopReasonEnum["ControlNotAllowed"] = "control-not-allowed";
+    /**
+     * The user switched battery control off in the energy manager settings
+     * (`BatteryControl`). Actionable: point the user at the setting.
+     */
+    EnyoBatteryChargeNowStopReasonEnum["ControlDisabledByUser"] = "control-disabled-by-user";
+    /**
+     * Grid charging was allowed for the request but the battery does not
+     * declare {@link EnyoBatteryFeature.GridCharging}, and there is no PV
+     * surplus to charge from.
+     */
+    EnyoBatteryChargeNowStopReasonEnum["GridChargingNotSupported"] = "grid-charging-not-supported";
+    /** The battery already is at or above the target SoC (or its `maxSoC`). */
+    EnyoBatteryChargeNowStopReasonEnum["AlreadyAtTarget"] = "already-at-target";
+    /** {@link EnyoDataBusRequestBatteryChargeNowV1.data.maxDurationMinutes} (or the energy manager's own limit) elapsed. */
+    EnyoBatteryChargeNowStopReasonEnum["MaxDurationReached"] = "max-duration-reached";
+    /** A newer request for the same battery replaced this one. */
+    EnyoBatteryChargeNowStopReasonEnum["Superseded"] = "superseded";
+    /** The battery stopped accepting charge below the target (e.g. a device-side limit or fault). */
+    EnyoBatteryChargeNowStopReasonEnum["BatteryStoppedCharging"] = "battery-stopped-charging";
+})(EnyoBatteryChargeNowStopReasonEnum || (exports.EnyoBatteryChargeNowStopReasonEnum = EnyoBatteryChargeNowStopReasonEnum = {}));
 /**
  * Possible answers an appliance can give when acknowledging a command.
  */