@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/esm/ESPRMNeoNode.js.map

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

package/dist/esm/ESPRMNeoSchedule.js

@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents a schedule in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for schedule operations.
+ */
+class ESPRMNeoSchedule {
+    id;
+    name;
+    nodeId;
+    groupId;
+    enabled;
+    triggers;
+    action;
+    validity;
+    node;
+    group;
+    constructor(schedule, nodeId, groupId, id, node, group) {
+        this.enabled = schedule.enabled;
+        this.triggers = schedule.triggers;
+        this.action = schedule.action;
+        this.validity = schedule.validity;
+        this.name = schedule.name;
+        this.nodeId = nodeId;
+        this.groupId = groupId;
+        this.node = node;
+        this.group = group;
+        this.id = id ?? schedule.id ?? ESPRMNeoSchedule.generateId();
+    }
+    /**
+     * Gets the node instance for this schedule.
+     * Returns the direct node reference when set, otherwise resolves it via the
+     * group. Returns `null` when neither path yields a node.
+     */
+    async getNode() {
+        if (this.node) {
+            return this.node;
+        }
+        if (this.group) {
+            try {
+                return await this.group.getNode(this.nodeId);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Generates a schedule id when the caller doesn't provide one.
+     * 4-char base36 tail (a-z, 0-9) — ~1.6M values per node. Duplicate ids
+     * inside a single node's list are still guarded against at create-time by
+     * {@link ESPRMNeoNode.createSchedule}.
+     */
+    static generateId() {
+        return `schedule_${Math.random().toString(36).slice(2, 6)}`;
+    }
+}
+
+export { ESPRMNeoSchedule };
+//# sourceMappingURL=ESPRMNeoSchedule.js.map

package/dist/esm/ESPRMNeoSchedule.js.map

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

package/dist/esm/ESPRMNeoService.js

@@ -0,0 +1,34 @@
+import { ESPRMNeoServiceParam } from './ESPRMNeoServiceParam.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Node-level service (not tied to a single device), e.g. time, local control.
+ * Holds a WeakRef to the parent node for delegating getParams/setParams.
+ */
+class ESPRMNeoService {
+    name;
+    type;
+    params;
+    _nodeRef;
+    constructor(data, nodeRef) {
+        this.name = data.name;
+        this.type = data.type ?? "";
+        this._nodeRef = nodeRef;
+        this.params = (data.params ?? []).map((p) => new ESPRMNeoServiceParam({
+            id: p.id,
+            type: p.type ?? p.id,
+            properties: p.properties ?? [],
+            dataType: p.dataType,
+            serviceName: data.name,
+            bounds: p.bounds,
+            validStrings: p.validStrings,
+        }, nodeRef));
+    }
+}
+
+export { ESPRMNeoService };
+//# sourceMappingURL=ESPRMNeoService.js.map

package/dist/esm/ESPRMNeoService.js.map

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

package/dist/esm/ESPRMNeoServiceParam.js

@@ -0,0 +1,50 @@
+import { delegatedTransportHandler } from './services/ESPRMNeoHelpers/DelegatedTransportHandler.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
+ */
+/**
+ * Service parameter – one parameter of a node service (e.g. timezone).
+ * Holds a WeakRef to the parent node so writes can be dispatched via the best
+ * available transport (see {@link delegatedTransportHandler}).
+ */
+class ESPRMNeoServiceParam {
+    id;
+    type;
+    properties;
+    dataType;
+    serviceName;
+    bounds;
+    validStrings;
+    value;
+    _nodeRef;
+    constructor(data, nodeRef) {
+        this.id = data.id;
+        this.type = data.type ?? data.id;
+        this.properties = data.properties ?? [];
+        this.dataType = data.dataType;
+        this.serviceName = data.serviceName;
+        this.bounds = data.bounds;
+        this.validStrings = data.validStrings;
+        this.value = data.value;
+        this._nodeRef = nodeRef;
+    }
+    setValue(value) {
+        const node = this._nodeRef.deref();
+        if (!node) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_NODE_REF);
+        }
+        const payload = {
+            node_id: node.nodeId,
+            payload: { [this.serviceName]: { [this.id]: value } },
+        };
+        return (delegatedTransportHandler).call(node, (manager) => manager.setParam(payload, node));
+    }
+}
+
+export { ESPRMNeoServiceParam };
+//# sourceMappingURL=ESPRMNeoServiceParam.js.map

package/dist/esm/ESPRMNeoServiceParam.js.map

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

package/dist/esm/ESPRMNeoSharingRequest.js

@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents a sharing request in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for sharing request operations.
+ */
+class ESPRMNeoSharingRequest {
+    sharingRequestId;
+    groupId;
+    subgroupId;
+    accessType;
+    /** Primary user information who sent the share invitation. */
+    primaryUserId;
+    primaryEmail;
+    primaryPhoneNumber;
+    constructor(data) {
+        this.sharingRequestId = data.sharing_request_id;
+        this.groupId = data.group_id;
+        this.subgroupId = data.subgroup_id;
+        this.accessType = data.access_type;
+        this.primaryUserId = data.primary_user_id ?? "";
+        this.primaryEmail = data.primary_email ?? "";
+        this.primaryPhoneNumber = data.primary_phone_number ?? "";
+    }
+}
+
+export { ESPRMNeoSharingRequest };
+//# sourceMappingURL=ESPRMNeoSharingRequest.js.map

package/dist/esm/ESPRMNeoSharingRequest.js.map

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

package/dist/esm/ESPRMNeoTrigger.js

@@ -0,0 +1,48 @@
+import { triggerToItem } from './utils/triggerUtils.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents a trigger in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for trigger operations.
+ * Holds a WeakRef to the parent node, matching the pattern used by
+ * ESPRMNeoDevice / ESPRMNeoService / ESPRMNeoDeviceParam.
+ */
+class ESPRMNeoTrigger {
+    id;
+    nodeId;
+    groupId;
+    type;
+    enabled;
+    path;
+    operator;
+    value;
+    _nodeRef;
+    constructor(data, node) {
+        this.id = data.id;
+        this.type = data.type;
+        this.enabled = data.enabled;
+        this.path = data.path;
+        this.operator = data.operator;
+        this.value = data.value;
+        this.nodeId = node.nodeId;
+        this.groupId = node.groupId;
+        this._nodeRef = new WeakRef(node);
+    }
+    /** Parent node, if the weak reference is still alive. */
+    getNode() {
+        return this._nodeRef.deref();
+    }
+    /**
+     * Converts this trigger to a plain TriggerItem (for building API payloads).
+     */
+    toTriggerItem() {
+        return triggerToItem(this);
+    }
+}
+
+export { ESPRMNeoTrigger };
+//# sourceMappingURL=ESPRMNeoTrigger.js.map

package/dist/esm/ESPRMNeoTrigger.js.map

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

package/dist/esm/ESPRMNeoUser.js

@@ -0,0 +1,80 @@
+import { StorageKeys, TokenErrorCodes } from './utils/constants.js';
+import { ESPRMNeoStorage } from './services/ESPRMNeoStorage/ESPRMNeoStorage.js';
+import { ESPRMNeoAuth } from './ESPRMNeoAuth.js';
+import { ESPTokenError } from './utils/error/ESPTokenError.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("ESPRMNeoUser");
+/**
+ * Represents an authenticated user in the ESP Rainmaker Neo system.
+ * Provides methods for user operations, device management, group management,
+ * and MQTT-based real-time communication.
+ *
+ */
+class ESPRMNeoUser {
+    /** Registered event subscriber callbacks, keyed by event (see {@link subscribe}). */
+    eventCallbacks = {};
+    /**
+     * Per-event teardown handles for backing sources started by {@link subscribe}
+     * (LAN discovery, node-updates bus, custom discovery). Kept so
+     * {@link unsubscribe} / {@link removeAllCallbacks} can stop them.
+     */
+    eventTeardowns = {};
+    /**
+     * Initializes the ESPRMNeoUser instance and persists the tokens to storage.
+     *
+     * @param tokens - Object containing the access token, id token, and refresh token.
+     */
+    constructor(tokens) {
+        ESPRMNeoStorage.setItem(StorageKeys.ACCESSTOKEN, tokens.accessToken);
+        ESPRMNeoStorage.setItem(StorageKeys.IDTOKEN, tokens.idToken);
+        ESPRMNeoStorage.setItem(StorageKeys.REFRESHTOKEN, tokens.refreshToken);
+        logger.debug("User initialized");
+    }
+    /** Reads a token from storage, throwing when the user is not logged in. */
+    static async requireToken(storageKey, missingCode) {
+        const token = await ESPRMNeoStorage.getItem(storageKey);
+        if (!token) {
+            throw new ESPTokenError(missingCode);
+        }
+        return token;
+    }
+    /**
+     * Returns the current Cognito access token from storage.
+     * @throws {ESPTokenError} When no access token is stored (not logged in).
+     */
+    async getAccessToken() {
+        return ESPRMNeoUser.requireToken(StorageKeys.ACCESSTOKEN, TokenErrorCodes.MISSING_ACCESS_TOKEN);
+    }
+    /**
+     * Returns the current Cognito ID token from storage.
+     * @throws {ESPTokenError} When no ID token is stored (not logged in).
+     */
+    async getIdToken() {
+        return ESPRMNeoUser.requireToken(StorageKeys.IDTOKEN, TokenErrorCodes.MISSING_ID_TOKEN);
+    }
+    /**
+     * Returns the current Cognito refresh token from storage.
+     * @throws {ESPTokenError} When no refresh token is stored (not logged in).
+     */
+    async getRefreshToken() {
+        return ESPRMNeoUser.requireToken(StorageKeys.REFRESHTOKEN, TokenErrorCodes.MISSING_REFRESH_TOKEN);
+    }
+    /**
+     * Extends the current session using a refresh token.
+     */
+    static async extendSession(refreshToken) {
+        const response = await ESPRMNeoAuth.getRefreshedTokens(refreshToken);
+        await ESPRMNeoStorage.setItem(StorageKeys.ACCESSTOKEN, response.accessToken);
+        await ESPRMNeoStorage.setItem(StorageKeys.IDTOKEN, response.idToken);
+        await ESPRMNeoStorage.setItem(StorageKeys.REFRESHTOKEN, response.refreshToken);
+    }
+}
+
+export { ESPRMNeoUser };
+//# sourceMappingURL=ESPRMNeoUser.js.map

package/dist/esm/ESPRMNeoUser.js.map

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

package/dist/esm/index.js

@@ -0,0 +1,140 @@
+export { ESPRMNeoBase } from './ESPRMNeoBase.js';
+export { ESPRMNeoAuth } from './ESPRMNeoAuth.js';
+export { ESPRMNeoUser } from './ESPRMNeoUser.js';
+export { ESPRMNeoGroup } from './ESPRMNeoGroup.js';
+export { ESPRMNeoNode } from './ESPRMNeoNode.js';
+export { ESPRMNeoDevice } from './ESPRMNeoDevice.js';
+export { ESPRMNeoDeviceParam } from './ESPRMNeoDeviceParam.js';
+export { ESPRMNeoService } from './ESPRMNeoService.js';
+export { ESPRMNeoServiceParam } from './ESPRMNeoServiceParam.js';
+export { ESPRMNeoSchedule } from './ESPRMNeoSchedule.js';
+export { ESPRMNeoSharingRequest } from './ESPRMNeoSharingRequest.js';
+export { ESPRMNeoTrigger } from './ESPRMNeoTrigger.js';
+export { ESPRMNeoAutomation } from './ESPRMNeoAutomation.js';
+export { ESPDevice } from './ESPDevice.js';
+export { ESPDiscoveryProtocol, ESPRMNeoEventType } from './types/discovery.js';
+export { ESPClaimStatus, ESPConnectStatus, ESPProvResponseStatus, ESPProvisionStatus, ESPSecurity, ESPTransport } from './types/provision.js';
+export { resolveNodeId } from './types/subscription.js';
+export { DEFAULT_TRANSPORT_ORDER, ESPTransportMode } from './types/transport.js';
+import './methods/ESPRMNeoAuth/ChangePassword.js';
+import './methods/ESPRMNeoAuth/ConfirmSignUp.js';
+import './methods/ESPRMNeoAuth/ForgotPassword.js';
+import './methods/ESPRMNeoAuth/GetLoggedInUser.js';
+import './methods/ESPRMNeoAuth/Login.js';
+import './methods/ESPRMNeoAuth/SendSignUpCode.js';
+import './methods/ESPRMNeoAuth/SetNewPassword.js';
+import './methods/ESPRMNeoUser/CreateESPDevice.js';
+import './methods/ESPRMNeoUser/SearchESPDevices.js';
+import './methods/ESPRMNeoUser/CreateGroup.js';
+import './methods/ESPRMNeoUser/GetGroups.js';
+import './methods/ESPRMNeoUser/GetTemporaryAWSCredentials.js';
+import './methods/ESPRMNeoUser/GetUserInfo.js';
+import './methods/ESPRMNeoUser/ListIntegrations.js';
+import './methods/ESPRMNeoUser/ListSharingRequests.js';
+import './methods/ESPRMNeoUser/Logout.js';
+import './methods/ESPRMNeoUser/EventSubscription.js';
+import './methods/ESPRMNeoUser/RegisterIntegrationEndpoint.js';
+import './methods/ESPRMNeoUser/UnregisterIntegrationEndpoint.js';
+import './methods/ESPRMNeoUser/MQTT/ConnectMQTT.js';
+import './methods/ESPRMNeoUser/MQTT/AssumeRole.js';
+import './methods/ESPRMNeoUser/MQTT/DisconnectMQTT.js';
+import './methods/ESPRMNeoGroup/CreateSubGroup.js';
+import './methods/ESPRMNeoGroup/SetParams.js';
+import './methods/ESPRMNeoGroup/Delete.js';
+import './methods/ESPRMNeoGroup/UpdateName.js';
+import './methods/ESPRMNeoGroup/Share.js';
+import './methods/ESPRMNeoGroup/GetSharingInfo.js';
+import './methods/ESPRMNeoGroup/RemoveMember.js';
+import './methods/ESPRMNeoGroup/Leave.js';
+import './methods/ESPRMNeoGroup/AddNode.js';
+import './methods/ESPRMNeoGroup/RemoveNode.js';
+import './methods/ESPRMNeoGroup/GetNode.js';
+import './methods/ESPRMNeoGroup/GetNodes.js';
+import './methods/ESPRMNeoGroup/GetSchedules.js';
+import './methods/ESPRMNeoGroup/CreateSchedule.js';
+import './methods/ESPRMNeoGroup/DeleteAllSchedules.js';
+import './methods/ESPRMNeoGroup/GetAutomations.js';
+import './methods/ESPRMNeoGroup/GetAutomation.js';
+import './methods/ESPRMNeoGroup/CreateAutomation.js';
+import './methods/ESPRMNeoSchedule/Update.js';
+import './methods/ESPRMNeoSchedule/Delete.js';
+import './methods/ESPRMNeoSchedule/Enable.js';
+import './methods/ESPRMNeoTrigger/Update.js';
+import './methods/ESPRMNeoTrigger/Delete.js';
+import './methods/ESPRMNeoTrigger/Enable.js';
+import './methods/ESPRMNeoAutomation/Update.js';
+import './methods/ESPRMNeoAutomation/Delete.js';
+import './methods/ESPRMNeoAutomation/AddCondition.js';
+import './methods/ESPRMNeoAutomation/RemoveCondition.js';
+import './methods/ESPRMNeoAutomation/AddAction.js';
+import './methods/ESPRMNeoAutomation/RemoveAction.js';
+import './methods/ESPRMNeoSharingRequest/Accept.js';
+import './methods/ESPRMNeoSharingRequest/Decline.js';
+import './methods/ESPRMNeoNode/GetConfig.js';
+import './methods/ESPRMNeoNode/Sync.js';
+import './methods/ESPRMNeoNode/GetCustomParamTSData.js';
+import './methods/ESPRMNeoNode/GetCustomParamRawTSData.js';
+import './methods/ESPRMNeoNode/GetCustomParamLatestTSData.js';
+import './methods/ESPRMNeoNode/SetParams.js';
+import './methods/ESPRMNeoNode/SubscriptionConfig.js';
+import './methods/ESPRMNeoNode/Delete.js';
+import './methods/ESPRMNeoNode/UnsubscribeFromMqttUpdates.js';
+import './methods/ESPRMNeoNode/GetSchedules.js';
+import './methods/ESPRMNeoNode/CreateSchedule.js';
+import './methods/ESPRMNeoNode/RemoveSchedule.js';
+import './methods/ESPRMNeoNode/RemoveAllSchedules.js';
+import './methods/ESPRMNeoNode/GetTriggers.js';
+import './methods/ESPRMNeoNode/CreateTrigger.js';
+import './methods/ESPRMNeoNode/RemoveTrigger.js';
+import './methods/ESPRMNeoNode/RemoveAllTriggers.js';
+import './methods/ESPRMNeoDeviceParam/GetTSData.js';
+import './methods/ESPRMNeoDeviceParam/GetRawTSData.js';
+import './methods/ESPRMNeoDeviceParam/GetLatestTSData.js';
+import './methods/ESPRMNeoDevice/GetParams.js';
+import './methods/ESPRMNeoService/GetParams.js';
+import './methods/ESPDevice/Connect.js';
+import './methods/ESPDevice/Disconnect.js';
+import './methods/ESPDevice/GetDeviceCapabilities.js';
+import './methods/ESPDevice/GetDeviceVersion.js';
+import './methods/ESPDevice/ScanWifiList.js';
+import './methods/ESPDevice/Provision.js';
+import './methods/ESPDevice/SetProofOfPossession.js';
+import './methods/ESPDevice/SendData.js';
+import './methods/ESPDevice/InitializeSession.js';
+import './methods/ESPDevice/SetNetworkCredentials.js';
+import './methods/ESPDevice/InitiateUserNodeMapping.js';
+import './methods/ESPDevice/VerifyUserNodeMapping.js';
+import './methods/ESPDevice/StartAssistedClaiming.js';
+export { buildGroupControlParamsTopic, buildRainMakerUserParamsTopic, buildShadowBase, buildShadowGroupWildcardTopics, buildShadowUpdatePayload, extractNodeIdFromTopic, getReportedParamsFromShadowDocument, getReportedParamsFromShadowLiveMessage, getStateFromPayload, parseShadowMessage } from './utils/awsShadowTopics.js';
+export { coerceToFiniteNumber, coerceToNonEmptyString, coerceToString } from './utils/coerce.js';
+export { buildCanonicalQueryString, createAuthorizationHeader, generateIotDeviceGatewayMqttSignedUrl, generateSigV4AuthHeader } from './utils/awsSigv4Utils.js';
+export { buildMainApiUrl, buildUserCredentialsUrl, ensureValidIdToken, extractTemporaryCredentials, isExpiredTokenAuthError, parseCredentialsErrorMessage, postUserCredentials, refreshUserSession } from './utils/awsUtils.js';
+export { APICallValidationErrorCodes, APIEndpoints, APIOperations, APIPathV1, AWSCredentialsErrorMessages, AuthErrorCodes, AuthSuccessMessages, AutomationStatusValues, AutomationSuccessMessages, CLAIM_CSR_MAX_CHUNKS, CLAIM_DEVICE_CSR_KEYS, CLAIM_DEVICE_MAC_KEYS, CLAIM_MAC_HEX_LENGTHS, CLAIM_MAC_SEPARATORS, CLAIM_MAX_FRAGMENT_SIZE, ClaimCapabilities, ClaimCapabilityPolicies, ClaimEndpoints, ClaimErrorCodes, ClaimProgressMessages, ConfigErrorCodes, DEFAULT_REST_API_VERSION, ESPProvProgressMessages, ESPRMNeoErrorCodes, ESPRMNeoStorageKeys, ESPServiceParamType, ESPServiceType, Endpoint, ErrorLabels, GroupSuccessMessages, GroupUserAliases, HTTPMethods, IntegrationSuccessMessages, NodeSuccessMessages, NodeWarnMessages, ProtocolType, ProvErrorCodes, ProvisionType, SDK_VERSION, ScheduleErrorMessages, ScheduleSuccessMessages, ServiceType, SharingSuccessMessages, StatusMessage, StorageAdapterErrorCodes, StorageKeys, SubscriptionChannelIds, TokenErrorCodes, TriggerErrorMessages, TriggerSuccessMessages, ValidationErrorCodes } from './utils/constants.js';
+export { LogLevel, Logger } from './utils/logger.js';
+export { concurrentFetchPool } from './utils/mapLimit.js';
+export { EventEmitter } from './utils/eventEmitter.js';
+export { resolveMqttWebSocketEndpoint } from './utils/mqtt.js';
+export { constructDeviceParamsTopic, constructShadowName, constructShadowTopic, generateParamsDigest } from './utils/shadowUtils.js';
+export { DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS, DEFAULT_NODE_ONLINE_TIMEOUT_MS, isNodeOnlineFromShadowPayload, waitForNodeOnline } from './utils/waitForNodeOnline.js';
+export { clearAllNcfgVersionMarkers, clearNcfgVersionMarker, getNcfgVersion, hasNcfgVersionChanged, listTrackedNodeIds, persistNcfgVersionMarker } from './utils/nodeNcfgVersionHandler.js';
+export { clearLocalNcfgVersionMarker, clearLocalNodeCache, collectSubgroupIdsForNode, fetchCloudNodeConfig, fetchCloudNodeConfigForNode, readLocalNodeConfig, removeLocalNodeConfig, toNeoNode, writeLocalNodeConfig } from './utils/nodeUtils.js';
+export { buildGroupNameBody, resolveGroupPath } from './utils/groupUtils.js';
+export { getScheduleItemsForNode, scheduleToItem } from './utils/scheduleUtils.js';
+export { applyTriggerUpdates, getTriggerItemsForNode, mergeTriggerItem, triggerToItem } from './utils/triggerUtils.js';
+export { TIME_SERIES_PROPERTY, buildTSQueryString, resolveTSParamIdentity, resolveTSWindow, transformTSAggregateEntry, transformTSDataPoint, tsParamIdentityFromOptions, tsParamIdentityFromParam } from './utils/tsDataUtils.js';
+export { clearNodeConfigCache, clearTokens, errorDetail, failSafe, invalidateServerSession } from './utils/userUtils.js';
+export { ESPBaseError } from './utils/error/ESPBaseError.js';
+export { ESPConfigError } from './utils/error/ESPConfigError.js';
+export { ESPValidationError } from './utils/error/ESPValidationError.js';
+export { ESPStorageAdapterError } from './utils/error/ESPStorageAdapterError.js';
+export { ESPAPICallValidationError } from './utils/error/ESPAPICallValidationError.js';
+export { ESPTokenError } from './utils/error/ESPTokenError.js';
+export { ESPProvError } from './utils/error/ESPProvError.js';
+export { ESPClaimError } from './utils/error/ESPClaimError.js';
+export { isNonEmptyString, isValidObject, isValidUrl } from './utils/validator/validators.js';
+export { decodeToken } from './services/ESPRMNeoHelpers/DecodeToken.js';
+export { ESPRMNeoSubscriptionManager } from './services/ESPRMNeoSubscriptionManager.js';
+export { NODE_PARAMS_CHANGED_EVENT } from './services/ESPRMNeoHelpers/transformShadowToNodeUpdate.js';
+export { fetchAggregatedTSData, fetchLatestTSData, fetchRawTSData } from './services/ESPRMNeoHelpers/FetchTSData.js';
+export { ESPAuthError } from './utils/error/ESPAuthError.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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

package/dist/esm/methods/ESPDevice/Connect.js

@@ -0,0 +1,11 @@
+import { ESPDevice } from '../../ESPDevice.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.prototype.connect = async function () {
+    return await this.ESPProvisionAdapter.connect(this.name);
+};
+//# sourceMappingURL=Connect.js.map

