@enyo-energy/energy-app-sdk 0.0.113 → 0.0.115

package/dist/cjs/implementations/retry/backoff.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBackoffDelay = computeBackoffDelay;
+/**
+ * Computes the delay (ms) the {@link RetryManager} should wait before retry attempt `attempt`.
+ *
+ * Pure function — no timers, no global state — so it can be called directly by
+ * callers that drive their own retry loops.
+ *
+ * @param config Backoff curve and bounds.
+ * @param attempt 1-based attempt number; `1` is the first retry (the call right after the first failure).
+ * @param rng Source of randomness for jitter, in `[0, 1)`. Injectable for deterministic tests.
+ * @returns Non-negative delay in milliseconds.
+ * @throws RangeError on invalid configuration or non-positive `attempt`.
+ *
+ * @example
+ * ```ts
+ * computeBackoffDelay({ type: 'exponential', initialMs: 100, maxMs: 5000 }, 4); // 800
+ * ```
+ */
+function computeBackoffDelay(config, attempt, rng = Math.random) {
+    if (!Number.isFinite(attempt) || attempt < 1) {
+        throw new RangeError(`attempt must be a positive integer, got ${attempt}`);
+    }
+    if (config.initialMs < 0) {
+        throw new RangeError(`initialMs must be >= 0, got ${config.initialMs}`);
+    }
+    if (config.maxMs !== undefined && config.maxMs < 0) {
+        throw new RangeError(`maxMs must be >= 0, got ${config.maxMs}`);
+    }
+    const factor = config.factor ?? 2;
+    if (config.type === 'exponential' && factor < 1) {
+        throw new RangeError(`factor must be >= 1, got ${factor}`);
+    }
+    const jitter = config.jitter ?? 0;
+    if (jitter < 0 || jitter > 1) {
+        throw new RangeError(`jitter must be in [0, 1], got ${jitter}`);
+    }
+    let delay;
+    switch (config.type) {
+        case 'fixed':
+            delay = config.initialMs;
+            break;
+        case 'linear':
+            delay = config.initialMs * attempt;
+            break;
+        case 'exponential':
+            delay = config.initialMs * factor ** (attempt - 1);
+            break;
+    }
+    if (config.maxMs !== undefined && delay > config.maxMs) {
+        delay = config.maxMs;
+    }
+    if (jitter > 0) {
+        delay = delay * (1 + (rng() * 2 - 1) * jitter);
+    }
+    return delay < 0 ? 0 : delay;
+}

package/dist/cjs/implementations/retry/backoff.d.cts

@@ -0,0 +1,19 @@
+import type { BackoffConfig } from '../../types/enyo-retry-manager.cjs';
+/**
+ * Computes the delay (ms) the {@link RetryManager} should wait before retry attempt `attempt`.
+ *
+ * Pure function — no timers, no global state — so it can be called directly by
+ * callers that drive their own retry loops.
+ *
+ * @param config Backoff curve and bounds.
+ * @param attempt 1-based attempt number; `1` is the first retry (the call right after the first failure).
+ * @param rng Source of randomness for jitter, in `[0, 1)`. Injectable for deterministic tests.
+ * @returns Non-negative delay in milliseconds.
+ * @throws RangeError on invalid configuration or non-positive `attempt`.
+ *
+ * @example
+ * ```ts
+ * computeBackoffDelay({ type: 'exponential', initialMs: 100, maxMs: 5000 }, 4); // 800
+ * ```
+ */
+export declare function computeBackoffDelay(config: BackoffConfig, attempt: number, rng?: () => number): number;

package/dist/cjs/implementations/retry/retry-errors.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryExhaustedError = void 0;
+/**
+ * Thrown by {@link RetryManager.execute} when all attempts have been used or
+ * the policy's `isRetryable` predicate rejected the last error.
+ *
+ * The original failure is preserved on {@link RetryExhaustedError.cause} so
+ * callers can inspect or rethrow it.
+ */
+class RetryExhaustedError extends Error {
+    id;
+    attempts;
+    cause;
+    /**
+     * @param id Identifier of the retry instance that gave up.
+     * @param attempts Number of attempts that ran before giving up.
+     * @param cause The error from the final failing attempt.
+     */
+    constructor(id, attempts, cause) {
+        super(`Retry exhausted for "${id}" after ${attempts} attempt(s)`);
+        this.id = id;
+        this.attempts = attempts;
+        this.cause = cause;
+        this.name = 'RetryExhaustedError';
+    }
+}
+exports.RetryExhaustedError = RetryExhaustedError;

