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

package/dist/cjs/types/enyo-retry-manager.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryState = void 0;
+/**
+ * Lifecycle state of a single retryable instance tracked by {@link RetryManager}.
+ */
+var RetryState;
+(function (RetryState) {
+    /** Registered but no attempt has run yet (or the instance was reset). */
+    RetryState["Idle"] = "idle";
+    /** An attempt is currently executing. */
+    RetryState["Running"] = "running";
+    /** The previous attempt failed and the manager is sleeping before the next one. */
+    RetryState["Waiting"] = "waiting";
+    /** The most recent attempt succeeded. */
+    RetryState["Succeeded"] = "succeeded";
+    /** All attempts have been used (or the error was non-retryable). */
+    RetryState["Exhausted"] = "exhausted";
+})(RetryState || (exports.RetryState = RetryState = {}));

package/dist/cjs/types/enyo-retry-manager.d.cts

@@ -0,0 +1,72 @@
+/**
+ * Lifecycle state of a single retryable instance tracked by {@link RetryManager}.
+ */
+export declare enum RetryState {
+    /** Registered but no attempt has run yet (or the instance was reset). */
+    Idle = "idle",
+    /** An attempt is currently executing. */
+    Running = "running",
+    /** The previous attempt failed and the manager is sleeping before the next one. */
+    Waiting = "waiting",
+    /** The most recent attempt succeeded. */
+    Succeeded = "succeeded",
+    /** All attempts have been used (or the error was non-retryable). */
+    Exhausted = "exhausted"
+}
+/**
+ * Backoff curve used to compute the delay between retry attempts.
+ *
+ * The same shape covers fixed, linear and exponential strategies so callers
+ * configure backoff with plain data instead of constructing strategy classes.
+ */
+export interface BackoffConfig {
+    /** Backoff curve. `exponential` is the typical default for network I/O. */
+    type: 'fixed' | 'linear' | 'exponential';
+    /** Base delay for the first retry, in milliseconds. Must be `>= 0`. */
+    initialMs: number;
+    /** Optional upper bound (ms) applied after the curve and before jitter. */
+    maxMs?: number;
+    /** Growth factor for `exponential`. Defaults to `2`. Must be `>= 1`. */
+    factor?: number;
+    /**
+     * Random jitter ratio in `[0, 1]`. `0.2` means the final delay is uniformly
+     * distributed in `[delay * 0.8, delay * 1.2]`. Defaults to `0`.
+     */
+    jitter?: number;
+}
+/**
+ * Per-instance retry policy. Registered with {@link RetryManager.register}.
+ */
+export interface RetryPolicy {
+    /** Total attempts allowed including the first call. Use `Infinity` for endless retry. */
+    maxAttempts: number;
+    /** Backoff curve applied between attempts. */
+    backoff: BackoffConfig;
+    /**
+     * Predicate consulted after each failure. Returning `false` short-circuits
+     * to {@link RetryState.Exhausted} without further retries (e.g. for auth or 4xx errors).
+     * Defaults to "always retryable".
+     */
+    isRetryable?: (error: unknown) => boolean;
+}
+/**
+ * Snapshot of a single instance's current retry state.
+ */
+export interface RetryStatus {
+    /** Identifier the instance was registered under. */
+    id: string;
+    /** Current lifecycle state. */
+    state: RetryState;
+    /** Number of attempts that have started so far in the current cycle. */
+    attempts: number;
+    /** Error from the most recent failed attempt, if any. */
+    lastError?: unknown;
+    /** Delay (ms) the manager is sleeping for, set only while `state === Waiting`. */
+    nextDelayMs?: number;
+}
+/**
+ * Listener invoked on every state transition for any registered instance.
+ *
+ * @param status Snapshot of the instance immediately after the transition.
+ */
+export type RetryStateListener = (status: RetryStatus) => void;

package/dist/cjs/version.cjs

@@ -9,7 +9,7 @@ exports.getSdkVersion = getSdkVersion;
 /**
  * Current version of the enyo Energy App SDK.
  */
-exports.SDK_VERSION = '0.0.113';
+exports.SDK_VERSION = '0.0.115';
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/dist/cjs/version.d.cts

@@ -5,7 +5,7 @@
 /**
  * Current version of the enyo Energy App SDK.
  */
-export declare const SDK_VERSION = "0.0.113";
+export declare const SDK_VERSION = "0.0.115";
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/dist/implementations/retry/backoff.d.ts

@@ -0,0 +1,19 @@
+import type { BackoffConfig } from '../../types/enyo-retry-manager.js';
+/**
+ * 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/implementations/retry/backoff.js

@@ -0,0 +1,55 @@
+/**
+ * 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 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/implementations/retry/retry-errors.d.ts

@@ -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/implementations/retry/retry-errors.js

@@ -0,0 +1,24 @@
+/**
+ * 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 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';
+    }
+}

package/dist/implementations/retry/retry-manager.d.ts

@@ -0,0 +1,97 @@
+import { type RetryPolicy, type RetryStateListener, type RetryStatus } from '../../types/enyo-retry-manager.js';
+/**
+ * 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/implementations/retry/retry-manager.js

@@ -0,0 +1,178 @@
+import { RetryState, } from '../../types/enyo-retry-manager.js';
+import { computeBackoffDelay } from './backoff.js';
+import { RetryExhaustedError } from './retry-errors.js';
+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());
+ * ```
+ */
+export 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: 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 = 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, RetryState.Running);
+            try {
+                const result = await fn();
+                instance.lastError = undefined;
+                this.transition(instance, 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, RetryState.Exhausted);
+                    throw new RetryExhaustedError(id, attempt, error);
+                }
+                const delay = computeBackoffDelay(backoff, attempt, this.rng);
+                instance.nextDelayMs = delay;
+                this.transition(instance, 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 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);
+        }
+    }
+}
+function toStatus(instance) {
+    return {
+        id: instance.id,
+        state: instance.state,
+        attempts: instance.attempts,
+        lastError: instance.lastError,
+        nextDelayMs: instance.nextDelayMs,
+    };
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/packages/energy-app-onboarding.d.ts

@@ -1,4 +1,4 @@
-import { EnyoOnboardingGuide, EnyoOnboardingStep, EnyoOnboardingStepListener, EnyoOnboardingStepResponse } from "../types/enyo-onboarding.js";
+import { EnyoOnboardingGuide, EnyoOnboardingGuideCategory, EnyoOnboardingStep, EnyoOnboardingStepListener, EnyoOnboardingStepResponse } from "../types/enyo-onboarding.js";
 /**
  * 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/types/enyo-appliance.d.ts

@@ -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/types/enyo-appliance.js

@@ -18,14 +18,17 @@ export 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.
  */
 export 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 || (EnyoApplianceStatusEnum = {}));