@enyo-energy/energy-app-sdk 0.0.114 → 0.0.116

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

@@ -137,6 +137,43 @@ export interface EnergyAppPackagePermission {
     /** Internal documentation describing what this permission is used for */
     internalComment: string;
 }
+/**
+ * A specific device model supported by an Energy App package.
+ * Used inside {@link EnergyAppPackageCompatibilityVendor.models} to enumerate
+ * the concrete models the package has been verified to work with.
+ */
+export interface EnergyAppPackageCompatibilityModel {
+    /** Human-readable model name as marketed by the vendor (e.g. "SE10K-RW0TEBNN4") */
+    modelName: string;
+    /**
+     * Optional internal display name shown in the enyo Store / Admin UI when
+     * different from the official `modelName` (e.g. a friendlier label).
+     */
+    displayName?: string;
+    /**
+     * Optional minimum firmware version the package supports for this model.
+     * Free-form string compared lexicographically by hosts that need it.
+     */
+    minimumFirmwareVersion?: string;
+    /** Optional internal note explaining model-specific caveats or limitations */
+    internalComment?: string;
+}
+/**
+ * A vendor and the list of its models supported by an Energy App package.
+ * Used inside {@link EnergyAppPackageDefinition.compatibility} to declare
+ * which manufacturers and product models the package targets.
+ */
+export interface EnergyAppPackageCompatibilityVendor {
+    /** Human-readable vendor name (e.g. "SolarEdge", "Fronius") */
+    vendorName: string;
+    /**
+     * Optional vendor logo path, mirroring the package-level `logo` field.
+     * Useful when the host wants to render a vendor list in the store.
+     */
+    logo?: string;
+    /** Models from this vendor that the package supports */
+    models: EnergyAppPackageCompatibilityModel[];
+}
 /**
  * Complete definition for a enyo Energy App package.
  * This interface defines all the metadata, permissions, and configuration
@@ -163,6 +200,14 @@ export interface EnergyAppPackageDefinition {
     sdkVersion: string;
     /** If the energy app should be visible in the enyo store. Default is true*/
     showInStore?: boolean;
