@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/esm/methods/ESPRMNeoAuth/Login.js

@@ -0,0 +1,47 @@
+import { ESPRMNeoAuth } from '../../ESPRMNeoAuth.js';
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+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("Login");
+/**
+ * Maps a sign-in API response to SDK token fields, or throws when any token is missing.
+ */
+function toUserTokens(apiResponse) {
+    if (!apiResponse?.access_token ||
+        !apiResponse?.id_token ||
+        !apiResponse?.refresh_token) {
+        logger.debug("login → Missing required tokens in response");
+        throw new ESPAuthError(AuthErrorCodes.LOGIN_FAILED_MISSING_TOKENS, authErrorMessages.LOGIN_FAILED_MISSING_TOKENS, apiResponse);
+    }
+    return {
+        accessToken: apiResponse.access_token,
+        idToken: apiResponse.id_token,
+        refreshToken: apiResponse.refresh_token,
+    };
+}
+ESPRMNeoAuth.prototype.login = async function (username, password) {
+    try {
+        const api = ESPRMNeoAPIManager.getInstance();
+        logger.debug(`login → POST ${APIPathV1.USER_AUTH_TOKEN}`);
+        const requestBody = { username, password };
+        const apiResponse = await api.postUserApi(APIPathV1.USER_AUTH_TOKEN, requestBody);
+        return new ESPRMNeoUser(toUserTokens(apiResponse));
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError)
+            throw err;
+        const message = err instanceof Error ? err.message : authErrorMessages.LOGIN_FAILED;
+        logger.debug("login → Error:", message);
+        throw new ESPAuthError(AuthErrorCodes.LOGIN_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=Login.js.map

package/dist/esm/methods/ESPRMNeoAuth/Login.js.map

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

package/dist/esm/methods/ESPRMNeoAuth/SendSignUpCode.js

@@ -0,0 +1,45 @@
+import { ESPRMNeoAuth } from '../../ESPRMNeoAuth.js';
+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 { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+import { signupIdentityFromUsername } from '../../utils/authUtils.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("SendSignUpCode");
+/**
+ * Builds the signup request body from username, password, and optional attributes.
+ * Explicit `userAttributes` override the username-derived email / phone fields.
+ */
+function toSignupRequest(username, password, userAttributes) {
+    const attrs = userAttributes ?? {};
+    const identity = signupIdentityFromUsername(username);
+    return {
+        password,
+        email: attrs.email ?? identity.email,
+        phone_number: attrs.phone_number ?? identity.phone_number,
+    };
+}
+ESPRMNeoAuth.prototype.sendSignUpCode = async function (username, password, userAttributes) {
+    try {
+        const requestBody = toSignupRequest(username, password, userAttributes);
+        const api = ESPRMNeoAPIManager.getInstance();
+        logger.debug(`sendSignUpCode → POST ${APIPathV1.USER_AUTH_SIGNUP}`);
+        const apiResponse = await api.postUserApi(APIPathV1.USER_AUTH_SIGNUP, requestBody);
+        return normalizeApiResponse(apiResponse);
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError)
+            throw err;
+        const message = err instanceof Error ? err.message : authErrorMessages.SIGNUP_FAILED;
+        logger.debug("sendSignUpCode → Error:", message);
+        throw new ESPAuthError(AuthErrorCodes.SIGNUP_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=SendSignUpCode.js.map

package/dist/esm/methods/ESPRMNeoAuth/SendSignUpCode.js.map

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

package/dist/esm/methods/ESPRMNeoAuth/SetNewPassword.js

@@ -0,0 +1,39 @@
+import { ESPRMNeoAuth } from '../../ESPRMNeoAuth.js';
+import { ESPRMNeoAPIManager } from '../../services/ESPRMNeoAPIManager.js';
+import { APIPathV1, AuthSuccessMessages, AuthErrorCodes } from '../../utils/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.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("SetNewPassword");
+ESPRMNeoAuth.prototype.setNewPassword = async function (username, newPassword, verificationCode) {
+    try {
+        const requestBody = {
+            username,
+            code: verificationCode,
+            new_password: newPassword,
+        };
+        const api = ESPRMNeoAPIManager.getInstance();
+        logger.debug(`setNewPassword → POST ${APIPathV1.USER_AUTH_PASSWORD_RECOVERY_CONFIRMATION}`);
+        const apiResponse = await api.postUserApi(APIPathV1.USER_AUTH_PASSWORD_RECOVERY_CONFIRMATION, requestBody);
+        return normalizeApiResponse(apiResponse, {
+            message: AuthSuccessMessages.PASSWORD_RESET,
+        });
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError)
+            throw err;
+        const message = err instanceof Error
+            ? err.message
+            : authErrorMessages.PASSWORD_RESET_FAILED;
+        logger.debug("setNewPassword → Error:", message);
+        throw new ESPAuthError(AuthErrorCodes.PASSWORD_RESET_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=SetNewPassword.js.map

package/dist/esm/methods/ESPRMNeoAuth/SetNewPassword.js.map

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

package/dist/esm/methods/ESPRMNeoAutomation/AddAction.js

@@ -0,0 +1,21 @@
+import { ESPRMNeoAutomation } from '../../ESPRMNeoAutomation.js';
+import { APICallValidationErrorCodes } 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
+ */
+ESPRMNeoAutomation.prototype.addAction = async function (target) {
+    if (!target ||
+        !String(target.node ?? "").trim() ||
+        !String(target.path ?? "").trim()) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_ACTION_TARGET);
+    }
+    const nextActions = { targets: [...this.actions.targets, target] };
+    const response = await this.update({ actions: nextActions });
+    this.actions = nextActions;
+    return response;
+};
+//# sourceMappingURL=AddAction.js.map

package/dist/esm/methods/ESPRMNeoAutomation/AddAction.js.map

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

package/dist/esm/methods/ESPRMNeoAutomation/AddCondition.js

@@ -0,0 +1,25 @@
+import { ESPRMNeoAutomation } from '../../ESPRMNeoAutomation.js';
+import { APICallValidationErrorCodes, AutomationSuccessMessages } from '../../utils/constants.js';
+import { ESPAPICallValidationError } from '../../utils/error/ESPAPICallValidationError.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoAutomation.prototype.addCondition = async function (triggerId) {
+    if (!triggerId?.trim()) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_TRIGGER_ID);
+    }
+    if (this.conditions.and.includes(triggerId)) {
+        return normalizeApiResponse(null, {
+            message: AutomationSuccessMessages.CONDITION_ALREADY_ADDED,
+        });
+    }
+    const nextConditions = { and: [...this.conditions.and, triggerId] };
+    const response = await this.update({ conditions: nextConditions });
+    this.conditions = nextConditions;
+    return response;
+};
+//# sourceMappingURL=AddCondition.js.map

package/dist/esm/methods/ESPRMNeoAutomation/AddCondition.js.map

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

package/dist/esm/methods/ESPRMNeoAutomation/Delete.js

@@ -0,0 +1,27 @@
+import { ESPRMNeoAutomation } from '../../ESPRMNeoAutomation.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APIPathV1, AutomationSuccessMessages } from '../../utils/constants.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+import { Logger } from '../../utils/logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("AutomationDelete");
+ESPRMNeoAutomation.prototype.delete = async function () {
+    try {
+        const endpoint = APIPathV1.groupAutomationId(this.groupId, this.id);
+        const api = ESPSigV4APIManager.getInstance();
+        const response = await api.request("DELETE", endpoint);
+        return normalizeApiResponse(response, {
+            message: AutomationSuccessMessages.AUTOMATION_DELETED,
+        });
+    }
+    catch (err) {
+        logger.error("delete failed", err instanceof Error ? err.message : String(err));
+        throw err;
+    }
+};
+//# sourceMappingURL=Delete.js.map

package/dist/esm/methods/ESPRMNeoAutomation/Delete.js.map

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

package/dist/esm/methods/ESPRMNeoAutomation/RemoveAction.js

@@ -0,0 +1,21 @@
+import { ESPRMNeoAutomation } from '../../ESPRMNeoAutomation.js';
+import { APICallValidationErrorCodes } 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
+ */
+ESPRMNeoAutomation.prototype.removeAction = async function (index) {
+    if (index < 0 || index >= this.actions.targets.length) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_ACTION_INDEX);
+    }
+    const nextActions = {
+        targets: this.actions.targets.filter((_, i) => i !== index),
+    };
+    const response = await this.update({ actions: nextActions });
+    this.actions = nextActions;
+    return response;
+};
+//# sourceMappingURL=RemoveAction.js.map

