@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/cjs/utils/validator/ConfigValidator.js

@@ -0,0 +1,216 @@
+'use strict';
+
+var validators = require('./validators.js');
+var ESPConfigError = require('../error/ESPConfigError.js');
+var constants = require('../constants.js');
+require('../logger.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Methods every custom storage adapter must implement. */
+const STORAGE_ADAPTER_METHODS = [
+    "setItem",
+    "getItem",
+    "removeItem",
+    "clear",
+];
+/** Required methods for an MQTT transport (`once` is optional per interface). */
+const MQTT_ADAPTER_METHODS = [
+    "connect",
+    "disconnect",
+    "isConnected",
+    "publish",
+    "subscribe",
+    "unsubscribe",
+];
+/** Required methods for a provisioning adapter. */
+const PROVISION_ADAPTER_METHODS = [
+    "searchESPDevices",
+    "stopESPDevicesSearch",
+    "createESPDevice",
+    "connect",
+    "getDeviceCapabilities",
+    "getDeviceVersion",
+    "setProofOfPossession",
+    "initializeSession",
+    "scanWifiList",
+    "sendData",
+    "provision",
+    "disconnect",
+];
+/** Required methods for a local control adapter. */
+const LOCAL_CONTROL_ADAPTER_METHODS = [
+    "isConnected",
+    "connect",
+    "sendData",
+];
+/** Required methods for a local discovery adapter. */
+const LOCAL_DISCOVERY_ADAPTER_METHODS = [
+    "startDiscovery",
+    "stopDiscovery",
+];
+/**
+ * A class that validates configuration objects for the ESP RainMaker Neo SDK.
+ *
+ * This class provides methods to ensure that the provided configuration
+ * adheres to the required structure and rules for URLs, versions, and other fields.
+ */
+class ConfigValidator {
+    /**
+     * Validates the given authentication configuration.
+     *
+     * @param config - The authentication configuration object to validate.
+     * @throws {ESPConfigError} If the configuration is invalid.
+     */
+    static validateConfig(config) {
+        ConfigValidator.validateConfigObject(config);
+        ConfigValidator.validateBaseUrl(config.baseUrl);
+        ConfigValidator.validateUserApiBase(config.userApiBase);
+        ConfigValidator.validateRegion(config.awsRegion);
+        ConfigValidator.validateIotEndpoint(config.iotEndpoint);
+        ConfigValidator.validateCustomStorageAdapter(config.customStorageAdapter);
+        ConfigValidator.validateMQTTAdapter(config.mqttAdapter);
+        ConfigValidator.validateProvisionAdapter(config.provisionAdapter);
+        ConfigValidator.validateLocalControlAdapter(config.localControlAdapter);
+        ConfigValidator.validateLocalDiscoveryAdapter(config.localDiscoveryAdapter);
+    }
+    /**
+     * Validates that the provided configuration object is valid.
+     *
+     * @param config - The configuration object to validate.
+     * @throws {ESPConfigError} If the configuration object is invalid.
+     */
+    static validateConfigObject(config) {
+        if (!validators.isValidObject(config)) {
+            throw new ESPConfigError.ESPConfigError(constants.ConfigErrorCodes.INVALID_CONFIG_OBJECT);
+        }
+    }
+    /**
+     * Validates the base URL of the configuration.
+     *
+     * @param baseUrl - The base URL to validate.
+     * @throws {ESPConfigError} If the base URL is invalid or empty.
+     */
+    static validateBaseUrl(baseUrl) {
+        if (!validators.isNonEmptyString(baseUrl) || !validators.isValidUrl(baseUrl)) {
+            throw new ESPConfigError.ESPConfigError(constants.ConfigErrorCodes.INVALID_BASE_URL);
+        }
+    }
+    /**
+     * Validates the User/auth API base URL of the configuration.
+     *
+     * @param userApiBase - The User API base URL to validate.
+     * @throws {ESPConfigError} If the User API base URL is invalid or empty.
+     */
+    static validateUserApiBase(userApiBase) {
+        if (!validators.isNonEmptyString(userApiBase) || !validators.isValidUrl(userApiBase)) {
+            throw new ESPConfigError.ESPConfigError(constants.ConfigErrorCodes.INVALID_USER_API_BASE);
+        }
+    }
+    /**
+     * Validates the AWS region.
+     *
+     * @param region - The AWS region to validate.
+     * @throws {ESPConfigError} If the region is invalid or empty.
+     */
+    static validateRegion(region) {
+        if (!validators.isNonEmptyString(region)) {
+            throw new ESPConfigError.ESPConfigError(constants.ConfigErrorCodes.INVALID_REGION);
+        }
+    }
+    /**
+     * Validates the IoT endpoint (used for MQTT and SigV4-signed connections).
+     * Accepts either a hostname (e.g. `xxxxx-ats.iot.region.amazonaws.com`) or a
+     * full `wss://…/mqtt` URL; both forms are normalised downstream.
+     *
+     * @param iotEndpoint - The IoT endpoint string to validate.
+     * @throws {ESPConfigError} If the endpoint is missing or empty.
+     */
+    static validateIotEndpoint(iotEndpoint) {
+        if (!validators.isNonEmptyString(iotEndpoint)) {
+            throw new ESPConfigError.ESPConfigError(constants.ConfigErrorCodes.INVALID_IOT_ENDPOINT);
+        }
+    }
+    /**
+     * Validates that an adapter is an object and implements every method in
+     * {@link requiredMethods}. Throws with {@link errorCode} on the first
+     * missing method.
+     */
+    static validateAdapterShape(adapter, requiredMethods, errorCode) {
+        if (!validators.isValidObject(adapter)) {
+            throw new ESPConfigError.ESPConfigError(errorCode);
+        }
+        const record = adapter;
+        for (const method of requiredMethods) {
+            if (typeof record[method] !== "function") {
+                throw new ESPConfigError.ESPConfigError(errorCode);
+            }
+        }
+    }
+    /**
+     * Validates the custom storage adapter if provided.
+     *
+     * @param adapter - The custom storage adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPStorageAdapter} contract.
+     */
+    static validateCustomStorageAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, STORAGE_ADAPTER_METHODS, constants.ConfigErrorCodes.INVALID_STORAGE_ADAPTER);
+    }
+    /**
+     * Validates the MQTT adapter if provided.
+     *
+     * @param adapter - The MQTT adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link MQTTTransport} contract.
+     */
+    static validateMQTTAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, MQTT_ADAPTER_METHODS, constants.ConfigErrorCodes.INVALID_MQTT_ADAPTER);
+    }
+    /**
+     * Validates the provisioning adapter if provided.
+     *
+     * @param adapter - The provisioning adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPProvisionAdapterInterface} contract.
+     */
+    static validateProvisionAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, PROVISION_ADAPTER_METHODS, constants.ConfigErrorCodes.INVALID_PROVISION_ADAPTER);
+    }
+    /**
+     * Validates the local control adapter if provided.
+     *
+     * @param adapter - The local control adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPLocalControlAdapterInterface} contract.
+     */
+    static validateLocalControlAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, LOCAL_CONTROL_ADAPTER_METHODS, constants.ConfigErrorCodes.INVALID_LOCAL_CONTROL_ADAPTER);
+    }
+    /**
+     * Validates the local discovery adapter if provided.
+     *
+     * @param adapter - The local discovery adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPLocalDiscoveryAdapterInterface} contract.
+     */
+    static validateLocalDiscoveryAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, LOCAL_DISCOVERY_ADAPTER_METHODS, constants.ConfigErrorCodes.INVALID_LOCAL_DISCOVERY_ADAPTER);
+    }
+}
+
+exports.ConfigValidator = ConfigValidator;
+//# sourceMappingURL=ConfigValidator.js.map

