@espressif/rainmaker-neo-base-sdk 1.0.0

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var mapLimit = require('../../utils/mapLimit.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Max concurrent `getNode` calls while loading a group’s node list. */
+const GET_NODES_CONCURRENCY = 5;
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.getNodes = async function (options) {
+    const ids = this.nodeIds;
+    if (!ids.length)
+        return [];
+    const nodes = await mapLimit.concurrentFetchPool(GET_NODES_CONCURRENCY, ids, (nodeId) => this.getNode(nodeId, options).catch(() => null));
+    return nodes.filter((node) => node != null);
+};
+//# sourceMappingURL=GetNodes.js.map

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

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

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

@@ -0,0 +1,42 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPRMNeoSchedule = require('../../ESPRMNeoSchedule.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var logger$1 = require('../../utils/logger.js');
+var constants = require('../../utils/constants.js');
+var mapLimit = require('../../utils/mapLimit.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("GetSchedules");
+/** Max concurrent per-node schedule fetches while aggregating a group. */
+const GET_SCHEDULES_CONCURRENCY = 5;
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.getSchedules = async function () {
+    if (!this.nodeIds.length)
+        return [];
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const results = await mapLimit.concurrentFetchPool(GET_SCHEDULES_CONCURRENCY, this.nodeIds, async (nodeId) => {
+        try {
+            const endpoint = constants.APIPathV1.groupNodeSchedules(this.groupId, nodeId);
+            const response = await api.get(endpoint);
+            const schedulesArray = Array.isArray(response?.schedules)
+                ? response.schedules
+                : [];
+            return schedulesArray.map((schedule) => new ESPRMNeoSchedule.ESPRMNeoSchedule(schedule, nodeId, this.groupId, schedule.id, undefined, this));
+        }
+        catch (error) {
+            logger.error("Failed to get schedules for node", {
+                groupId: this.groupId,
+                nodeId,
+                error,
+            });
+            return [];
+        }
+    });
+    return results.flat();
+};
+//# sourceMappingURL=GetSchedules.js.map

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

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

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

@@ -0,0 +1,33 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var groupUtils = require('../../utils/groupUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Maps a wire-format group user entry to the public {@link GroupUser} shape.
+ */
+function mapGroupUser(user) {
+    return {
+        userId: user.user_id,
+        email: user.email,
+        phoneNumber: user.phone_number,
+        accessType: user.access_type,
+        subgroups: user.subgroups,
+    };
+}
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.getSharingInfo = async function () {
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const path = groupUtils.resolveGroupPath(this, constants.APIPathV1.groupUsers, constants.APIPathV1.groupSubgroupUsers);
+    const response = await api.request(constants.HTTPMethods.GET, path);
+    return {
+        users: (response.users ?? []).map(mapGroupUser),
+    };
+};
+//# sourceMappingURL=GetSharingInfo.js.map

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

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

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

@@ -0,0 +1,22 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var groupUtils = require('../../utils/groupUtils.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.leave = async function () {
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const path = groupUtils.resolveGroupPath(this, constants.APIPathV1.groupUser, constants.APIPathV1.groupSubgroupUser, constants.GroupUserAliases.CURRENT);
+    const response = await api.request(constants.HTTPMethods.DELETE, path);
+    return normalizeApiResponse.normalizeApiResponse(response, {
+        message: constants.GroupSuccessMessages.LEFT_GROUP,
+    });
+};
+//# sourceMappingURL=Leave.js.map

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

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

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

@@ -0,0 +1,29 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+var groupUtils = require('../../utils/groupUtils.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.removeMember = async function (userId) {
+    if (!userId?.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_USER_ID);
+    }
+    if (userId === constants.GroupUserAliases.CURRENT) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.USE_LEAVE_FOR_CURRENT_USER);
+    }
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const path = groupUtils.resolveGroupPath(this, constants.APIPathV1.groupUser, constants.APIPathV1.groupSubgroupUser, userId);
+    const response = await api.request(constants.HTTPMethods.DELETE, path);
+    return normalizeApiResponse.normalizeApiResponse(response, {
+        message: constants.GroupSuccessMessages.MEMBER_REMOVED,
+    });
+};
+//# sourceMappingURL=RemoveMember.js.map

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

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

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

@@ -0,0 +1,26 @@
+'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 nodeUtils = require('../../utils/nodeUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.removeNode = async function (nodeId) {
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const path = groupUtils.resolveGroupPath(this, constants.APIPathV1.groupNode, constants.APIPathV1.groupSubgroupNode, nodeId);
+    const response = await api.request(constants.HTTPMethods.DELETE, path);
+    this.nodeIds = this.nodeIds.filter((id) => id !== nodeId);
+    // Safe even when the node remains in another group.
+    await nodeUtils.clearLocalNodeCache(nodeId);
+    return normalizeApiResponse.normalizeApiResponse(response, {
+        message: constants.GroupSuccessMessages.NODE_REMOVED,
+    });
+};
+//# sourceMappingURL=RemoveNode.js.map

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

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

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

@@ -0,0 +1,29 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var NodeMQTTOrchestrator = require('../../services/NodeMQTTOrchestrator.js');
+var constants = require('../../utils/constants.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.setParams = async function (params, options) {
+    let groupId;
+    let subgroupId;
+    if (ESPRMNeoGroup.isChildGroup(this)) {
+        groupId = this.parentId;
+        subgroupId = this.groupId;
+    }
+    else {
+        groupId = this.groupId;
+        subgroupId = options?.subgroupId;
+    }
+    await NodeMQTTOrchestrator.NodeMQTTOrchestrator.setGroupParams(groupId, params, subgroupId);
+    return normalizeApiResponse.normalizeApiResponse(null, {
+        message: constants.GroupSuccessMessages.PARAMS_SET,
+    });
+};
+//# sourceMappingURL=SetParams.js.map

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

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

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

@@ -0,0 +1,34 @@
+'use strict';
+
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.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("Share");
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.share = async function (options) {
+    if (!options.username?.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_USERNAME);
+    }
+    try {
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const requestData = {
+            username: options.username,
+            access_type: options.accessType,
+        };
+        const path = groupUtils.resolveGroupPath(this, constants.APIPathV1.groupSharingRequests, constants.APIPathV1.groupSubgroupSharingRequests);
+        return api.request("POST", path, requestData);
+    }
+    catch (error) {
+        logger.error("share failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=Share.js.map

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

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

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

@@ -0,0 +1,37 @@
+'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');
+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("UpdateName");
+ESPRMNeoGroup.ESPRMNeoGroup.prototype.updateName = async function (newName) {
+    const trimmedName = newName?.trim();
+    if (!trimmedName) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_GROUP_NAME);
+    }
+    try {
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const path = groupUtils.resolveGroupPath(this, constants.APIPathV1.group, constants.APIPathV1.groupSubgroup);
+        const body = groupUtils.buildGroupNameBody(this, trimmedName);
+        const response = await api.patch(path, body);
+        this.groupName = trimmedName;
+        return normalizeApiResponse.normalizeApiResponse(response, {
+            message: constants.GroupSuccessMessages.NAME_UPDATED,
+        });
+    }
+    catch (error) {
+        logger.error("updateName failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=UpdateName.js.map

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

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

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

@@ -0,0 +1,47 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var ESPRMNeoSchedule = require('../../ESPRMNeoSchedule.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
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.createSchedule = async function (schedules) {
+    if (Array.isArray(schedules)) {
+        const endpoint = constants.APIPathV1.groupNodeSchedules(this.groupId, this.nodeId);
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        await api.put(endpoint, {
+            schedules,
+        });
+        return schedules.map((schedule) => new ESPRMNeoSchedule.ESPRMNeoSchedule(schedule, this.nodeId, this.groupId, schedule.id, this));
+    }
+    const schedule = schedules;
+    if (!schedule || typeof schedule !== "object") {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_SCHEDULE);
+    }
+    if (!schedule.id || typeof schedule.id !== "string" || !schedule.id.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_SCHEDULE_ID);
+    }
+    // Schedules API is replace-all: fetch the current list, append, PUT the merged
+    // set. No cache — see scheduleUtils.ts for the rationale.
+    const existing = await this.getSchedules();
+    if (existing.some((s) => s.id === schedule.id)) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.SCHEDULE_ALREADY_EXISTS);
+    }
+    const existingItems = existing.map((s) => ({
+        id: s.id,
+        name: s.name,
+        enabled: s.enabled,
+        triggers: s.triggers,
+        action: s.action,
+        validity: s.validity,
+    }));
+    const created = await this.createSchedule([...existingItems, schedule]);
+    return created.find((s) => s.id === schedule.id);
+};
+//# sourceMappingURL=CreateSchedule.js.map

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

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