package/dist/cjs/implementations/retry/retry-errors.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Thrown by {@link RetryManager.execute} when all attempts have been used or
+ * the policy's `isRetryable` predicate rejected the last error.
+ *
+ * The original failure is preserved on {@link RetryExhaustedError.cause} so
+ * callers can inspect or rethrow it.
+ */
+export declare class RetryExhaustedError extends Error {
+    readonly id: string;
+    readonly attempts: number;
+    readonly cause: unknown;
+    /**
+     * @param id Identifier of the retry instance that gave up.
+     * @param attempts Number of attempts that ran before giving up.
+     * @param cause The error from the final failing attempt.
+     */
+    constructor(id: string, attempts: number, cause: unknown);
+}

package/dist/cjs/implementations/retry/retry-manager.cjs

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryManager = void 0;
+const enyo_retry_manager_js_1 = require("../../types/enyo-retry-manager.cjs");
+const backoff_js_1 = require("./backoff.cjs");
+const retry_errors_js_1 = require("./retry-errors.cjs");
+const defaultSleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Protocol-agnostic retry coordinator.
+ *
+ * Each *instance* (a Modbus connection, an MQTT client, a REST endpoint, …) is
+ * registered under a string `id` together with its own {@link RetryPolicy}.
+ * Callers then run an operation through {@link RetryManager.execute}; the
+ * manager handles attempt counting, backoff, and state transitions and reports
+ * progress through {@link RetryManager.onStateChange}.
+ *
+ * @example
+ * ```ts
+ * const retries = new RetryManager();
+ * retries.register('modbus-inverter-1', {
+ *     maxAttempts: 5,
+ *     backoff: { type: 'exponential', initialMs: 200, maxMs: 5000, jitter: 0.2 },
+ * });
+ *
+ * await retries.execute('modbus-inverter-1', () => client.connect());
+ * ```
+ */
+class RetryManager {
+    instances = new Map();
+    listeners = new Set();
+    sleep;
+    rng;
+    /**
+     * @param options Test hooks for sleep and randomness. Production callers can omit this argument.
+     */
+    constructor(options = {}) {
+        this.sleep = options.sleep ?? defaultSleep;
+        this.rng = options.rng ?? Math.random;
+    }
+    /**
+     * Registers a new retry instance.
+     *
+     * @param id Identifier used for all subsequent operations and reported in {@link RetryStatus}.
+     * @param policy Retry policy applied to this instance.
+     * @throws Error if `id` is already registered.
+     */
+    register(id, policy) {
+        if (this.instances.has(id)) {
+            throw new Error(`Retry instance "${id}" is already registered`);
+        }
+        if (policy.maxAttempts < 1) {
+            throw new RangeError(`maxAttempts must be >= 1, got ${policy.maxAttempts}`);
+        }
+        this.instances.set(id, { id, policy, state: enyo_retry_manager_js_1.RetryState.Idle, attempts: 0 });
+    }
+    /**
+     * Removes the instance from the manager. No-op if `id` is not registered.
+     */
+    unregister(id) {
+        this.instances.delete(id);
+    }
+    /**
+     * Returns whether `id` is registered.
+     */
+    has(id) {
+        return this.instances.has(id);
+    }
+    /**
+     * Returns a snapshot of `id`'s current state, or `undefined` if not registered.
+     */
+    status(id) {
+        const instance = this.instances.get(id);
+        return instance ? toStatus(instance) : undefined;
+    }
+    /**
+     * Returns snapshots for every registered instance.
+     */
+    statuses() {
+        return Array.from(this.instances.values(), toStatus);
+    }
+    /**
+     * Resets `id` to {@link RetryState.Idle} with zero attempts. The policy is preserved.
+     *
+     * @throws Error if `id` is not registered.
+     */
+    reset(id) {
+        const instance = this.requireInstance(id);
+        instance.state = enyo_retry_manager_js_1.RetryState.Idle;
+        instance.attempts = 0;
+        instance.lastError = undefined;
+        instance.nextDelayMs = undefined;
+        this.emit(instance);
+    }
+    /**
+     * Subscribes to state-change events for every registered instance.
+     *
+     * @param listener Called once per transition with the post-transition snapshot.
+     * @returns Unsubscribe function.
+     */
+    onStateChange(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Runs `fn` under the policy registered for `id`.
+     *
+     * Each invocation starts a fresh attempt cycle: counters and `lastError` are
+     * cleared before the first attempt so the same instance can be re-used after
+     * a previous success or exhaustion.
+     *
+     * @param id Identifier registered via {@link RetryManager.register}.
+     * @param fn Operation to execute. Rejecting causes a retry (subject to the policy).
+     * @returns Whatever `fn` resolves to.
+     * @throws RetryExhaustedError when all attempts have been used or `isRetryable` returns `false`.
+     * @throws Error when `id` is not registered.
+     */
+    async execute(id, fn) {
+        const instance = this.requireInstance(id);
+        instance.attempts = 0;
+        instance.lastError = undefined;
+        instance.nextDelayMs = undefined;
+        const { maxAttempts, backoff, isRetryable } = instance.policy;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            instance.attempts = attempt;
+            instance.nextDelayMs = undefined;
+            this.transition(instance, enyo_retry_manager_js_1.RetryState.Running);
+            try {
+                const result = await fn();
+                instance.lastError = undefined;
+                this.transition(instance, enyo_retry_manager_js_1.RetryState.Succeeded);
+                return result;
+            }
+            catch (error) {
+                instance.lastError = error;
+                const retryable = isRetryable ? isRetryable(error) : true;
+                const hasMore = attempt < maxAttempts;
+                if (!retryable || !hasMore) {
+                    this.transition(instance, enyo_retry_manager_js_1.RetryState.Exhausted);
+                    throw new retry_errors_js_1.RetryExhaustedError(id, attempt, error);
+                }
+                const delay = (0, backoff_js_1.computeBackoffDelay)(backoff, attempt, this.rng);
+                instance.nextDelayMs = delay;
+                this.transition(instance, enyo_retry_manager_js_1.RetryState.Waiting);
+                await this.sleep(delay);
+            }
+        }
+        // Unreachable: the loop either returns, throws, or completes by entering
+        // the catch branch on the final attempt (which throws Exhausted above).
+        throw new retry_errors_js_1.RetryExhaustedError(id, instance.attempts, instance.lastError);
+    }
+    requireInstance(id) {
+        const instance = this.instances.get(id);
+        if (!instance) {
+            throw new Error(`Retry instance "${id}" is not registered`);
+        }
+        return instance;
+    }
+    transition(instance, state) {
+        instance.state = state;
+        this.emit(instance);
+    }
+    emit(instance) {
+        if (this.listeners.size === 0)
+            return;
+        const snapshot = toStatus(instance);
+        for (const listener of this.listeners) {
+            listener(snapshot);
+        }
+    }
+}
+exports.RetryManager = RetryManager;
+function toStatus(instance) {
+    return {
+        id: instance.id,
+        state: instance.state,
+        attempts: instance.attempts,
+        lastError: instance.lastError,
+        nextDelayMs: instance.nextDelayMs,
+    };
+}