package/dist/cjs/utils/validator/ConfigValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigValidator.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/utils/validator/ScheduleValidator.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var constants = require('../constants.js');
+var ESPAPICallValidationError = require('../error/ESPAPICallValidationError.js');
+var validators = require('./validators.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Validates schedule payloads used by group/node schedule APIs.
+ */
+class ScheduleValidator {
+    /**
+     * Validates the `nodeSchedules` argument for `createSchedule`.
+     *
+     * @param nodeSchedules - Per-node schedule batches to validate.
+     * @throws {ESPAPICallValidationError} If the payload shape is invalid.
+     */
+    static validateNodeSchedules(nodeSchedules) {
+        if (!Array.isArray(nodeSchedules)) {
+            throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.INVALID_NODE_SCHEDULES);
+        }
+        for (const { nodeId, schedules } of nodeSchedules) {
+            if (!validators.isNonEmptyString(nodeId)) {
+                throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_NODE_ID);
+            }
+            if (!Array.isArray(schedules)) {
+                throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.INVALID_SCHEDULES);
+            }
+            for (const schedule of schedules) {
+                ScheduleValidator.validateScheduleItem(schedule);
+            }
+        }
+    }
+    /**
+     * Validates a single schedule item.
+     *
+     * @param item - The schedule item to validate.
+     * @throws {ESPAPICallValidationError} If required fields are missing or invalid.
+     */
+    static validateScheduleItem(item) {
+        if (typeof item?.enabled !== "boolean") {
+            throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.INVALID_SCHEDULE_ENABLED);
+        }
+        if (!Array.isArray(item.triggers)) {
+            throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.INVALID_SCHEDULE_TRIGGERS);
+        }
+        if (!validators.isValidObject(item.action)) {
+            throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.INVALID_SCHEDULE_ACTION);
+        }
+    }
+}
+
+exports.ScheduleValidator = ScheduleValidator;
+//# sourceMappingURL=ScheduleValidator.js.map