package/dist/cjs/methods/ESPRMNeoNode/CreateTrigger.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var ESPRMNeoTrigger = require('../../ESPRMNeoTrigger.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
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.createTrigger = async function (triggers) {
+    if (Array.isArray(triggers)) {
+        const endpoint = constants.APIPathV1.groupNodeTriggers(this.groupId, this.nodeId);
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        await api.put(endpoint, {
+            triggers,
+        });
+        return triggers.map((trigger) => new ESPRMNeoTrigger.ESPRMNeoTrigger(trigger, this));
+    }
+    const trigger = triggers;
+    if (!trigger || typeof trigger !== "object") {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_TRIGGER);
+    }
+    if (!trigger.id || typeof trigger.id !== "string" || !trigger.id.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_TRIGGER_ID);
+    }
+    const existing = await this.getTriggers();
+    if (existing.some((t) => t.id === trigger.id)) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.TRIGGER_ALREADY_EXISTS);
+    }
+    const created = await this.createTrigger([
+        ...existing.map((t) => t.toTriggerItem()),
+        trigger,
+    ]);
+    return created.find((t) => t.id === trigger.id);
+};
+//# sourceMappingURL=CreateTrigger.js.map

package/dist/cjs/methods/ESPRMNeoNode/CreateTrigger.js.map

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

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