package/dist/esm/methods/ESPDevice/Connect.js.map

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

package/dist/esm/methods/ESPDevice/Disconnect.js

@@ -0,0 +1,13 @@
+import { ESPDevice } from '../../ESPDevice.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.prototype.disconnect = async function () {
+    await this.ESPProvisionAdapter.disconnect(this.name);
+    return normalizeApiResponse(null, { message: "Device disconnected successfully" });
+};
+//# sourceMappingURL=Disconnect.js.map

package/dist/esm/methods/ESPDevice/Disconnect.js.map

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

package/dist/esm/methods/ESPDevice/GetDeviceCapabilities.js

@@ -0,0 +1,11 @@
+import { ESPDevice } from '../../ESPDevice.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.prototype.getDeviceCapabilities = async function () {
+    return await this.ESPProvisionAdapter.getDeviceCapabilities(this.name);
+};
+//# sourceMappingURL=GetDeviceCapabilities.js.map

package/dist/esm/methods/ESPDevice/GetDeviceCapabilities.js.map

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

package/dist/esm/methods/ESPDevice/GetDeviceVersion.js

@@ -0,0 +1,11 @@
+import { ESPDevice } from '../../ESPDevice.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.prototype.getDeviceVersion = async function () {
+    return await this.ESPProvisionAdapter.getDeviceVersion(this.name);
+};
+//# sourceMappingURL=GetDeviceVersion.js.map

package/dist/esm/methods/ESPDevice/GetDeviceVersion.js.map

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

package/dist/esm/methods/ESPDevice/InitializeSession.js

@@ -0,0 +1,11 @@
+import { ESPDevice } from '../../ESPDevice.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.prototype.initializeSession = async function () {
+    return await this.ESPProvisionAdapter.initializeSession(this.name);
+};
+//# sourceMappingURL=InitializeSession.js.map

package/dist/esm/methods/ESPDevice/InitializeSession.js.map

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

package/dist/esm/methods/ESPDevice/InitiateUserNodeMapping.js

@@ -0,0 +1,12 @@
+import { ESPDevice } from '../../ESPDevice.js';
+import { NodeMappingHelper } from '../../services/ESPRMNeoHelpers/NodeMappingHelper.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.prototype.initiateUserNodeMapping = async function (groupId, requestBody = {}) {
+    return NodeMappingHelper.initiateUserNodeMapping(groupId, requestBody);
+};
+//# sourceMappingURL=InitiateUserNodeMapping.js.map

package/dist/esm/methods/ESPDevice/InitiateUserNodeMapping.js.map

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