package/dist/esm/methods/ESPRMNeoAutomation/RemoveAction.js.map

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

package/dist/esm/methods/ESPRMNeoAutomation/RemoveCondition.js

@@ -0,0 +1,21 @@
+import { ESPRMNeoAutomation } from '../../ESPRMNeoAutomation.js';
+import { APICallValidationErrorCodes } 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
+ */
+ESPRMNeoAutomation.prototype.removeCondition = async function (triggerId) {
+    if (!triggerId?.trim()) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_TRIGGER_ID);
+    }
+    const nextConditions = {
+        and: this.conditions.and.filter((id) => id !== triggerId),
+    };
+    const response = await this.update({ conditions: nextConditions });
+    this.conditions = nextConditions;
+    return response;
+};
+//# sourceMappingURL=RemoveCondition.js.map

package/dist/esm/methods/ESPRMNeoAutomation/RemoveCondition.js.map

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

package/dist/esm/methods/ESPRMNeoAutomation/Update.js

@@ -0,0 +1,38 @@
+import { ESPRMNeoAutomation } from '../../ESPRMNeoAutomation.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APIPathV1 } from '../../utils/constants.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoAutomation.prototype.update = async function (updates) {
+    if (updates.name !== undefined) {
+        this.name = updates.name;
+    }
+    if (updates.conditions !== undefined) {
+        this.conditions = updates.conditions;
+    }
+    if (updates.actions !== undefined) {
+        this.actions = updates.actions;
+    }
+    if (updates.status !== undefined) {
+        this.status = updates.status;
+    }
+    if (updates.retrigger !== undefined) {
+        this.retrigger = updates.retrigger;
+    }
+    const endpoint = APIPathV1.groupAutomationId(this.groupId, this.id);
+    const api = ESPSigV4APIManager.getInstance();
+    const response = await api.request("PUT", endpoint, {
+        name: this.name,
+        conditions: this.conditions,
+        actions: this.actions,
+        status: this.status,
+        retrigger: this.retrigger,
+    });
+    return normalizeApiResponse(response, { message: "Automation updated successfully" });
+};
+//# sourceMappingURL=Update.js.map