@@ -0,0 +1,31 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var nodeUtils = require('../../utils/nodeUtils.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("NodeDelete");
+ESPRMNeoNode.ESPRMNeoNode.prototype.delete = async function () {
+    try {
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const path = constants.APIPathV1.groupNode(this.groupId, this.nodeId);
+        const response = await api.request(constants.HTTPMethods.DELETE, path);
+        await nodeUtils.clearLocalNodeCache(this.nodeId);
+        return normalizeApiResponse.normalizeApiResponse(response, {
+            message: constants.NodeSuccessMessages.NODE_DELETED,
+        });
+    }
+    catch (error) {
+        logger.error("delete failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=Delete.js.map

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

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

package/dist/cjs/methods/ESPRMNeoNode/GetConfig.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.getConfig = function () {
+    return this.config;
+};
+//# sourceMappingURL=GetConfig.js.map

package/dist/cjs/methods/ESPRMNeoNode/GetConfig.js.map

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

package/dist/cjs/methods/ESPRMNeoNode/GetCustomParamLatestTSData.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var FetchTSData = require('../../services/ESPRMNeoHelpers/FetchTSData.js');
+var tsDataUtils = require('../../utils/tsDataUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.getCustomParamLatestTSData = async function (deviceName, paramName, options) {
+    const { key, dataType } = tsDataUtils.resolveTSParamIdentity(this, deviceName, paramName, options);
+    return FetchTSData.fetchLatestTSData({
+        groupId: this.groupId,
+        nodeId: this.nodeId,
+        key,
+        dataType});
+};
+//# sourceMappingURL=GetCustomParamLatestTSData.js.map

package/dist/cjs/methods/ESPRMNeoNode/GetCustomParamLatestTSData.js.map

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

package/dist/cjs/methods/ESPRMNeoNode/GetCustomParamRawTSData.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var FetchTSData = require('../../services/ESPRMNeoHelpers/FetchTSData.js');
+var tsDataUtils = require('../../utils/tsDataUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.getCustomParamRawTSData = async function (deviceName, paramName, options) {
+    const { key, dataType } = tsDataUtils.resolveTSParamIdentity(this, deviceName, paramName, options);
+    return FetchTSData.fetchRawTSData({
+        groupId: this.groupId,
+        nodeId: this.nodeId,
+        key,
+        dataType,
+        options,
+    });
+};
+//# sourceMappingURL=GetCustomParamRawTSData.js.map

package/dist/cjs/methods/ESPRMNeoNode/GetCustomParamRawTSData.js.map

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

package/dist/cjs/methods/ESPRMNeoNode/GetCustomParamTSData.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var FetchTSData = require('../../services/ESPRMNeoHelpers/FetchTSData.js');
+var tsDataUtils = require('../../utils/tsDataUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.getCustomParamTSData = async function (deviceName, paramName, options) {
+    const { key, dataType } = tsDataUtils.resolveTSParamIdentity(this, deviceName, paramName, options);
+    return FetchTSData.fetchAggregatedTSData({
+        groupId: this.groupId,
+        nodeId: this.nodeId,
+        key,
+        dataType,
+        options,
+    });
+};
+//# sourceMappingURL=GetCustomParamTSData.js.map

package/dist/cjs/methods/ESPRMNeoNode/GetCustomParamTSData.js.map

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

package/dist/cjs/methods/ESPRMNeoNode/GetSchedules.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var ESPRMNeoSchedule = require('../../ESPRMNeoSchedule.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
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.getSchedules = async function () {
+    const endpoint = constants.APIPathV1.groupNodeSchedules(this.groupId, this.nodeId);
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    const response = await api.get(endpoint);
+    const items = (Array.isArray(response?.schedules)
+        ? response.schedules
+        : []);
+    return items.map((schedule) => new ESPRMNeoSchedule.ESPRMNeoSchedule(schedule, this.nodeId, this.groupId, schedule.id, this));
+};
+//# sourceMappingURL=GetSchedules.js.map

package/dist/cjs/methods/ESPRMNeoNode/GetSchedules.js.map

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

package/dist/cjs/methods/ESPRMNeoNode/GetTriggers.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var ESPRMNeoTrigger = require('../../ESPRMNeoTrigger.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("GetTriggers");
+ESPRMNeoNode.ESPRMNeoNode.prototype.getTriggers = async function () {
+    try {
+        const endpoint = constants.APIPathV1.groupNodeTriggers(this.groupId, this.nodeId);
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const response = await api.get(endpoint);
+        const triggers = Array.isArray(response?.triggers) ? response.triggers : [];
+        return triggers.map((trigger) => new ESPRMNeoTrigger.ESPRMNeoTrigger(trigger, this));
+    }
+    catch (err) {
+        logger.error(constants.TriggerErrorMessages.GET_FAILED, err instanceof Error ? err.message : String(err));
+        throw err;
+    }
+};
+//# sourceMappingURL=GetTriggers.js.map

package/dist/cjs/methods/ESPRMNeoNode/GetTriggers.js.map

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

package/dist/cjs/methods/ESPRMNeoNode/RemoveAllSchedules.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var ESPSigV4APIManager = require('../../services/ESPSigV4APIManager.js');
+var constants = require('../../utils/constants.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.removeAllSchedules =
+    async function () {
+        const endpoint = constants.APIPathV1.groupNodeSchedules(this.groupId, this.nodeId);
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const response = await api.delete(endpoint);
+        return normalizeApiResponse.normalizeApiResponse(response, {
+            message: constants.ScheduleSuccessMessages.ALL_DELETED,
+        });
+    };
+//# sourceMappingURL=RemoveAllSchedules.js.map

package/dist/cjs/methods/ESPRMNeoNode/RemoveAllSchedules.js.map

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