package/dist/cjs/implementations/retry/retry-manager.d.cts

@@ -0,0 +1,97 @@
+import { type RetryPolicy, type RetryStateListener, type RetryStatus } from '../../types/enyo-retry-manager.cjs';
+/**
+ * Options controlling how a {@link RetryManager} interacts with the outside world.
+ *
+ * Both fields exist purely so unit tests can inject deterministic substitutes;
+ * production code should use the defaults.
+ */
+export interface RetryManagerOptions {
+    /** Replacement for `setTimeout`-based sleeping. Defaults to a `setTimeout` wrapper. */
+    sleep?: (ms: number) => Promise<void>;
+    /** Source of randomness for backoff jitter. Defaults to `Math.random`. */
+    rng?: () => number;
+}
+/**
+ * Protocol-agnostic retry coordinator.
+ *
+ * Each *instance* (a Modbus connection, an MQTT client, a REST endpoint, …) is
+ * registered under a string `id` together with its own {@link RetryPolicy}.
+ * Callers then run an operation through {@link RetryManager.execute}; the
+ * manager handles attempt counting, backoff, and state transitions and reports
+ * progress through {@link RetryManager.onStateChange}.
+ *
+ * @example
+ * ```ts
+ * const retries = new RetryManager();
+ * retries.register('modbus-inverter-1', {
+ *     maxAttempts: 5,
+ *     backoff: { type: 'exponential', initialMs: 200, maxMs: 5000, jitter: 0.2 },
+ * });
+ *
+ * await retries.execute('modbus-inverter-1', () => client.connect());
+ * ```
+ */
+export declare class RetryManager {
+    private readonly instances;
+    private readonly listeners;
+    private readonly sleep;
+    private readonly rng;
+    /**
+     * @param options Test hooks for sleep and randomness. Production callers can omit this argument.
+     */
+    constructor(options?: RetryManagerOptions);
+    /**
+     * Registers a new retry instance.
+     *
+     * @param id Identifier used for all subsequent operations and reported in {@link RetryStatus}.
+     * @param policy Retry policy applied to this instance.
+     * @throws Error if `id` is already registered.
+     */
+    register(id: string, policy: RetryPolicy): void;
+    /**
+     * Removes the instance from the manager. No-op if `id` is not registered.
+     */
+    unregister(id: string): void;
+    /**
+     * Returns whether `id` is registered.
+     */
+    has(id: string): boolean;
+    /**
+     * Returns a snapshot of `id`'s current state, or `undefined` if not registered.
+     */
+    status(id: string): RetryStatus | undefined;
+    /**
+     * Returns snapshots for every registered instance.
+     */
+    statuses(): RetryStatus[];
+    /**
+     * Resets `id` to {@link RetryState.Idle} with zero attempts. The policy is preserved.
+     *
+     * @throws Error if `id` is not registered.
+     */
+    reset(id: string): void;
+    /**
+     * Subscribes to state-change events for every registered instance.
+     *
+     * @param listener Called once per transition with the post-transition snapshot.
+     * @returns Unsubscribe function.
+     */
+    onStateChange(listener: RetryStateListener): () => void;
+    /**
+     * Runs `fn` under the policy registered for `id`.
+     *
+     * Each invocation starts a fresh attempt cycle: counters and `lastError` are
+     * cleared before the first attempt so the same instance can be re-used after
+     * a previous success or exhaustion.
+     *
+     * @param id Identifier registered via {@link RetryManager.register}.
+     * @param fn Operation to execute. Rejecting causes a retry (subject to the policy).
+     * @returns Whatever `fn` resolves to.
+     * @throws RetryExhaustedError when all attempts have been used or `isRetryable` returns `false`.
+     * @throws Error when `id` is not registered.
+     */
+    execute<T>(id: string, fn: () => Promise<T>): Promise<T>;
+    private requireInstance;
+    private transition;
+    private emit;
+}