package/dist/cjs/utils/validator/ScheduleValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleValidator.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/utils/validator/validators.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Checks if a string is not empty.
+ * @param value - The string to check.
+ * @returns True if the string is not empty, false otherwise.
+ */
+const isNonEmptyString = (value) => {
+    return typeof value === "string" && value.trim().length > 0;
+};
+/**
+ * Validates if a given string is a valid URL.
+ * @param url - The URL string to validate.
+ * @returns True if the URL is valid, false otherwise.
+ */
+const isValidUrl = (url) => {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Checks if a value is a valid object (not null and type object).
+ * @param value - The value to check.
+ * @returns True if the value is a valid object, false otherwise.
+ */
+const isValidObject = (value) => {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+
+exports.isNonEmptyString = isNonEmptyString;
+exports.isValidObject = isValidObject;
+exports.isValidUrl = isValidUrl;
+//# sourceMappingURL=validators.js.map

package/dist/cjs/utils/validator/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/utils/waitForNodeOnline.js

@@ -0,0 +1,187 @@
+'use strict';
+
+var ESPRMNeoMqtt = require('../services/ESPRMNeoMqtt/ESPRMNeoMqtt.js');
+var NodeMQTTOrchestrator = require('../services/NodeMQTTOrchestrator.js');
+var constants = require('./constants.js');
+var ESPProvError = require('./error/ESPProvError.js');
+var shadowUtils = require('./shadowUtils.js');
+var logger$1 = require('./logger.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("waitForNodeOnline");
+/** Default max wait after WiFi provisioning before rejecting (2 minutes). */
+const DEFAULT_NODE_ONLINE_TIMEOUT_MS = 120_000;
+/** Interval between shadow GET polls while waiting (matches app_sim). */
+const DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS = 5_000;
+/**
+ * Creates a promise with externally accessible `resolve` / `reject` handles.
+ * Used so MQTT callbacks and the timeout timer can settle the same wait.
+ */
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+/**
+ * Schedules a one-shot timeout that rejects the online wait with {@link ESPProvError}.
+ * No-ops if the wait already settled (MQTT success, GET poll, or duplicate event).
+ */
+function createOnlineTimeout(nodeId, timeoutMs, reject, isSettled, markSettled) {
+    return setTimeout(() => {
+        if (isSettled()) {
+            return;
+        }
+        markSettled();
+        logger.error("Timed out waiting for node to come online", {
+            nodeId,
+            timeoutMs,
+        });
+        reject(new ESPProvError.ESPProvError(constants.ProvErrorCodes.NODE_ONLINE_TIMEOUT));
+    }, timeoutMs);
+}
+/**
+ * Detects online status from a shadow MQTT payload or getShadow state slice.
+ *
+ * Live MQTT messages use `{ state: { reported: { online: true } } }`.
+ * {@link NodeMQTTOrchestrator.getShadow} returns `{ reported: { online: true } }`.
+ */
+function isNodeOnlineFromShadowPayload(payload) {
+    const data = payload;
+    return (data?.state?.reported?.online === true || data?.reported?.online === true);
+}
+/**
+ * Subscribes to shadow MQTT for `nodeId`, polls getShadow on an interval, resolves
+ * when `online: true`, then unsubscribes and unregisters the temporary node binding
+ * (if owned).
+ *
+ * @throws {ESPProvError} If `timeoutMs` elapses without the node reporting online.
+ * @throws {Error} If MQTT connection or subscription fails.
+ */
+async function waitForNodeOnline({ nodeId, groupId, user, timeoutMs = DEFAULT_NODE_ONLINE_TIMEOUT_MS, pollIntervalMs = DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS, }) {
+    const shadowName = shadowUtils.constructShadowName(groupId);
+    logger.info("Waiting for node to come online", {
+        nodeId,
+        groupId,
+        shadowName,
+        timeoutMs,
+        pollIntervalMs,
+    });
+    // Guards against resolving/rejecting more than once (MQTT vs poll vs timeout race).
+    let settled = false;
+    const isSettled = () => settled;
+    const markSettled = () => {
+        settled = true;
+    };
+    const online = createDeferred();
+    const settleOnline = (source) => {
+        if (isSettled()) {
+            return;
+        }
+        markSettled();
+        logger.info("Node reported online", { nodeId, source });
+        online.resolve();
+    };
+    /** MQTT shadow callback — resolves the wait when `state.reported.online` becomes true. */
+    const onUpdate = (payload) => {
+        if (!isNodeOnlineFromShadowPayload(payload)) {
+            return;
+        }
+        settleOnline("mqtt");
+    };
+    /** Polls getShadow; ignores missing-shadow errors (expected right after provision). */
+    const pollShadowOnce = async () => {
+        if (isSettled()) {
+            return;
+        }
+        try {
+            const shadow = await NodeMQTTOrchestrator.NodeMQTTOrchestrator.getShadow(nodeId);
+            if (isNodeOnlineFromShadowPayload(shadow)) {
+                settleOnline("shadow_get");
+            }
+        }
+        catch (error) {
+            logger.debug("Shadow get while waiting for online failed; will retry", {
+                nodeId,
+                error,
+            });
+        }
+    };
+    // Avoid wiping a registration owned by ESPRMNeoNode / subscription channel.
+    const alreadyRegistered = NodeMQTTOrchestrator.NodeMQTTOrchestrator.isNodeRegistered(nodeId);
+    let timer;
+    let pollTimer;
+    /** Clears timers, unsubscribes our callback; unregisters only if we created the binding. */
+    const cleanup = async () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        if (pollTimer !== undefined) {
+            clearInterval(pollTimer);
+        }
+        try {
+            await NodeMQTTOrchestrator.NodeMQTTOrchestrator.unsubscribeFromNode(nodeId, onUpdate);
+            if (!alreadyRegistered) {
+                NodeMQTTOrchestrator.NodeMQTTOrchestrator.unregisterNode(nodeId);
+            }
+            logger.debug("Cleaned up temporary MQTT subscription", { nodeId });
+        }
+        catch (error) {
+            logger.warn("Failed to clean up temporary MQTT subscription", {
+                nodeId,
+                error,
+            });
+        }
+    };
+    try {
+        // 1. Ensure MQTT connectivity
+        const mqttConnected = ESPRMNeoMqtt.ESPRMNeoMqtt.hasInstance() && (await ESPRMNeoMqtt.ESPRMNeoMqtt.getInstance().isConnected());
+        if (!mqttConnected) {
+            logger.debug("MQTT not connected; connecting before online wait", {
+                nodeId,
+            });
+            await user.connectMQTT();
+        }
+        // 2. Register (if needed) and subscribe before the shadow may exist
+        if (!alreadyRegistered) {
+            NodeMQTTOrchestrator.NodeMQTTOrchestrator.registerNode(nodeId, shadowName);
+        }
+        await NodeMQTTOrchestrator.NodeMQTTOrchestrator.subscribeToNode(nodeId, onUpdate);
+        logger.debug("Subscribed to node shadow for online wait", {
+            nodeId,
+            shadowName,
+        });
+        // 3. Start timeout only after we are listening
+        timer = createOnlineTimeout(nodeId, timeoutMs, online.reject, isSettled, markSettled);
+        // 4. Immediate GET + interval poll (app_sim pattern); MQTT updates also settle
+        await pollShadowOnce();
+        if (!isSettled()) {
+            pollTimer = setInterval(() => {
+                void pollShadowOnce();
+            }, pollIntervalMs);
+        }
+        // 5. Wait until MQTT update, successful GET, or timeout
+        await online.promise;
+    }
+    catch (error) {
+        markSettled();
+        logger.error("Error while waiting for node to come online", error);
+        throw error;
+    }
+    finally {
+        await cleanup();
+    }
+}
+
+exports.DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS = DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS;
+exports.DEFAULT_NODE_ONLINE_TIMEOUT_MS = DEFAULT_NODE_ONLINE_TIMEOUT_MS;
+exports.isNodeOnlineFromShadowPayload = isNodeOnlineFromShadowPayload;
+exports.waitForNodeOnline = waitForNodeOnline;
+//# sourceMappingURL=waitForNodeOnline.js.map

package/dist/cjs/utils/waitForNodeOnline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitForNodeOnline.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/ESPDevice.js

@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Lazy require to avoid circular dependency: ESPDevice -> ESPRMNeoBase -> (index) -> ESPDevice
+function getESPRMNeoBase() {
+    return require("./ESPRMNeoBase").ESPRMNeoBase;
+}
+/**
+ * Represents an ESP device for provisioning and local communication.
+ * Provides methods for device discovery and WiFi provisioning.
+ */
+class ESPDevice {
+    _espProvisionAdapter;
+    get ESPProvisionAdapter() {
+        if (!this._espProvisionAdapter) {
+            this._espProvisionAdapter = getESPRMNeoBase().getProvisionAdapter();
+        }
+        return this._espProvisionAdapter;
+    }
+    name;
+    transport;
+    security;
+    constructor(deviceConfig) {
+        this.name = deviceConfig.name;
+        this.transport = deviceConfig.transport;
+        this.security = deviceConfig.security;
+    }
+}
+
+export { ESPDevice };
+//# sourceMappingURL=ESPDevice.js.map

package/dist/esm/ESPDevice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPDevice.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/ESPRMNeoAuth.js

@@ -0,0 +1,58 @@
+import { ESPRMNeoAPIManager } from './services/ESPRMNeoAPIManager.js';
+import { Logger } from './utils/logger.js';
+import { APIPathV1, AuthErrorCodes } from './utils/constants.js';
+import { authErrorMessages } from './utils/error/errorMessages.js';
+import { ESPAuthError } from './utils/error/ESPAuthError.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("ESPRMNeoAuth");
+/**
+ * The `ESPRMNeoAuth` class provides authentication functionality via the
+ * RainMaker User Auth API. Key features include:
+ *
+ * - **Sign-Up Process**: Methods to send sign-up codes and confirm user registration.
+ * - **Password Management**: Support for password recovery, setting new passwords, and login with credentials.
+ * - **Session Management**: Provides functionality to fetch details of the currently logged-in user.
+ */
+class ESPRMNeoAuth {
+    _config;
+    constructor(config) {
+        this._config = config;
+    }
+    /**
+     * Returns the SDK config this auth instance was constructed with.
+     * Prefer this over {@link ESPRMNeoBase.getConfig} in auth method implementations.
+     */
+    getConfig() {
+        return this._config;
+    }
+    /**
+     * Gets refreshed tokens using a refresh token without persisting them.
+     *
+     * Calls `POST /v1/user/auth/token/refresh` (unauthenticated; the backend
+     * validates `refresh_token` in the body only).
+     */
+    static async getRefreshedTokens(refreshToken) {
+        const api = ESPRMNeoAPIManager.getInstance();
+        logger.debug("getRefreshedTokens (token/refresh)", {
+            refresh_token: refreshToken.substring(0, 20) + "...",
+        });
+        const requestBody = { refresh_token: refreshToken };
+        const apiResponse = await api.postUserApi(APIPathV1.USER_AUTH_TOKEN_REFRESH, requestBody);
+        if (!apiResponse?.access_token || !apiResponse?.id_token) {
+            throw new ESPAuthError(AuthErrorCodes.TOKEN_REFRESH_FAILED_MISSING_TOKENS, authErrorMessages.TOKEN_REFRESH_FAILED_MISSING_TOKENS, apiResponse);
+        }
+        return {
+            accessToken: apiResponse.access_token,
+            idToken: apiResponse.id_token,
+            refreshToken,
+        };
+    }
+}
+
+export { ESPAuthError, ESPRMNeoAuth };
+//# sourceMappingURL=ESPRMNeoAuth.js.map

package/dist/esm/ESPRMNeoAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/ESPRMNeoAutomation.js

@@ -0,0 +1,46 @@
+import { APICallValidationErrorCodes, AutomationStatusValues } from './utils/constants.js';
+import { ESPAPICallValidationError } from './utils/error/ESPAPICallValidationError.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents an automation in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for automation operations.
+ */
+class ESPRMNeoAutomation {
+    id;
+    groupId;
+    name;
+    conditions;
+    actions;
+    /** Enable/disable flag. Defaults to "enabled" when absent (backend default). */
+    status;
+    retrigger;
+    constructor(data, group) {
+        if (!data.id) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_AUTOMATION_ID);
+        }
+        if (!data.name) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_AUTOMATION_NAME);
+        }
+        if (!data.conditions) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_AUTOMATION_CONDITIONS);
+        }
+        if (!data.actions) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_AUTOMATION_ACTIONS);
+        }
+        this.id = data.id;
+        this.groupId = group.groupId;
+        this.name = data.name;
+        this.conditions = data.conditions;
+        this.actions = data.actions;
+        this.status = data.status ?? AutomationStatusValues.ENABLED;
+        this.retrigger = data.retrigger;
+    }
+}
+
+export { ESPRMNeoAutomation };
+//# sourceMappingURL=ESPRMNeoAutomation.js.map

package/dist/esm/ESPRMNeoAutomation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoAutomation.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}