@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/cjs/methods/ESPRMNeoNode/RemoveAllTriggers.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.removeAllTriggers =
+    async function () {
+        const endpoint = constants.APIPathV1.groupNodeTriggers(this.groupId, this.nodeId);
+        const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+        const response = await api.delete(endpoint);
+        return normalizeApiResponse.normalizeApiResponse(response, {
+            message: constants.TriggerSuccessMessages.ALL_DELETED,
+        });
+    };
+//# sourceMappingURL=RemoveAllTriggers.js.map

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

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

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

@@ -0,0 +1,35 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.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
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.removeSchedule = async function (scheduleId) {
+    if (!scheduleId || typeof scheduleId !== "string" || !scheduleId.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_SCHEDULE_ID);
+    }
+    const existing = await this.getSchedules();
+    const items = existing.map((s) => ({
+        id: s.id,
+        name: s.name,
+        enabled: s.enabled,
+        triggers: s.triggers,
+        action: s.action,
+        validity: s.validity,
+    }));
+    const filtered = items.filter((item) => item.id !== scheduleId);
+    if (filtered.length === items.length) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.SCHEDULE_NOT_FOUND);
+    }
+    await this.createSchedule(filtered);
+    return normalizeApiResponse.normalizeApiResponse(null, {
+        message: constants.ScheduleSuccessMessages.SET,
+    });
+};
+//# sourceMappingURL=RemoveSchedule.js.map

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

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

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

@@ -0,0 +1,27 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.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
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.removeTrigger = async function (triggerId) {
+    if (!triggerId || typeof triggerId !== "string" || !triggerId.trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_TRIGGER_ID);
+    }
+    const existing = await this.getTriggers();
+    const filtered = existing.filter((t) => t.id !== triggerId);
+    if (filtered.length === existing.length) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.TRIGGER_NOT_FOUND);
+    }
+    await this.createTrigger(filtered.map((t) => t.toTriggerItem()));
+    return normalizeApiResponse.normalizeApiResponse(null, {
+        message: constants.TriggerSuccessMessages.SET,
+    });
+};
+//# sourceMappingURL=RemoveTrigger.js.map

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

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

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var DelegatedTransportHandler = require('../../services/ESPRMNeoHelpers/DelegatedTransportHandler.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.setParams = async function (params) {
+    if (!params || Object.keys(params).length === 0) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_PARAMS);
+    }
+    const payload = { node_id: this.nodeId, payload: params };
+    return (DelegatedTransportHandler.delegatedTransportHandler).call(this, (manager) => manager.setParam(payload, this));
+};
+//# sourceMappingURL=SetParams.js.map

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

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

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

@@ -0,0 +1,25 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var ESPRMNeoBase = require('../../ESPRMNeoBase.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoNode.ESPRMNeoNode.prototype.setSubscriptionChannelOrder = function (channelIds) {
+    if (!this.subscriptionConfig) {
+        this.subscriptionConfig = {};
+    }
+    this.subscriptionConfig.channelOrder = channelIds;
+};
+ESPRMNeoNode.ESPRMNeoNode.prototype.getSubscriptionChannelOrder = function () {
+    return ESPRMNeoBase.ESPRMNeoBase.subscriptionManager.getEffectiveChannelOrder(this);
+};
+ESPRMNeoNode.ESPRMNeoNode.prototype.clearSubscriptionChannelOrder = function () {
+    if (this.subscriptionConfig) {
+        delete this.subscriptionConfig.channelOrder;
+    }
+};
+//# sourceMappingURL=SubscriptionConfig.js.map

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

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

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