package/dist/cjs/index.cjs

@@ -56,6 +56,12 @@ __exportStar(require("./packages/energy-app-diagnostics.cjs"), exports);
 __exportStar(require("./types/enyo-learning-phase.cjs"), exports);
 __exportStar(require("./packages/energy-app-learning-phase.cjs"), exports);
 __exportStar(require("./types/enyo-air-conditioning-appliance.cjs"), exports);
+__exportStar(require("./types/enyo-onboarding.cjs"), exports);
+__exportStar(require("./packages/energy-app-onboarding.cjs"), exports);
+__exportStar(require("./types/enyo-retry-manager.cjs"), exports);
+__exportStar(require("./implementations/retry/backoff.cjs"), exports);
+__exportStar(require("./implementations/retry/retry-manager.cjs"), exports);
+__exportStar(require("./implementations/retry/retry-errors.cjs"), exports);
 __exportStar(require("./integrations/integration-types.cjs"), exports);
 __exportStar(require("./integrations/integration-energy-app.cjs"), exports);
 __exportStar(require("./integrations/heatpump-integration-energy-app.cjs"), exports);

package/dist/cjs/index.d.cts

@@ -40,6 +40,12 @@ export * from './packages/energy-app-diagnostics.cjs';
 export * from './types/enyo-learning-phase.cjs';
 export * from './packages/energy-app-learning-phase.cjs';
 export * from './types/enyo-air-conditioning-appliance.cjs';
