@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/cjs/index.js

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

package/dist/cjs/index.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/cjs/methods/ESPDevice/Provision.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var ESPDevice = require('../../ESPDevice.js');
+var provision = require('../../types/provision.js');
+var constants = require('../../utils/constants.js');
+var ESPProvError = require('../../utils/error/ESPProvError.js');
+var ChallengeResponseHelper = require('../../services/ESPRMNeoHelpers/ChallengeResponseHelper.js');
+var TransformEncoding = require('../../services/ESPRMNeoHelpers/TransformEncoding.js');
+var waitForNodeOnline = require('../../utils/waitForNodeOnline.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("Provision");
+function reportProgress(onProgress, status, description) {
+    onProgress?.({ status, description });
+}
+function validateProvisionOptions(options) {
+    if (options?.waitForOnline && !options.user) {
+        throw new Error("Provision options: user is required when waitForOnline is true");
+    }
+}
+ESPDevice.ESPDevice.prototype.provision = async function (ssid, passphrase, onProgress, groupId, provisionType = constants.ProvisionType.CHAL_RESP, options) {
+    try {
+        if (provisionType !== constants.ProvisionType.CHAL_RESP) {
+            throw new ESPProvError.ESPProvError("INVALID_PROVISION_TYPE");
+        }
+        validateProvisionOptions(options);
+        return await runChallengeResponseFlow(this, ssid, passphrase, groupId, onProgress, options);
+    }
+    catch (error) {
+        logger.error("Provision failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+async function runChallengeResponseFlow(device, ssid, passphrase, groupId, onProgress, options) {
+    // 1. INITIATE (Server)
+    reportProgress(onProgress, provision.ESPProvResponseStatus.onProgress, constants.ESPProvProgressMessages.INITIATING_NODE_ASSOCIATION);
+    const initiateResponse = (await device.initiateUserNodeMapping(groupId, {}));
+    const { challenge, request_id: requestId } = initiateResponse;
+    if (!challenge || !requestId) {
+        throw new ESPProvError.ESPProvError("INVALID_MAPPING_RESPONSE");
+    }
+    // 2. SEND CHALLENGE TO DEVICE
+    reportProgress(onProgress, provision.ESPProvResponseStatus.onProgress, constants.ESPProvProgressMessages.SENDING_CHALLENGE_TO_DEVICE);
+    const challengePayload = ChallengeResponseHelper.ChallengeResponseHelper.createChallengeRequest(challenge);
+    const base64Payload = TransformEncoding.uint8ArrayToBase64(challengePayload);
+    const responseStr = await device.sendData(constants.Endpoint.CHALLENGE_RESPONSE, base64Payload);
+    // 3. VALIDATE RESPONSE FORMAT
+    const responseBytes = TransformEncoding.base64ToUint8Array(responseStr);
+    const deviceResponse = ChallengeResponseHelper.ChallengeResponseHelper.parseDeviceResponse(responseBytes);
+    if (!ChallengeResponseHelper.ChallengeResponseHelper.validateChallengeResponse(deviceResponse)) {
+        logger.error("Invalid device response", deviceResponse);
+        throw new ESPProvError.ESPProvError("INVALID_CHALLENGE_RESPONSE_FORMAT");
+    }
+    const { nodeId, signedChallenge } = deviceResponse;
+    logger.debug("Parsed device response", {
+        nodeId,
+        signedChallengeLength: signedChallenge?.length,
+    });
+    // 4. VERIFY (Server)
+    reportProgress(onProgress, provision.ESPProvResponseStatus.onProgress, constants.ESPProvProgressMessages.VERIFYING_NODE_ASSOCIATION);
+    await device.verifyUserNodeMapping(groupId, requestId, {
+        challenge_response: signedChallenge,
+        node_id: nodeId,
+    });
+    // 5. SET NETWORK CREDENTIALS
+    reportProgress(onProgress, provision.ESPProvResponseStatus.onProgress, constants.ESPProvProgressMessages.SETTING_NETWORK_CREDENTIALS);
+    await device.setNetworkCredentials(ssid, passphrase);
+    const resolvedNodeId = nodeId;
+    // 6. Wait for cloud online (optional)
+    if (options?.waitForOnline && options.user) {
+        reportProgress(onProgress, provision.ESPProvResponseStatus.onProgress, constants.ESPProvProgressMessages.WAITING_FOR_ONLINE);
+        await waitForNodeOnline.waitForNodeOnline({
+            nodeId: resolvedNodeId,
+            groupId,
+            user: options.user,
+            timeoutMs: options.onlineTimeoutMs ?? waitForNodeOnline.DEFAULT_NODE_ONLINE_TIMEOUT_MS,
+        });
+    }
+    // 7. Success
+    reportProgress(onProgress, provision.ESPProvResponseStatus.succeed, resolvedNodeId ?? constants.ESPProvProgressMessages.DEVICE_PROVISIONED);
+    return resolvedNodeId;
+}
+//# sourceMappingURL=Provision.js.map

package/dist/cjs/methods/ESPDevice/Provision.js.map

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

package/dist/cjs/methods/ESPDevice/ScanWifiList.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var ESPDevice = require('../../ESPDevice.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.ESPDevice.prototype.scanWifiList = async function () {
+    return await this.ESPProvisionAdapter.scanWifiList(this.name);
+};
+//# sourceMappingURL=ScanWifiList.js.map

package/dist/cjs/methods/ESPDevice/ScanWifiList.js.map

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

package/dist/cjs/methods/ESPDevice/SendData.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var ESPDevice = require('../../ESPDevice.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.ESPDevice.prototype.sendData = async function (endPoint, data) {
+    return await this.ESPProvisionAdapter.sendData(this.name, endPoint, data);
+};
+//# sourceMappingURL=SendData.js.map

package/dist/cjs/methods/ESPDevice/SendData.js.map

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

package/dist/cjs/methods/ESPDevice/SetNetworkCredentials.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var ESPDevice = require('../../ESPDevice.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.ESPDevice.prototype.setNetworkCredentials = async function (ssid, passphrase) {
+    return this.ESPProvisionAdapter.provision(this.name, ssid, passphrase);
+};
+//# sourceMappingURL=SetNetworkCredentials.js.map

package/dist/cjs/methods/ESPDevice/SetNetworkCredentials.js.map

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

package/dist/cjs/methods/ESPDevice/SetProofOfPossession.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var ESPDevice = require('../../ESPDevice.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.ESPDevice.prototype.setProofOfPossession = async function (proofOfPossession) {
+    return await this.ESPProvisionAdapter.setProofOfPossession(this.name, proofOfPossession);
+};
+//# sourceMappingURL=SetProofOfPossession.js.map

package/dist/cjs/methods/ESPDevice/SetProofOfPossession.js.map

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