@espressif/rainmaker-neo-base-sdk 1.0.0

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

@@ -0,0 +1,27 @@
+'use strict';
+
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoAutomation.ESPRMNeoAutomation.prototype.addCondition = async function (triggerId) {
+    if (!triggerId?.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_TRIGGER_ID);
+    }
+    if (this.conditions.and.includes(triggerId)) {
+        return normalizeApiResponse.normalizeApiResponse(null, {
+            message: constants.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/cjs/methods/ESPRMNeoAutomation/AddCondition.js.map

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoAutomation.ESPRMNeoAutomation.prototype.removeAction = async function (index) {
+    if (index < 0 || index >= this.actions.targets.length) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.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/cjs/methods/ESPRMNeoAutomation/RemoveAction.js.map

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

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoAutomation.ESPRMNeoAutomation.prototype.removeCondition = async function (triggerId) {
+    if (!triggerId?.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.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/cjs/methods/ESPRMNeoAutomation/RemoveCondition.js.map

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

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

@@ -0,0 +1,40 @@
+'use strict';
+
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoAutomation.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 = constants.APIPathV1.groupAutomationId(this.groupId, this.id);
+    const api = ESPSigV4APIManager.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.normalizeApiResponse(response, { message: "Automation updated successfully" });
+};
+//# sourceMappingURL=Update.js.map

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

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

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

@@ -0,0 +1,34 @@
+'use strict';
+
+var ESPRMNeoDevice = require('../../ESPRMNeoDevice.js');
+var DelegatedTransportHandler = require('../../services/ESPRMNeoHelpers/DelegatedTransportHandler.js');
+var paramValues = require('../../utils/paramValues.js');
+var nodeUtils = require('../../utils/nodeUtils.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoDevice.ESPRMNeoDevice.prototype.getParams = async function (options) {
+    const self = this;
+    const useCache = options?.cache ?? true;
+    const node = self._nodeRef.deref();
+    if (!node) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    if (useCache) {
+        const local = await nodeUtils.readLocalNodeConfig(node.nodeId);
+        const cachedParams = local?.params;
+        if (cachedParams?.[self.name] !== undefined) {
+            paramValues.applyValuesToParams(self.params, cachedParams[self.name]);
+        }
+        return self.params;
+    }
+    const allParams = await (DelegatedTransportHandler.delegatedTransportHandler).call(node, (manager) => manager.getParams({ node_id: node.nodeId }, node));
+    paramValues.applyValuesToParams(self.params, allParams[self.name]);
+    return self.params;
+};
+//# sourceMappingURL=GetParams.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.addNode = async function (nodeId) {
+    if (!ESPRMNeoGroup.isChildGroup(this)) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.ADD_NODE_REQUIRES_NESTED_GROUP);
+    }
+    if (this.nodeIds.includes(nodeId)) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.NODE_ALREADY_IN_GROUP);
+    }
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const path = constants.APIPathV1.groupSubgroupNode(this.parentId, this.groupId, nodeId);
+    const response = await api.request("PUT", path);
+    this.nodeIds.push(nodeId);
+    return normalizeApiResponse.normalizeApiResponse(response, {
+        message: constants.GroupSuccessMessages.NODE_ADDED,
+    });
+};
+//# sourceMappingURL=AddNode.js.map

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

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

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.createAutomation = async function (input) {
+    if (!input.name?.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_AUTOMATION_NAME);
+    }
+    if (!input.conditions) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_AUTOMATION_CONDITIONS);
+    }
+    if (!input.actions) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_AUTOMATION_ACTIONS);
+    }
+    const endpoint = constants.APIPathV1.groupAutomation(this.groupId);
+    const api = ESPSigV4APIManager.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.ESPRMNeoAutomation(createdItem, this);
+};
+//# sourceMappingURL=CreateAutomation.js.map

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

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

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

@@ -0,0 +1,54 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+var logger$1 = require('../../utils/logger.js');
+var mapLimit = require('../../utils/mapLimit.js');
+var ScheduleValidator = require('../../utils/validator/ScheduleValidator.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("CreateSchedule");
+/** Max concurrent per-node schedule writes when applying a batch on a group. */
+const CREATE_SCHEDULE_CONCURRENCY = 5;
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.createSchedule = async function (nodeSchedules) {
+    ScheduleValidator.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.ESPAPICallValidationError(constants.APICallValidationErrorCodes.SCHEDULE_NODE_NOT_FOUND);
+    }
+    const results = new Array(nodeSchedules.length);
+    const failures = [];
+    await mapLimit.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(constants.ScheduleErrorMessages.CREATE_FAILED(failures.length, nodeSchedules.length, summary));
+    }
+    return results.flat();
+};
+//# sourceMappingURL=CreateSchedule.js.map

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

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

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