+export * from './types/enyo-onboarding.cjs';
+export * from './packages/energy-app-onboarding.cjs';
+export * from './types/enyo-retry-manager.cjs';
+export * from './implementations/retry/backoff.cjs';
+export * from './implementations/retry/retry-manager.cjs';
+export * from './implementations/retry/retry-errors.cjs';
 export * from './integrations/integration-types.cjs';
 export * from './integrations/integration-energy-app.cjs';
 export * from './integrations/heatpump-integration-energy-app.cjs';

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

@@ -1,4 +1,4 @@
-import { EnyoOnboardingGuide, EnyoOnboardingStep, EnyoOnboardingStepListener, EnyoOnboardingStepResponse } from "../types/enyo-onboarding.cjs";
+import { EnyoOnboardingGuide, EnyoOnboardingGuideCategory, EnyoOnboardingStep, EnyoOnboardingStepListener, EnyoOnboardingStepResponse } from "../types/enyo-onboarding.cjs";
 /**
  * Interface for managing onboarding guides within Energy App packages.
  * Provides methods to create, manage, and navigate through onboarding flows
@@ -40,6 +40,22 @@ export interface EnergyAppOnboarding {
      * @returns Promise that resolves to an array of all active onboarding guides
      */
     getAllOnboardingGuides(): Promise<EnyoOnboardingGuide[]>;
+    /**
+     * Gets all currently active onboarding guides that belong to the given category.
+     * Guides without an explicit category are excluded — use {@link getAllOnboardingGuides}
+     * if you need uncategorized guides as well.
+     *
+     * @param category - The lifecycle category to filter guides by
+     * @returns Promise resolving to all guides whose `category` matches
+     *
+     * @example
+     * ```typescript
+     * const reconnectGuides = await onboarding.getGuidesByCategory(
+     *   EnyoOnboardingGuideCategory.ReconnectDevice
+     * );
+     * ```
+     */
+    getGuidesByCategory(category: EnyoOnboardingGuideCategory): Promise<EnyoOnboardingGuide[]>;
     /**
      * Gets the current step being displayed in the onboarding flow for a specific guide.
      * Returns null if no onboarding is active or if the guide is complete.

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

@@ -21,14 +21,17 @@ var EnyoApplianceStateEnum;
 /**
  * Health status of an appliance. Orthogonal to {@link EnyoApplianceStateEnum},
  * which describes connectivity. `Healthy` means the appliance is operating
- * normally; `Faulted` means it has reported an internal error and may need
- * attention. Vendor- or protocol-specific details should be conveyed via
- * accompanying error codes.
+ * normally; `Warning` means a non-blocking issue has been reported (the
+ * appliance is still functional but should be inspected); `Faulted` means it
+ * has reported an internal error and may need attention. Vendor- or
+ * protocol-specific details should be conveyed via accompanying error codes.
  */
 var EnyoApplianceStatusEnum;
 (function (EnyoApplianceStatusEnum) {
     /** Appliance is operating normally */
     EnyoApplianceStatusEnum["Healthy"] = "healthy";
+    /** Appliance is operating but has reported a non-blocking issue that should be inspected */
+    EnyoApplianceStatusEnum["Warning"] = "warning";
     /** Appliance has reported an internal fault */
     EnyoApplianceStatusEnum["Faulted"] = "faulted";
 })(EnyoApplianceStatusEnum || (exports.EnyoApplianceStatusEnum = EnyoApplianceStatusEnum = {}));

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