package/dist/esm/methods/ESPRMNeoAutomation/Update.js.map

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

package/dist/esm/methods/ESPRMNeoDevice/GetParams.js

@@ -0,0 +1,32 @@
+import { ESPRMNeoDevice } from '../../ESPRMNeoDevice.js';
+import { delegatedTransportHandler } from '../../services/ESPRMNeoHelpers/DelegatedTransportHandler.js';
+import { applyValuesToParams } from '../../utils/paramValues.js';
+import { readLocalNodeConfig } from '../../utils/nodeUtils.js';
+import { APICallValidationErrorCodes } 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
+ */
+ESPRMNeoDevice.prototype.getParams = async function (options) {
+    const self = this;
+    const useCache = options?.cache ?? true;
+    const node = self._nodeRef.deref();
+    if (!node) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    if (useCache) {
+        const local = await readLocalNodeConfig(node.nodeId);
+        const cachedParams = local?.params;
+        if (cachedParams?.[self.name] !== undefined) {
+            applyValuesToParams(self.params, cachedParams[self.name]);
+        }
+        return self.params;
+    }
+    const allParams = await (delegatedTransportHandler).call(node, (manager) => manager.getParams({ node_id: node.nodeId }, node));
+    applyValuesToParams(self.params, allParams[self.name]);
+    return self.params;
+};
+//# sourceMappingURL=GetParams.js.map

package/dist/esm/methods/ESPRMNeoDevice/GetParams.js.map

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

package/dist/esm/methods/ESPRMNeoDeviceParam/GetLatestTSData.js

@@ -0,0 +1,24 @@
+import { ESPRMNeoDeviceParam } from '../../ESPRMNeoDeviceParam.js';
+import { fetchLatestTSData } from '../../services/ESPRMNeoHelpers/FetchTSData.js';
+import { APICallValidationErrorCodes } from '../../utils/constants.js';
+import { ESPAPICallValidationError } from '../../utils/error/ESPAPICallValidationError.js';
+import { tsParamIdentityFromParam } from '../../utils/tsDataUtils.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoDeviceParam.prototype.getLatestTSData = async function (options) {
+    const node = this._nodeRef.deref();
+    if (!node) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    const { key, dataType } = tsParamIdentityFromParam(this, options);
+    return fetchLatestTSData({
+        groupId: node.groupId,
+        nodeId: node.nodeId,
+        key,
+        dataType});
+};
+//# sourceMappingURL=GetLatestTSData.js.map

package/dist/esm/methods/ESPRMNeoDeviceParam/GetLatestTSData.js.map

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

package/dist/esm/methods/ESPRMNeoDeviceParam/GetRawTSData.js