@@ -0,0 +1,30 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.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("NodeSync");
+ESPRMNeoNode.ESPRMNeoNode.prototype.sync = async function () {
+    try {
+        const config = await nodeUtils.fetchCloudNodeConfigForNode(this.groupId, this.nodeId);
+        // Apply first so a schema issue surfaces to the caller instead of
+        // poisoning the storage cache for the next cold start.
+        this.applyNodeConfig(config);
+        await nodeUtils.writeLocalNodeConfig(this.nodeId, config);
+        return this;
+    }
+    catch (error) {
+        logger.error("sync failed", {
+            nodeId: this.nodeId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+//# sourceMappingURL=Sync.js.map

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

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

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

@@ -0,0 +1,24 @@
+'use strict';
+
+var ESPRMNeoNode = require('../../ESPRMNeoNode.js');
+var NodeMQTTOrchestrator = require('../../services/NodeMQTTOrchestrator.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("NodeUnsubscribeFromMqttUpdates");
+ESPRMNeoNode.ESPRMNeoNode.prototype.unsubscribeFromMqttUpdates = function () {
+    try {
+        NodeMQTTOrchestrator.NodeMQTTOrchestrator.unregisterNode(this.nodeId);
+    }
+    catch (error) {
+        logger.warn("Failed to unregister node from MQTT orchestrator", {
+            nodeId: this.nodeId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+};
+//# sourceMappingURL=UnsubscribeFromMqttUpdates.js.map

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

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var ESPRMNeoSchedule = require('../../ESPRMNeoSchedule.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
+ */
+ESPRMNeoSchedule.ESPRMNeoSchedule.prototype.delete = async function () {
+    const node = await this.getNode();
+    if (!node) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.SCHEDULE_NODE_NOT_FOUND);
+    }
+    return node.removeSchedule(this.id);
+};
+//# sourceMappingURL=Delete.js.map

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

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

package/dist/cjs/methods/ESPRMNeoSchedule/Enable.js

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

package/dist/cjs/methods/ESPRMNeoSchedule/Enable.js.map

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

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

@@ -0,0 +1,50 @@
+'use strict';
+
+var ESPRMNeoSchedule = require('../../ESPRMNeoSchedule.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var scheduleUtils = require('../../utils/scheduleUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoSchedule.ESPRMNeoSchedule.prototype.update = async function (updates) {
+    const node = await this.getNode();
+    if (!node) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.SCHEDULE_NODE_NOT_FOUND);
+    }
+    const items = await scheduleUtils.getScheduleItemsForNode(node);
+    const index = items.findIndex((item) => item.id === this.id);
+    if (index === -1) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.SCHEDULE_NOT_FOUND);
+    }
+    // Build the intended item WITHOUT touching `this.*`. Only after the PUT
+    // succeeds do we commit the changes to the instance — otherwise a failed
+    // network call leaves the instance in a state that doesn't reflect the
+    // cloud.
+    const updatedItem = {
+        ...scheduleUtils.scheduleToItem(this),
+        ...updates,
+    };
+    items[index] = updatedItem;
+    await node.createSchedule(items);
+    // PUT succeeded — commit the local changes now so subsequent reads reflect
+    // what's actually in the cloud.
+    if (updates.enabled !== undefined)
+        this.enabled = updates.enabled;
+    if (updates.triggers !== undefined)
+        this.triggers = updates.triggers;
+    if (updates.action !== undefined)
+        this.action = updates.action;
+    if (updates.validity !== undefined)
+        this.validity = updates.validity;
+    if (updates.name !== undefined)
+        this.name = updates.name;
+    return normalizeApiResponse.normalizeApiResponse(null, {
+        message: constants.ScheduleSuccessMessages.SET,
+    });
+};
+//# sourceMappingURL=Update.js.map

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

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

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

@@ -0,0 +1,42 @@
+'use strict';
+
+var ESPRMNeoService = require('../../ESPRMNeoService.js');
+var DelegatedTransportHandler = require('../../services/ESPRMNeoHelpers/DelegatedTransportHandler.js');
+var paramValues = require('../../utils/paramValues.js');
+var constants = require('../../utils/constants.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("ServiceGetParams");
+ESPRMNeoService.ESPRMNeoService.prototype.getParams = async function () {
+    logger.debug("getParams called", { service: this.name });
+    const node = this._nodeRef.deref();
+    if (!node) {
+        logger.error("getParams failed: missing node ref", { service: this.name });
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    try {
+        const allParams = await (DelegatedTransportHandler.delegatedTransportHandler).call(node, (manager) => manager.getParams({ node_id: node.nodeId }, node));
+        paramValues.applyValuesToParams(this.params, allParams[this.name]);
+        logger.debug("getParams succeeded", {
+            service: this.name,
+            nodeId: node.nodeId,
+            count: this.params.length,
+        });
+        return this.params;
+    }
+    catch (error) {
+        logger.error("getParams failed", {
+            service: this.name,
+            nodeId: node.nodeId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+//# sourceMappingURL=GetParams.js.map

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

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

package/dist/cjs/methods/ESPRMNeoSharingRequest/Accept.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var ESPRMNeoSharingRequest = require('../../ESPRMNeoSharingRequest.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("SharingRequestAccept");
+ESPRMNeoSharingRequest.ESPRMNeoSharingRequest.prototype.accept =
+    async function () {
+        logger.debug("accept called", {
+            sharingRequestId: this.sharingRequestId,
+        });
+        try {
+            const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+            const endpoint = constants.APIPathV1.sharingRequestAccept(this.sharingRequestId);
+            const response = await api.post(endpoint, {});
+            const result = normalizeApiResponse.normalizeApiResponse(response, {
+                message: constants.SharingSuccessMessages.ACCEPTED,
+            });
+            logger.debug("accept succeeded", {
+                sharingRequestId: this.sharingRequestId,
+            });
+            return result;
+        }
+        catch (err) {
+            logger.error("accept failed", err instanceof Error ? err.message : String(err));
+            throw err;
+        }
+    };
+//# sourceMappingURL=Accept.js.map

package/dist/cjs/methods/ESPRMNeoSharingRequest/Accept.js.map

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

package/dist/cjs/methods/ESPRMNeoSharingRequest/Decline.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var ESPRMNeoSharingRequest = require('../../ESPRMNeoSharingRequest.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("SharingRequestDecline");
+ESPRMNeoSharingRequest.ESPRMNeoSharingRequest.prototype.decline =
+    async function () {
+        logger.debug("decline called", {
+            sharingRequestId: this.sharingRequestId,
+        });
+        try {
+            const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+            const endpoint = constants.APIPathV1.sharingRequestReject(this.sharingRequestId);
+            const response = await api.post(endpoint, {});
+            const result = normalizeApiResponse.normalizeApiResponse(response, {
+                message: constants.SharingSuccessMessages.DECLINED,
+            });
+            logger.debug("decline succeeded", {
+                sharingRequestId: this.sharingRequestId,
+            });
+            return result;
+        }
+        catch (err) {
+            logger.error("decline failed", err instanceof Error ? err.message : String(err));
+            throw err;
+        }
+    };
+//# sourceMappingURL=Decline.js.map

package/dist/cjs/methods/ESPRMNeoSharingRequest/Decline.js.map

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var ESPRMNeoTrigger = require('../../ESPRMNeoTrigger.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
+ */
+ESPRMNeoTrigger.ESPRMNeoTrigger.prototype.delete = async function () {
+    const node = this.getNode();
+    if (!node) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    return node.removeTrigger(this.id);
+};
+//# sourceMappingURL=Delete.js.map

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

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

package/dist/cjs/methods/ESPRMNeoTrigger/Enable.js

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

package/dist/cjs/methods/ESPRMNeoTrigger/Enable.js.map

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

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

@@ -0,0 +1,34 @@
+'use strict';
+
+var ESPRMNeoTrigger = require('../../ESPRMNeoTrigger.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var triggerUtils = require('../../utils/triggerUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoTrigger.ESPRMNeoTrigger.prototype.update = async function (updates) {
+    const node = this.getNode();
+    if (!node) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_NODE_REF);
+    }
+    const items = await triggerUtils.getTriggerItemsForNode(node);
+    const index = items.findIndex((item) => item.id === this.id);
+    if (index === -1) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.TRIGGER_NOT_FOUND);
+    }
+    // Build the merged plain item WITHOUT mutating `this`. Instance fields
+    // are updated only after the server accepts the change (below).
+    items[index] = triggerUtils.mergeTriggerItem(triggerUtils.triggerToItem(this), updates);
+    await node.createTrigger(items);
+    // Server accepted — now reflect the change on the instance.
+    triggerUtils.applyTriggerUpdates(this, updates);
+    return normalizeApiResponse.normalizeApiResponse(null, {
+        message: constants.TriggerSuccessMessages.SET,
+    });
+};
+//# sourceMappingURL=Update.js.map

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

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

package/dist/cjs/methods/ESPRMNeoUser/CreateESPDevice.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var ESPRMNeoUser = require('../../ESPRMNeoUser.js');
+var ESPDevice = require('../../ESPDevice.js');
+var ESPRMNeoBase = require('../../ESPRMNeoBase.js');
+var ESPProvError = require('../../utils/error/ESPProvError.js');
+var constants = require('../../utils/constants.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Creates an ESP device with the given parameters.
+ * @param name - The name of the device.
+ * @param transport - The transport type to use.
+ * @param security - The security type to use (optional).
+ * @param proofOfPossession - The proof of possession string (optional).
+ * @param softAPPassword - The SoftAP password (optional).
+ * @param username - The username (optional).
+ * @returns A promise that resolves to an ESPDevice instance.
+ */
+ESPRMNeoUser.ESPRMNeoUser.prototype.createESPDevice = async function (name, transport, security, proofOfPossession, softAPPassword, username) {
+    const provisionAdapter = ESPRMNeoBase.ESPRMNeoBase.getProvisionAdapter();
+    if (!provisionAdapter) {
+        throw new ESPProvError.ESPProvError(constants.ProvErrorCodes.MISSING_PROV_ADAPTER);
+    }
+    const espDevice = await provisionAdapter.createESPDevice(name, transport, security, proofOfPossession, softAPPassword, username);
+    return new ESPDevice.ESPDevice(espDevice);
+};
+//# sourceMappingURL=CreateESPDevice.js.map

package/dist/cjs/methods/ESPRMNeoUser/CreateESPDevice.js.map

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

package/dist/cjs/methods/ESPRMNeoUser/CreateGroup.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var ESPRMNeoUser = require('../../ESPRMNeoUser.js');
+var ESPRMNeoGroup = require('../../ESPRMNeoGroup.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("CreateGroup");
+ESPRMNeoUser.ESPRMNeoUser.prototype.createGroup = async function (groupName) {
+    logger.debug("createGroup called", { groupName });
+    const api = ESPSigV4APIManager.ESPSigV4APIManager.getInstance();
+    try {
+        const response = await api.post(constants.APIPathV1.GROUPS, { group_name: groupName });
+        logger.debug("createGroup succeeded", {
+            groupId: response.group_id,
+            groupName,
+        });
+        return new ESPRMNeoGroup.ESPRMNeoGroup({
+            groupId: response.group_id,
+            groupName,
+            nodeIds: [],
+            subgroups: [],
+        });
+    }
+    catch (error) {
+        logger.error("createGroup failed", {
+            groupName,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+//# sourceMappingURL=CreateGroup.js.map

package/dist/cjs/methods/ESPRMNeoUser/CreateGroup.js.map

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