+    /**
+     * Optional declaration of vendors and models this package is compatible with.
+     * Each entry pairs a vendor with the concrete models the package supports,
+     * allowing the enyo Store and onboarding flows to surface accurate
+     * compatibility information to users. Omit when the package targets a
+     * single vendor implicitly or has no fixed compatibility surface.
+     */
+    compatibility?: EnergyAppPackageCompatibilityVendor[];
 }
 /**
  * Defines an Energy App package with automatic SDK version injection.

package/dist/cjs/energy-app-permission.type.cjs

@@ -40,5 +40,6 @@ var EnergyAppPermissionTypeEnum;
     EnergyAppPermissionTypeEnum["EebusDataAccess"] = "EebusDataAccess";
     EnergyAppPermissionTypeEnum["EebusControl"] = "EebusControl";
     EnergyAppPermissionTypeEnum["Mqtt"] = "Mqtt";
+    EnergyAppPermissionTypeEnum["Bluetooth"] = "Bluetooth";
     EnergyAppPermissionTypeEnum["ChildProcess"] = "ChildProcess";
 })(EnergyAppPermissionTypeEnum || (exports.EnergyAppPermissionTypeEnum = EnergyAppPermissionTypeEnum = {}));

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

@@ -1,4 +1,4 @@
-export type EnergyAppPermissionType = 'RestrictedInternetAccess' | 'NetworkDeviceDiscovery' | 'NetworkDeviceSearch' | 'NetworkDeviceAccess' | 'Modbus' | 'Storage' | 'Appliance' | 'AllAppliances' | 'SendDataBusValues' | 'SubscribeDataBus' | 'SendDataBusCommands' | 'OcppServer' | 'ChargingCard' | 'Vehicle' | 'Charge' | 'SecretManager' | 'LocationZipCode' | 'LocationCoordinates' | 'Timeseries' | 'EnergyManagerInfo' | 'ElectricityTariff' | 'WeatherForecastRegister' | 'WeatherForecastUse' | 'PvForecastRegister' | 'PvForecastUse' | 'PvSystemRegister' | 'PvSystemUse' | 'InverterControlCommands' | 'BatteryControlCommands' | 'ChargerControlCommands' | 'ModbusRtu' | 'EnergyPrices' | 'EnergyManager' | 'EebusDeviceManagement' | 'EebusDataAccess' | 'EebusControl' | 'Mqtt' | 'ChildProcess';
+export type EnergyAppPermissionType = 'RestrictedInternetAccess' | 'NetworkDeviceDiscovery' | 'NetworkDeviceSearch' | 'NetworkDeviceAccess' | 'Modbus' | 'Storage' | 'Appliance' | 'AllAppliances' | 'SendDataBusValues' | 'SubscribeDataBus' | 'SendDataBusCommands' | 'OcppServer' | 'ChargingCard' | 'Vehicle' | 'Charge' | 'SecretManager' | 'LocationZipCode' | 'LocationCoordinates' | 'Timeseries' | 'EnergyManagerInfo' | 'ElectricityTariff' | 'WeatherForecastRegister' | 'WeatherForecastUse' | 'PvForecastRegister' | 'PvForecastUse' | 'PvSystemRegister' | 'PvSystemUse' | 'InverterControlCommands' | 'BatteryControlCommands' | 'ChargerControlCommands' | 'ModbusRtu' | 'EnergyPrices' | 'EnergyManager' | 'EebusDeviceManagement' | 'EebusDataAccess' | 'EebusControl' | 'Mqtt' | 'Bluetooth' | 'ChildProcess';
 export declare enum EnergyAppPermissionTypeEnum {
     RestrictedInternetAccess = "RestrictedInternetAccess",
     NetworkDeviceDiscovery = "NetworkDeviceDiscovery",
@@ -37,5 +37,6 @@ export declare enum EnergyAppPermissionTypeEnum {
     EebusDataAccess = "EebusDataAccess",
     EebusControl = "EebusControl",
     Mqtt = "Mqtt",
+    Bluetooth = "Bluetooth",
     ChildProcess = "ChildProcess"
 }

package/dist/cjs/energy-app.cjs

@@ -211,6 +211,14 @@ class EnergyApp {
     useMqtt() {
         return this.energyAppSdk.useMqtt();
     }
+    /**
+     * Gets the Bluetooth Low Energy API for scanning peripherals and
+     * performing GATT operations against them.
+     * @returns The Bluetooth API instance
+     */
+    useBluetooth() {
+        return this.energyAppSdk.useBluetooth();
+    }
     /**
      * Gets the Diagnostics API for submitting energy manager diagnostics data.
      * Allows energy managers to report current state, forecast, and control plan

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

@@ -27,6 +27,7 @@ import { EnergyAppSequenceGenerator } from "./packages/energy-app-sequence-gener
 import { EnergyAppModbusRtu } from "./packages/energy-app-modbus-rtu.cjs";
 import { EnergyAppEebus } from "./packages/energy-app-eebus.cjs";
 import { EnergyAppMqtt } from "./packages/energy-app-mqtt.cjs";
+import { EnergyAppBluetooth } from "./packages/energy-app-bluetooth.cjs";
 import { EnergyAppDiagnostics } from "./packages/energy-app-diagnostics.cjs";
 import { EnergyAppLearningPhase } from "./packages/energy-app-learning-phase.cjs";
 /**
@@ -155,6 +156,12 @@ export declare class EnergyApp implements EnyoEnergyAppSdk {
      * @returns The MQTT API instance
      */
     useMqtt(): EnergyAppMqtt;
+    /**
+     * Gets the Bluetooth Low Energy API for scanning peripherals and
+     * performing GATT operations against them.
+     * @returns The Bluetooth API instance
+     */
+    useBluetooth(): EnergyAppBluetooth;
     /**
      * Gets the Diagnostics API for submitting energy manager diagnostics data.
      * Allows energy managers to report current state, forecast, and control plan

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

@@ -26,6 +26,7 @@ import { EnergyAppSequenceGenerator } from "./packages/energy-app-sequence-gener
 import { EnergyAppModbusRtu } from "./packages/energy-app-modbus-rtu.cjs";
 import { EnergyAppEebus } from "./packages/energy-app-eebus.cjs";
 import { EnergyAppMqtt } from "./packages/energy-app-mqtt.cjs";
+import { EnergyAppBluetooth } from "./packages/energy-app-bluetooth.cjs";
 import { EnergyAppDiagnostics } from "./packages/energy-app-diagnostics.cjs";
 import { EnergyAppLearningPhase } from "./packages/energy-app-learning-phase.cjs";
 export declare enum EnergyAppStateEnum {
@@ -108,6 +109,8 @@ export interface EnyoEnergyAppSdk {
     useEebus: () => EnergyAppEebus;
     /** Get the MQTT communication API for connecting to internal or external MQTT brokers */
     useMqtt: () => EnergyAppMqtt;