@@ -0,0 +1,26 @@
+import { ESPRMNeoDeviceParam } from '../../ESPRMNeoDeviceParam.js';
+import { fetchRawTSData } from '../../services/ESPRMNeoHelpers/FetchTSData.js';
+import { APICallValidationErrorCodes } from '../../utils/constants.js';
+import { ESPAPICallValidationError } from '../../utils/error/ESPAPICallValidationError.js';
+import { tsParamIdentityFromParam } from '../../utils/tsDataUtils.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoDeviceParam.prototype.getRawTSData = async function (options) {
+    const node = this._nodeRef.deref();
+    if (!node) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    const { key, dataType } = tsParamIdentityFromParam(this, options);
+    return fetchRawTSData({
+        groupId: node.groupId,
+        nodeId: node.nodeId,
+        key,
+        dataType,
+        options,
+    });
+};
+//# sourceMappingURL=GetRawTSData.js.map

package/dist/esm/methods/ESPRMNeoDeviceParam/GetRawTSData.js.map

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

package/dist/esm/methods/ESPRMNeoDeviceParam/GetTSData.js

@@ -0,0 +1,26 @@
+import { ESPRMNeoDeviceParam } from '../../ESPRMNeoDeviceParam.js';
+import { fetchAggregatedTSData } from '../../services/ESPRMNeoHelpers/FetchTSData.js';
+import { APICallValidationErrorCodes } from '../../utils/constants.js';
+import { ESPAPICallValidationError } from '../../utils/error/ESPAPICallValidationError.js';
+import { tsParamIdentityFromParam } from '../../utils/tsDataUtils.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoDeviceParam.prototype.getTSData = async function (options) {
+    const node = this._nodeRef.deref();
+    if (!node) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    const { key, dataType } = tsParamIdentityFromParam(this, options);
+    return fetchAggregatedTSData({
+        groupId: node.groupId,
+        nodeId: node.nodeId,
+        key,
+        dataType,
+        options,
+    });
+};
+//# sourceMappingURL=GetTSData.js.map

package/dist/esm/methods/ESPRMNeoDeviceParam/GetTSData.js.map

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

package/dist/esm/methods/ESPRMNeoGroup/AddNode.js

@@ -0,0 +1,27 @@
+import { ESPRMNeoGroup, isChildGroup } from '../../ESPRMNeoGroup.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APICallValidationErrorCodes, APIPathV1, GroupSuccessMessages } 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
+ */
+ESPRMNeoGroup.prototype.addNode = async function (nodeId) {
+    if (!isChildGroup(this)) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.ADD_NODE_REQUIRES_NESTED_GROUP);
+    }
+    if (this.nodeIds.includes(nodeId)) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.NODE_ALREADY_IN_GROUP);
+    }
+    const api = ESPSigV4APIManager.getInstance();
+    const path = APIPathV1.groupSubgroupNode(this.parentId, this.groupId, nodeId);
+    const response = await api.request("PUT", path);
+    this.nodeIds.push(nodeId);
+    return normalizeApiResponse(response, {
+        message: GroupSuccessMessages.NODE_ADDED,
+    });
+};
+//# sourceMappingURL=AddNode.js.map

package/dist/esm/methods/ESPRMNeoGroup/AddNode.js.map

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

package/dist/esm/methods/ESPRMNeoGroup/CreateAutomation.js

@@ -0,0 +1,30 @@
+import { ESPRMNeoGroup } from '../../ESPRMNeoGroup.js';
+import { ESPRMNeoAutomation } from '../../ESPRMNeoAutomation.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APICallValidationErrorCodes, APIPathV1 } 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
+ */
+ESPRMNeoGroup.prototype.createAutomation = async function (input) {
+    if (!input.name?.trim()) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_AUTOMATION_NAME);
+    }
+    if (!input.conditions) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_AUTOMATION_CONDITIONS);
+    }
+    if (!input.actions) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_AUTOMATION_ACTIONS);
+    }
+    const endpoint = APIPathV1.groupAutomation(this.groupId);
+    const api = ESPSigV4APIManager.getInstance();
+    // Strip any local `id` before sending — the server mints the id on creation.
+    const { id: _dropId, ...payload } = input;
+    const response = await api.post(endpoint, payload);
+    const createdItem = { ...payload, id: response.automation_id };
+    return new ESPRMNeoAutomation(createdItem, this);
+};
+//# sourceMappingURL=CreateAutomation.js.map

package/dist/esm/methods/ESPRMNeoGroup/CreateAutomation.js.map

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

package/dist/esm/methods/ESPRMNeoGroup/CreateSchedule.js