@@ -28,16 +28,26 @@ export declare enum EnyoApplianceStateEnum {
 /**
  * Health status of an appliance. Orthogonal to {@link EnyoApplianceStateEnum},
  * which describes connectivity. `Healthy` means the appliance is operating
- * normally; `Faulted` means it has reported an internal error and may need
- * attention. Vendor- or protocol-specific details should be conveyed via
- * accompanying error codes.
+ * normally; `Warning` means a non-blocking issue has been reported (the
+ * appliance is still functional but should be inspected); `Faulted` means it
+ * has reported an internal error and may need attention. Vendor- or
+ * protocol-specific details should be conveyed via accompanying error codes.
  */
 export declare enum EnyoApplianceStatusEnum {
     /** Appliance is operating normally */
     Healthy = "healthy",
+    /** Appliance is operating but has reported a non-blocking issue that should be inspected */
+    Warning = "warning",
     /** Appliance has reported an internal fault */
     Faulted = "faulted"
 }
+/**
+ * Severity classification for an {@link EnyoApplianceErrorCode}.
+ * Producers should mark non-blocking issues as `'warning'` and blocking
+ * faults as `'error'`. When omitted on an error code, consumers should
+ * treat it as `'error'` for backwards compatibility.
+ */
+export type EnyoApplianceErrorSeverity = 'error' | 'warning';
 /**
  * Translated, human-readable message for an appliance error code.
  * Producers should emit at most one entry per supported language.
@@ -49,18 +59,26 @@ export interface EnyoApplianceErrorMessage {
     message: string;
 }
 /**
- * Vendor- or protocol-specific error reported by an appliance, optionally
- * accompanied by translated human-readable messages. The `code` is the
- * machine-readable identifier (stable, non-localized); `messages` is an
+ * Vendor- or protocol-specific error or warning reported by an appliance,
+ * optionally accompanied by translated human-readable messages. The `code` is
+ * the machine-readable identifier (stable, non-localized); `messages` is an
  * optional set of pre-translated descriptions intended for UI display.
  * Consumers should fall back to rendering `code` when no `messages` entry
- * matches their locale.
+ * matches their locale. Use `severity` to distinguish a blocking error from
+ * a non-blocking warning; when omitted, consumers should treat the entry as
+ * an error for backwards compatibility.
  */
 export interface EnyoApplianceErrorCode {
     /** Machine-readable, vendor- or protocol-specific error code */
     code: string;
     /** Optional translated messages explaining the error */
     messages?: EnyoApplianceErrorMessage[];
+    /**
+     * Optional severity of this entry. Defaults to `'error'` semantics when
+     * omitted. Use `'warning'` to indicate a non-blocking issue that should
+     * be surfaced but does not put the appliance into a faulted state.
+     */
+    severity?: EnyoApplianceErrorSeverity;
 }
 export interface EnyoApplianceNetworkMetadata {
     /** If the appliance is connected via cellular network, you can put the imsi here*/

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

@@ -1,5 +1,10 @@
 import { EnyoPackageConfigurationTranslatedValue } from "./enyo-settings.cjs";
 export type EnyoAuthenticationType = 'apiKey' | 'oauth' | 'usernamePassword';
+/**
+ * Indicates whether the authentication request should be presented to the user
+ * before or after the onboarding guide. When omitted, the host decides the default ordering.
+ */
+export type EnyoAuthenticationOnboardingOrder = 'before-onboarding' | 'after-onboarding';
 /**
  * Represents an additional custom field for authentication forms.
  * Allows developers to add extra input fields beyond the standard username/password or API key.
@@ -66,6 +71,11 @@ export interface EnyoAuthentication {
     oneTimeAuthentication: boolean;
     /** Optional appliance ID. If provided, authentication is for specific appliance. If omitted, authentication is for the whole package */
     applianceId?: string;
+    /**
+     * Optional ordering hint indicating whether this authentication request should be
+     * presented before or after the onboarding guide. When omitted, the host decides the default.
+     */
+    onboardingOrder?: EnyoAuthenticationOnboardingOrder;
 }
 export interface EnyoApiKeyAuthenticationResponse {
     apiKey: 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-data-bus-value.d.cts

@@ -330,7 +330,8 @@ export interface EnyoDataBusApplianceFlexibilityAnnouncementV1 extends EnyoDataB
  * changes. At least one of `state` or `status` should be set; both may be
  * provided together if they change in the same event. `errorCodes` carries
  * vendor- or protocol-specific codes that explain a transition into a
- * `faulted` status.
+ * `warning` or `faulted` status; each entry's `severity` field indicates
+ * which.
  */
 export interface EnyoDataBusApplianceStateUpdateV1 extends EnyoDataBusMessage {
     type: 'message';
@@ -345,9 +346,10 @@ export interface EnyoDataBusApplianceStateUpdateV1 extends EnyoDataBusMessage {
         /**
          * Optional vendor- or protocol-specific error codes that explain the
          * current status. Each entry carries the raw code and may include
-         * pre-translated messages for UI display. Typically populated when
-         * transitioning into `faulted`; omitted or empty when there is
-         * nothing to report.
+         * pre-translated messages for UI display, plus an optional `severity`
+         * (`'error'` or `'warning'`). Typically populated when transitioning
+         * into `warning` or `faulted`; omitted or empty when there is nothing
+         * to report.
          */
         errorCodes?: EnyoApplianceErrorCode[];
     };

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

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnyoOnboardingSectionType = void 0;
+exports.EnyoOnboardingSectionType = exports.EnyoOnboardingGuideCategory = void 0;
+/**
+ * Enum representing the lifecycle category of an onboarding guide.
+ * Used to distinguish guides that perform different roles, e.g. initial
+ * configuration of a package vs. adding or reconnecting a single device.
+ */
+var EnyoOnboardingGuideCategory;
+(function (EnyoOnboardingGuideCategory) {
+    /** Initial package configuration — shown when EnergyAppStateEnum is 'configuration-required' */
+    EnyoOnboardingGuideCategory["InitialSetup"] = "initial-setup";
+    /** Guide for adding a new device to an already-configured package */
+    EnyoOnboardingGuideCategory["AddNewDevice"] = "add-new-device";
+    /** Guide for reconnecting an existing device that has lost its connection */
+    EnyoOnboardingGuideCategory["ReconnectDevice"] = "reconnect-device";
+})(EnyoOnboardingGuideCategory || (exports.EnyoOnboardingGuideCategory = EnyoOnboardingGuideCategory = {}));
 /**
  * Enum representing the type of content an onboarding section displays.
  */

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

@@ -9,6 +9,19 @@ export interface EnyoOnboardingTranslatedContent {
     /** The translated text value */
     value: string;
 }
+/**
+ * Enum representing the lifecycle category of an onboarding guide.
+ * Used to distinguish guides that perform different roles, e.g. initial
+ * configuration of a package vs. adding or reconnecting a single device.
+ */
+export declare enum EnyoOnboardingGuideCategory {
+    /** Initial package configuration — shown when EnergyAppStateEnum is 'configuration-required' */
+    InitialSetup = "initial-setup",
+    /** Guide for adding a new device to an already-configured package */
+    AddNewDevice = "add-new-device",
+    /** Guide for reconnecting an existing device that has lost its connection */
+    ReconnectDevice = "reconnect-device"
+}
 /**
  * Enum representing the type of content an onboarding section displays.
  */
@@ -125,6 +138,12 @@ export interface EnyoOnboardingGuide {
     description?: EnyoOnboardingTranslatedContent[];
     /** Optional appliance ID if this guide is associated with an appliance */
     applianceId?: string;
+    /**
+     * Optional lifecycle category for this guide.
+     * Allows hosts to render category-specific entry points (e.g. "Add new device" buttons).
+     * Defaults to InitialSetup semantics when omitted, for backwards compatibility.
+     */
+    category?: EnyoOnboardingGuideCategory;
     /** Ordered array of steps in the onboarding flow */
     steps: EnyoOnboardingStep[];
 }