@@ -0,0 +1,39 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var constants = require('../../utils/constants.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+var logger$1 = require('../../utils/logger.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("CreateSubGroup");
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.createSubGroup = async function (name) {
+    if (!name?.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_GROUP_NAME);
+    }
+    try {
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const path = constants.APIPathV1.groupSubgroups(this.groupId);
+        const response = await api.request("POST", path, {
+            subgroup_name: name,
+        });
+        const newChild = new ESPRMNeoGroup.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/cjs/methods/ESPRMNeoGroup/CreateSubGroup.js.map

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

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

@@ -0,0 +1,30 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var groupUtils = require('../../utils/groupUtils.js');
+var logger$1 = require('../../utils/logger.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("GroupDelete");
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.delete = async function () {
+    try {
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const path = groupUtils.resolveGroupPath(this, constants.APIPathV1.group, constants.APIPathV1.groupSubgroup);
+        const response = await api.request("DELETE", path);
+        return normalizeApiResponse.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

package/dist/cjs/methods/ESPRMNeoGroup/Delete.js.map

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

package/dist/cjs/methods/ESPRMNeoGroup/DeleteAllSchedules.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var logger$1 = require('../../utils/logger.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("DeleteAllSchedules");
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.deleteAllSchedules = async function () {
+    const nodes = await this.getNodes({ cache: false });
+    const settled = await Promise.allSettled(nodes.map((node) => node.removeAllSchedules()));
+    const failures = [];
+    settled.forEach((result, index) => {
+        if (result.status === "rejected") {
+            const message = result.reason instanceof Error
+                ? result.reason.message
+                : String(result.reason);
+            failures.push({ nodeId: nodes[index].nodeId, error: message });
+            logger.error(`Failed to delete schedules for node ${nodes[index].nodeId}`, message);
+        }
+    });
+    if (failures.length > 0) {
+        const summary = failures.map((f) => `${f.nodeId}: ${f.error}`).join("; ");
+        throw new Error(`Failed to delete schedules on ${failures.length} of ${nodes.length} nodes — ${summary}`);
+    }
+    return normalizeApiResponse.normalizeApiResponse(null, {
+        message: `All schedules deleted (${nodes.length} nodes)`,
+    });
+};
+//# sourceMappingURL=DeleteAllSchedules.js.map

package/dist/cjs/methods/ESPRMNeoGroup/DeleteAllSchedules.js.map

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

package/dist/cjs/methods/ESPRMNeoGroup/GetAutomation.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.getAutomation = async function (automationId) {
+    const endpoint = constants.APIPathV1.groupAutomationId(this.groupId, automationId);
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const response = await api.get(endpoint);
+    return new ESPRMNeoAutomation.ESPRMNeoAutomation(response, this);
+};
+//# sourceMappingURL=GetAutomation.js.map

package/dist/cjs/methods/ESPRMNeoGroup/GetAutomation.js.map

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

package/dist/cjs/methods/ESPRMNeoGroup/GetAutomations.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var logger$1 = require('../../utils/logger.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("GetAutomations");
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.getAutomations = async function () {
+    try {
+        const endpoint = constants.APIPathV1.groupAutomation(this.groupId);
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const response = await api.get(endpoint);
+        const raws = response.automations ?? [];
+        return raws.map((raw) => new ESPRMNeoAutomation.ESPRMNeoAutomation(raw, this));
+    }
+    catch (error) {
+        logger.error("getAutomations failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=GetAutomations.js.map

package/dist/cjs/methods/ESPRMNeoGroup/GetAutomations.js.map

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

package/dist/cjs/methods/ESPRMNeoGroup/GetNode.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+var nodeUtils = require('../../utils/nodeUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.getNode = async function (nodeId, options) {
+    const useCache = options?.cache ?? true;
+    const local = useCache ? await nodeUtils.readLocalNodeConfig(nodeId) : null;
+    const config = local ?? (await nodeUtils.fetchCloudNodeConfig(this, nodeId));
+    if (!config) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.NODE_CONFIG_UNRESOLVED);
+    }
+    return nodeUtils.toNeoNode(this, config, nodeId);
+};
+//# sourceMappingURL=GetNode.js.map

package/dist/cjs/methods/ESPRMNeoGroup/GetNode.js.map

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