@@ -0,0 +1,52 @@
+import { ESPRMNeoGroup } from '../../ESPRMNeoGroup.js';
+import { APICallValidationErrorCodes, ScheduleErrorMessages } from '../../utils/constants.js';
+import { ESPAPICallValidationError } from '../../utils/error/ESPAPICallValidationError.js';
+import { Logger } from '../../utils/logger.js';
+import { concurrentFetchPool } from '../../utils/mapLimit.js';
+import { ScheduleValidator } from '../../utils/validator/ScheduleValidator.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("CreateSchedule");
+/** Max concurrent per-node schedule writes when applying a batch on a group. */
+const CREATE_SCHEDULE_CONCURRENCY = 5;
+ESPRMNeoGroup.prototype.createSchedule = async function (nodeSchedules) {
+    ScheduleValidator.validateNodeSchedules(nodeSchedules);
+    const nodes = await this.getNodes();
+    const nodeMap = new Map(nodes.map((node) => [node.nodeId, node]));
+    // Pre-flight: fail fast if any requested nodeId is not part of this group.
+    // Input validation should stop the batch before any writes happen — a
+    // partial write from a bad-input case is worse than no write at all.
+    const missing = nodeSchedules
+        .map(({ nodeId }) => nodeId)
+        .filter((id) => !nodeMap.has(id));
+    if (missing.length > 0) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.SCHEDULE_NODE_NOT_FOUND);
+    }
+    const results = new Array(nodeSchedules.length);
+    const failures = [];
+    await concurrentFetchPool(CREATE_SCHEDULE_CONCURRENCY, nodeSchedules.map((entry, index) => ({ entry, index })), async ({ entry, index }) => {
+        const { nodeId, schedules } = entry;
+        try {
+            results[index] = await nodeMap.get(nodeId).createSchedule(schedules);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failures.push({ nodeId, error: message });
+            logger.error("Failed to create schedules for node", {
+                groupId: this.groupId,
+                nodeId,
+                error: message,
+            });
+        }
+    });
+    if (failures.length > 0) {
+        const summary = failures.map((f) => `${f.nodeId}: ${f.error}`).join("; ");
+        throw new Error(ScheduleErrorMessages.CREATE_FAILED(failures.length, nodeSchedules.length, summary));
+    }
+    return results.flat();
+};
+//# sourceMappingURL=CreateSchedule.js.map

package/dist/esm/methods/ESPRMNeoGroup/CreateSchedule.js.map

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

package/dist/esm/methods/ESPRMNeoGroup/CreateSubGroup.js

@@ -0,0 +1,37 @@
+import { ESPRMNeoGroup } from '../../ESPRMNeoGroup.js';
+import { APICallValidationErrorCodes, APIPathV1 } from '../../utils/constants.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { ESPAPICallValidationError } from '../../utils/error/ESPAPICallValidationError.js';
+import { Logger } from '../../utils/logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("CreateSubGroup");
+ESPRMNeoGroup.prototype.createSubGroup = async function (name) {
+    if (!name?.trim()) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_GROUP_NAME);
+    }
+    try {
+        const api = ESPSigV4APIManager.getInstance();
+        const path = APIPathV1.groupSubgroups(this.groupId);
+        const response = await api.request("POST", path, {
+            subgroup_name: name,
+        });
+        const newChild = new ESPRMNeoGroup({
+            groupId: response.subgroup_id,
+            groupName: name,
+            parentId: this.groupId,
+            nodeIds: [],
+        });
+        this.subgroups.push(newChild);
+        return newChild;
+    }
+    catch (error) {
+        logger.error("createSubGroup failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=CreateSubGroup.js.map

package/dist/esm/methods/ESPRMNeoGroup/CreateSubGroup.js.map

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

package/dist/esm/methods/ESPRMNeoGroup/Delete.js

@@ -0,0 +1,28 @@
+import { ESPRMNeoGroup } from '../../ESPRMNeoGroup.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APIPathV1 } from '../../utils/constants.js';
+import { resolveGroupPath } from '../../utils/groupUtils.js';
+import { Logger } from '../../utils/logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("GroupDelete");
+ESPRMNeoGroup.prototype.delete = async function () {
+    try {
+        const api = ESPSigV4APIManager.getInstance();
+        const path = resolveGroupPath(this, APIPathV1.group, APIPathV1.groupSubgroup);
+        const response = await api.request("DELETE", path);
+        return normalizeApiResponse(response, {
+            message: "Group deleted successfully",
+        });
+    }
+    catch (error) {
+        logger.error("delete failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=Delete.js.map