+    /** Get the Bluetooth Low Energy API for scanning and GATT communication with peripherals */
+    useBluetooth: () => EnergyAppBluetooth;
     /** Get the Diagnostics API for submitting energy manager diagnostics data */
     useDiagnostics: () => EnergyAppDiagnostics;
     /** Get the Learning Phase API for registering and tracking learning phases */

package/dist/cjs/index.cjs

@@ -51,6 +51,8 @@ __exportStar(require("./types/enyo-eebus.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);
+__exportStar(require("./types/enyo-bluetooth.cjs"), exports);
+__exportStar(require("./packages/energy-app-bluetooth.cjs"), exports);
 __exportStar(require("./types/enyo-diagnostics.cjs"), exports);
 __exportStar(require("./packages/energy-app-diagnostics.cjs"), exports);
 __exportStar(require("./types/enyo-learning-phase.cjs"), exports);

package/dist/cjs/index.d.cts

@@ -35,6 +35,8 @@ export * from './types/enyo-eebus.cjs';
 export * from './packages/energy-app-eebus.cjs';
 export * from './types/enyo-mqtt.cjs';
 export * from './packages/energy-app-mqtt.cjs';
+export * from './types/enyo-bluetooth.cjs';
+export * from './packages/energy-app-bluetooth.cjs';
 export * from './types/enyo-diagnostics.cjs';
 export * from './packages/energy-app-diagnostics.cjs';
 export * from './types/enyo-learning-phase.cjs';

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

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

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

@@ -0,0 +1,155 @@
+import { EnergyAppBluetoothConnectOptions, EnergyAppBluetoothDevice, EnergyAppBluetoothScanOptions } from "../types/enyo-bluetooth.cjs";
+/**
+ * Three consumption styles for the same notify channel — pick whichever fits
+ * the protocol you are implementing.
+ *
+ * - `onValue` is push-based and ideal for fire-and-forget event handling.
+ * - `next` is pull-based and convenient for request/response style protocols.
+ * - `values` exposes the same stream as an async iterator usable in
+ *   `for await` loops; the iterator ends automatically when the underlying
+ *   session disconnects.
+ *
+ * The three styles share the same underlying subscription, so calling
+ * {@link stop} cancels the notification subscription regardless of which
+ * style was used to consume values.
+ */
+export interface EnergyAppBluetoothNotifications {
+    /**
+     * Push-style consumption: the listener is invoked for every notification.
+     *
+     * @param listener - Callback invoked with each notification payload.
+     * @returns Promise resolving to an unsubscribe function. Calling it stops
+     *          delivering notifications to this listener but does not
+     *          terminate the underlying subscription — use {@link stop} for
+     *          that.
+     */
+    onValue(listener: (value: Uint8Array) => void): Promise<() => Promise<void>>;
+    /**
+     * Pull-style consumption: resolves with the next single notification.
+     *
+     * @param timeoutMs - Optional timeout. When provided and no notification
+     *                    arrives in time, the promise rejects with an
+     *                    `EnergyAppBluetoothError` of code `timeout`.
+     * @returns Promise resolving with the next received notification payload.
+     */
+    next(timeoutMs?: number): Promise<Uint8Array>;
+    /**
+     * Stream-style consumption usable with `for await` loops.
+     * The iterator ends automatically when the session disconnects.
+     */
+    values(): AsyncIterableIterator<Uint8Array>;
+    /**
+     * Stop notifications regardless of consumption style.
+     * Subsequent calls to {@link next} will reject and {@link values} will
+     * complete. Idempotent.
+     */
+    stop(): Promise<void>;
+}
+/**
+ * One open connection to a Bluetooth peripheral.
+ *
+ * All GATT operations are scoped to this object — there is no need to repeat
+ * the device address on every call. A session must NOT be reused after
+ * {@link disconnect} has been awaited or after the callback passed to
+ * {@link EnergyAppBluetooth.withDevice} has returned.
+ */
+export interface EnergyAppBluetoothSession {
+    /** MAC address of the peripheral this session is connected to. */
+    readonly address: string;
+    /**
+     * `true` until the connection is closed, either locally via
+     * {@link disconnect} or because the peripheral disconnected.
+     */
+    readonly connected: boolean;
+    /**
+     * Read the current value of a GATT characteristic.
+     *
+     * @param serviceUuid - UUID of the GATT service that owns the characteristic.
+     * @param charUuid - UUID of the characteristic to read.
+     * @returns Promise resolving with the raw characteristic bytes.
+     */
+    read(serviceUuid: string, charUuid: string): Promise<Uint8Array>;
+    /**
+     * Write a value to a GATT characteristic. Defaults to write-with-response.
+     *
+     * @param serviceUuid - UUID of the GATT service that owns the characteristic.
+     * @param charUuid - UUID of the characteristic to write.
+     * @param value - Bytes to write.
+     * @param options - Pass `withoutResponse: true` to use write-without-response.
+     */
+    write(serviceUuid: string, charUuid: string, value: Uint8Array, options?: {
+        withoutResponse?: boolean;
+    }): Promise<void>;
+    /**
+     * Subscribe to notifications/indications on a characteristic.
+     * The returned object exposes three interchangeable consumption styles
+     * — see {@link EnergyAppBluetoothNotifications}.
+     *
+     * @param serviceUuid - UUID of the GATT service that owns the characteristic.
+     * @param charUuid - UUID of the characteristic to subscribe to.
+     */
+    notifications(serviceUuid: string, charUuid: string): EnergyAppBluetoothNotifications;
+    /**
+     * Close the connection. Idempotent — calling it more than once is safe
+     * and resolves immediately on subsequent calls.
+     */
+    disconnect(): Promise<void>;
+}
+/**
+ * Bluetooth Low Energy API for enyo packages.
+ *
+ * Provides device discovery (scan) and GATT connection management. All
+ * operations require the package to declare the `Bluetooth` permission.
+ *
+ * @example
+ * ```ts
+ * const bluetooth = energyApp.useBluetooth();
+ *
+ * // Discover nearby Shelly devices
+ * const devices = await bluetooth.scan({
+ *     durationMs: 5000,
+ *     filter: { manufacturerIds: [0x0BA9] },
+ * });
+ *
+ * // Talk to one of them, with guaranteed cleanup
+ * await bluetooth.withDevice(devices[0].address, async (session) => {
+ *     const value = await session.read('1800', '2a00');
+ *     console.log(new TextDecoder().decode(value));
+ * });
+ * ```
+ */
+export interface EnergyAppBluetooth {
+    /**
+     * Run a discovery on the device's HCI controller.
+     *
+     * @param options - Optional filter and duration. Without options the host
+     *                  uses default duration and returns every advertisement.
+     * @returns Promise resolving with the discovered devices.
+     */
+    scan(options?: EnergyAppBluetoothScanOptions): Promise<EnergyAppBluetoothDevice[]>;
+    /**
+     * Open a connection to a peripheral.
+     *
+     * The caller is responsible for invoking {@link EnergyAppBluetoothSession.disconnect}.
+     * Prefer {@link withDevice} for typical use cases — it guarantees cleanup
+     * even when the callback throws.
+     *
+     * @param address - MAC address as returned by {@link scan}.
+     * @param options - Optional connection timeout configuration.
+     * @returns Promise resolving with an active {@link EnergyAppBluetoothSession}.
+     */
+    connect(address: string, options?: EnergyAppBluetoothConnectOptions): Promise<EnergyAppBluetoothSession>;
+    /**
+     * Convenience scope: connects to the peripheral, runs `fn`, and always
+     * disconnects (even if `fn` throws). Strongly preferred over manual
+     * connect/disconnect because it eliminates the risk of leaking sessions
+     * when error paths short-circuit cleanup.
+     *
+     * @param address - MAC address as returned by {@link scan}.
+     * @param fn - Callback invoked with the live session. Its return value is
+     *             forwarded as the result of `withDevice`.
+     * @param options - Optional connection timeout configuration.
+     * @returns Promise resolving with the value returned by `fn`.
+     */
+    withDevice<T>(address: string, fn: (session: EnergyAppBluetoothSession) => Promise<T>, options?: EnergyAppBluetoothConnectOptions): Promise<T>;
+}

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

@@ -2,7 +2,7 @@
  * Supported interval durations for scheduled tasks.
  * Provides predefined time intervals from 1 second to 1 hour.
  */
-export type IntervalDuration = '10s' | '30s' | '1m' | '5m' | '1hr';
+export type IntervalDuration = '1s' | '5s' | '10s' | '30s' | '1m' | '5m' | '1hr';
 /**
  * Interface for managing scheduled intervals in enyo packages.
  * Provides functionality to create and manage recurring tasks.

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

@@ -119,6 +119,34 @@ export interface EnergyAppOnboarding {
      * @returns Promise that resolves when navigation is complete
      */
     moveToPreviousStep(guideName: string): Promise<void>;
+    /**
+     * Jumps to a specific step within the onboarding guide by its `name`.
+     *
+     * Useful when implementing dynamic onboarding routes — for example, after
+     * receiving a step submission the package can decide programmatically
+     * which step to show next based on the submitted data, rather than
+     * relying on the declarative `branches` configuration on the step.
+     *
+     * If the target step does not exist within the guide the call is a no-op.
+     *
+     * @param guideName - The unique name of the guide to navigate
+     * @param stepName - The `name` of the target step to display
+     * @returns Promise that resolves when navigation is complete
+     *
+     * @example
+     * ```typescript
+     * onboarding.listenForStepSubmission(async (submission) => {
+     *   if (submission.stepName === 'choose-route') {
+     *     const route = submission.data?.route;
+     *     await onboarding.moveToStep(submission.guideName,
+     *       route === 'cloud' ? 'cloud-credentials' : 'local-network');
+     *     return { state: 'success' };
+     *   }
+     *   return { state: 'success' };
+     * });
+     * ```
+     */
+    moveToStep(guideName: string, stepName: string): Promise<void>;
     /**
      * Marks the onboarding as complete and clears the ConfigurationRequired state.
      * This updates the state for the specified guide.

package/dist/cjs/types/enyo-bluetooth.cjs

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

package/dist/cjs/types/enyo-bluetooth.d.cts

@@ -0,0 +1,96 @@
+/**
+ * Filter clause applied during a Bluetooth scan.
+ * The clauses inside this object are OR-combined: a device matches when at
+ * least one populated clause matches its advertisement. An empty filter
+ * (no populated clauses) returns every advertised device.
+ */
+export interface EnergyAppBluetoothScanFilter {
+    /**
+     * Match if any advertised GATT service UUID is in this list.
+     * Comparison is case-insensitive.
+     */
+    serviceUuids?: string[];
+    /** Match if any of the advertised manufacturer IDs is in this list. */
+    manufacturerIds?: number[];
+    /** Match if the BLE local name starts with this prefix (case-sensitive). */
+    namePrefix?: string;
+}
+/**
+ * Options controlling a single Bluetooth discovery run.
+ */
+export interface EnergyAppBluetoothScanOptions {
+    /**
+     * Wall-clock duration of the scan in milliseconds. Defaults to 5000;
+     * the host caps this value at 15000 to protect the HCI controller.
+     */
+    durationMs?: number;
+    /**
+     * Optional filter narrowing which advertisements are returned. When
+     * omitted or empty, every advertised device is returned.
+     */
+    filter?: EnergyAppBluetoothScanFilter;
+}
+/**
+ * A device discovered during a Bluetooth scan.
+ *
+ * The shape mirrors what is available in the BLE advertisement; values that
+ * are not present in the advertisement are omitted rather than zeroed.
+ */
+export interface EnergyAppBluetoothDevice {
+    /**
+     * Uppercase, colon-separated MAC address (e.g. "AA:BB:CC:DD:EE:FF").
+     * Use this value as the `address` argument to {@link EnergyAppBluetooth.connect}
+     * or {@link EnergyAppBluetooth.withDevice}.
+     */
+    address: string;
+    /** BLE local name (advertised). May be undefined for nameless beacons. */
+    name?: string;
+    /** Last received signal strength indicator in dBm. */
+    rssi?: number;
+    /**
+     * Manufacturer-specific advertisement data, keyed by manufacturer ID.
+     * Values are the raw bytes as advertised.
+     */
+    manufacturerData?: Record<number, Uint8Array>;
+    /** Advertised service UUIDs in lowercase. */
+    serviceUuids?: string[];
+}
+/**
+ * Options applied when opening a GATT connection to a peripheral.
+ */
+export interface EnergyAppBluetoothConnectOptions {
+    /**
+     * Maximum total time (milliseconds) to spend on the BlueZ `Connect` call
+     * plus `ServicesResolved`. Defaults to 15000.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Closed set of error codes raised by the Bluetooth API.
+ *
+ * - `permission_denied`: package is missing the `Bluetooth` permission.
+ * - `controller_unavailable`: BlueZ is down or the HCI device is not up.
+ * - `scan_in_progress`: a concurrent scan request was rejected.
+ * - `not_connected`: a GATT operation was issued on a stale session.
+ * - `service_not_found`: the requested service UUID could not be resolved.
+ * - `characteristic_not_found`: the characteristic UUID could not be resolved.
+ * - `authentication_required`: the characteristic requires pairing/encryption.
+ * - `timeout`: an operation exceeded its allotted time.
+ * - `invalid_address`: the MAC address argument is malformed.
+ */
+export type EnergyAppBluetoothErrorCode = 'permission_denied' | 'controller_unavailable' | 'scan_in_progress' | 'not_connected' | 'service_not_found' | 'characteristic_not_found' | 'authentication_required' | 'timeout' | 'invalid_address';
+/**
+ * Error subtype thrown by the Bluetooth API.
+ * Always carries a structured {@link EnergyAppBluetoothErrorCode}; callers
+ * should branch on `code` rather than parsing the human-readable message.
+ */
+export interface EnergyAppBluetoothError extends Error {
+    /** Machine-readable error code. */
+    readonly code: EnergyAppBluetoothErrorCode;
+    /**
+     * MAC address of the device the failed operation targeted, when relevant.
+     * Omitted for errors that are not tied to a specific device (e.g.
+     * `controller_unavailable`).
+     */
+    readonly address?: string;
+}

package/dist/cjs/types/enyo-charge.d.cts

@@ -1,3 +1,4 @@
+import { EnyoChargeModeEnum } from "./enyo-data-bus-value.cjs";
 /**
  * Status of a charging session
  */
@@ -65,6 +66,10 @@ export interface EnyoCharge {
     numberOfPhases: number;
     /** Active charging schedule entries, if smart charging is in use */
     schedule?: EnyoChargeScheduleEntry[];
+    /** Charging mode applied to this session (e.g. immediate, cost-optimized, price-limit) */
+    chargeMode?: EnyoChargeModeEnum;
+    /** Target completion time for the charging session as an ISO 8601 timestamp */
+    completeAtIsoTimestamp?: string;
 }
 /**
  * Represents a single entry in a charging schedule.

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnyoHeatpumpApplianceModeEnum = exports.EnyoHeatpumpApplianceAvailableFeaturesEnum = void 0;
+exports.EnyoHeatpumpApplianceConnectionTypeEnum = exports.EnyoHeatpumpApplianceModeEnum = exports.EnyoHeatpumpApplianceAvailableFeaturesEnum = void 0;
 var EnyoHeatpumpApplianceAvailableFeaturesEnum;
 (function (EnyoHeatpumpApplianceAvailableFeaturesEnum) {
     /** If the heatpump is capable of domestic hot water*/
@@ -15,6 +15,8 @@ var EnyoHeatpumpApplianceAvailableFeaturesEnum;
     EnyoHeatpumpApplianceAvailableFeaturesEnum["DomesticHotWaterOverheating"] = "DomesticHotWaterOverheating";
     /** If the heatpump supports available power announcements */
     EnyoHeatpumpApplianceAvailableFeaturesEnum["AvailablePowerAnnouncement"] = "AvailablePowerAnnouncement";
+    /** If the heatpump reports power values (e.g. electrical power consumption in watts) */
+    EnyoHeatpumpApplianceAvailableFeaturesEnum["Power"] = "Power";
 })(EnyoHeatpumpApplianceAvailableFeaturesEnum || (exports.EnyoHeatpumpApplianceAvailableFeaturesEnum = EnyoHeatpumpApplianceAvailableFeaturesEnum = {}));
 var EnyoHeatpumpApplianceModeEnum;
 (function (EnyoHeatpumpApplianceModeEnum) {
@@ -23,3 +25,16 @@ var EnyoHeatpumpApplianceModeEnum;
     EnyoHeatpumpApplianceModeEnum["DomesticHotWater"] = "DomesticHotWater";
     EnyoHeatpumpApplianceModeEnum["EmergencyOperation"] = "EmergencyOperation";
 })(EnyoHeatpumpApplianceModeEnum || (exports.EnyoHeatpumpApplianceModeEnum = EnyoHeatpumpApplianceModeEnum = {}));
+/**
+ * Describes how an enyo Hub physically/logically connects to the heatpump.
+ * Used by hosts and energy managers to reason about the integration's
+ * capabilities (e.g. SG-Ready offers only coarse 4-state control while an API
+ * connection typically exposes fine-grained read/write access).
+ */
+var EnyoHeatpumpApplianceConnectionTypeEnum;
+(function (EnyoHeatpumpApplianceConnectionTypeEnum) {
+    /** Connected via the SG-Ready interface (two relay inputs, four states) */
+    EnyoHeatpumpApplianceConnectionTypeEnum["SgReady"] = "sg-ready";
+    /** Connected via a vendor or local API (e.g. REST, Modbus, EEBus) */
+    EnyoHeatpumpApplianceConnectionTypeEnum["Api"] = "api";
+})(EnyoHeatpumpApplianceConnectionTypeEnum || (exports.EnyoHeatpumpApplianceConnectionTypeEnum = EnyoHeatpumpApplianceConnectionTypeEnum = {}));

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

@@ -10,7 +10,9 @@ export declare enum EnyoHeatpumpApplianceAvailableFeaturesEnum {
     /** If the heatpump supports domestic hot water overheating */
     DomesticHotWaterOverheating = "DomesticHotWaterOverheating",
     /** If the heatpump supports available power announcements */
-    AvailablePowerAnnouncement = "AvailablePowerAnnouncement"
+    AvailablePowerAnnouncement = "AvailablePowerAnnouncement",
+    /** If the heatpump reports power values (e.g. electrical power consumption in watts) */
+    Power = "Power"
 }
 export declare enum EnyoHeatpumpApplianceModeEnum {
     Idle = "Idle",
@@ -18,6 +20,18 @@ export declare enum EnyoHeatpumpApplianceModeEnum {
     DomesticHotWater = "DomesticHotWater",
     EmergencyOperation = "EmergencyOperation"
 }
+/**
+ * Describes how an enyo Hub physically/logically connects to the heatpump.
+ * Used by hosts and energy managers to reason about the integration's
+ * capabilities (e.g. SG-Ready offers only coarse 4-state control while an API
+ * connection typically exposes fine-grained read/write access).
+ */
+export declare enum EnyoHeatpumpApplianceConnectionTypeEnum {
+    /** Connected via the SG-Ready interface (two relay inputs, four states) */
+    SgReady = "sg-ready",
+    /** Connected via a vendor or local API (e.g. REST, Modbus, EEBus) */
+    Api = "api"
+}
 export interface EnyoHeatpumpApplianceDomesticHotWater {
     index: number;
     tankSizeLiter?: number;
@@ -44,4 +58,11 @@ export interface EnyoHeatpumpApplianceMetadata {
     bufferTanks?: EnyoHeatpumpApplianceBufferTank[];
     compressors?: EnyoHeatpumpApplianceCompressor[];
     heatingCircuits?: EnyoHeatpumpApplianceHeatingCircuit[];
+    /**
+     * Optional indicator of how the package connects to the heatpump.
+     * Helps consumers (UI, energy manager) understand the control surface
+     * available — e.g. an SG-Ready connection is limited to four discrete
+     * states, while an API connection typically allows direct read/write.
+     */
+    connectionType?: EnyoHeatpumpApplianceConnectionTypeEnum;
 }

package/dist/cjs/types/enyo-onboarding.cjs

@@ -32,4 +32,11 @@ var EnyoOnboardingSectionType;
     EnyoOnboardingSectionType["Url"] = "url";
     /** A dropdown/select section */
     EnyoOnboardingSectionType["Select"] = "select";
+    /**
+     * A branching decision section.
+     * Renders as a switch/segmented control or radio group; the user's
+     * selection determines which step is shown next, enabling dynamic routes
+     * within a single onboarding guide.
+     */
+    EnyoOnboardingSectionType["Branch"] = "branch";
 })(EnyoOnboardingSectionType || (exports.EnyoOnboardingSectionType = EnyoOnboardingSectionType = {}));