@espressif/rainmaker-neo-base-sdk 1.0.0

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

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

package/dist/esm/methods/ESPRMNeoUser/EventSubscription.js

@@ -0,0 +1,48 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPRMNeoEventType } from '../../types/discovery.js';
+import { isEnumValue, isEmptyObject } from '../../utils/common.js';
+import { startLocalDiscovery, startNodeUpdates, startCustomDiscovery } from '../../utils/eventSubscriptionUtils.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoUser.prototype.subscribe = function (event, callback, discoveryConfig) {
+    this.unsubscribe(event);
+    this.eventCallbacks[event] = callback;
+    if (event === ESPRMNeoEventType.localDiscovery) {
+        this.eventTeardowns[event] = startLocalDiscovery((data) => this.trigger(event, data));
+        return;
+    }
+    if (event === ESPRMNeoEventType.nodeUpdates) {
+        this.eventTeardowns[event] = startNodeUpdates((update) => this.trigger(ESPRMNeoEventType.nodeUpdates, update));
+        return;
+    }
+    if (!isEnumValue(event, ESPRMNeoEventType) &&
+        !isEmptyObject(discoveryConfig)) {
+        this.eventTeardowns[event] = startCustomDiscovery(discoveryConfig, (info) => this.trigger(event, info));
+    }
+};
+ESPRMNeoUser.prototype.unsubscribe = function (event) {
+    delete this.eventCallbacks[event];
+    this.eventTeardowns[event]?.stop();
+    delete this.eventTeardowns[event];
+};
+ESPRMNeoUser.prototype.trigger = function (event, arg) {
+    this.eventCallbacks[event]?.(arg);
+};
+ESPRMNeoUser.prototype.removeAllCallbacks = function (event) {
+    if (event) {
+        this.unsubscribe(event);
+        return;
+    }
+    const events = new Set([
+        ...Object.keys(this.eventCallbacks),
+        ...Object.keys(this.eventTeardowns),
+    ]);
+    for (const key of events) {
+        this.unsubscribe(key);
+    }
+};
+//# sourceMappingURL=EventSubscription.js.map

package/dist/esm/methods/ESPRMNeoUser/EventSubscription.js.map

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

package/dist/esm/methods/ESPRMNeoUser/GetGroups.js

@@ -0,0 +1,52 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { ESPRMNeoGroup } from '../../ESPRMNeoGroup.js';
+import { Logger } from '../../utils/logger.js';
+import { APIPathV1 } from '../../utils/constants.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("GetGroups");
+/**
+ * Maps a wire-format subgroup to a plain {@link ESPRMNeoGroupData} (child with `parentId`).
+ */
+function transformSubgroup(subgroup, parentGroupId) {
+    return {
+        groupId: subgroup.subgroup_id,
+        groupName: subgroup.subgroup_name,
+        parentId: parentGroupId,
+        nodeIds: subgroup.node_ids,
+    };
+}
+/**
+ * Transforms a group from API format (snake_case) to ESPRMNeoGroup instance.
+ */
+function transformGroup(group) {
+    const groupData = {
+        groupId: group.group_id,
+        groupName: group.group_name,
+        accessType: group.access_type,
+        nodeIds: group.node_ids,
+        subgroups: group.subgroups?.map((subgroup) => transformSubgroup(subgroup, group.group_id)),
+        nodeDetails: group.node_details,
+    };
+    return new ESPRMNeoGroup(groupData);
+}
+/**
+ * Implementation of the `getGroups` method for the `ESPRMNeoUser` class.
+ */
+ESPRMNeoUser.prototype.getGroups = async function () {
+    logger.debug("getGroups called");
+    try {
+        const response = await ESPSigV4APIManager.getInstance().request("GET", APIPathV1.GROUPS);
+        return (response.groups ?? []).map(transformGroup);
+    }
+    catch (error) {
+        logger.error("getGroups failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=GetGroups.js.map

package/dist/esm/methods/ESPRMNeoUser/GetGroups.js.map

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

package/dist/esm/methods/ESPRMNeoUser/GetTemporaryAWSCredentials.js

@@ -0,0 +1,77 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPRMNeoStorage } from '../../services/ESPRMNeoStorage/ESPRMNeoStorage.js';
+import { buildUserCredentialsUrl, ensureValidIdToken, postUserCredentials, extractTemporaryCredentials, parseCredentialsErrorMessage, isExpiredTokenAuthError, refreshUserSession } from '../../utils/awsUtils.js';
+import { AWSCredentialsErrorMessages } from '../../utils/constants.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("GetTemporaryAWSCredentials");
+const MAX_CREDENTIAL_RETRIES = 2;
+/**
+ * Fetches temporary AWS credentials from `POST /v1/user/credentials`.
+ *
+ * Shared by {@link ESPRMNeoUser.getTemporaryAWSCredentials} and callers that
+ * need identity-pool credentials (e.g. AssumeRole / MQTT setup) without
+ * depending on prototype attachment order.
+ *
+ * Flow:
+ * 1. Ensure a non-expired Cognito ID token (refresh session if needed).
+ * 2. POST credentials with Bearer ID token.
+ * 3. On 401 expired-token, refresh the session and retry (up to
+ *    `MAX_CREDENTIAL_RETRIES` times).
+ * 4. Persist and return the temporary credentials.
+ *
+ * @returns Temporary AWS credentials (access key, secret key, session token, expiration).
+ * @throws {ESPTokenError} If the user is not logged in (missing ID/refresh token).
+ * @throws {Error} On network failure, incomplete response, or non-retryable API error.
+ */
+async function fetchTemporaryAWSCredentials() {
+    logger.debug(AWSCredentialsErrorMessages.FETCH_CALLED);
+    const url = buildUserCredentialsUrl();
+    // Step 1: refresh a locally expired/undecodable ID token before the first request.
+    await ensureValidIdToken();
+    // Step 2–3: POST credentials; on 401 expired-token, refresh session and retry.
+    for (let attempt = 0; attempt <= MAX_CREDENTIAL_RETRIES; attempt++) {
+        const { response, data, responseText } = await postUserCredentials(url);
+        if (response.ok) {
+            // Step 4: map wire fields → ESPAWSCredentials, persist, then return.
+            const credentials = extractTemporaryCredentials(data);
+            await ESPRMNeoStorage.saveTemporaryCredentials(credentials);
+            logger.debug(AWSCredentialsErrorMessages.FETCH_SUCCESS, {
+                expiration: credentials.expiration,
+                attempt: attempt + 1,
+            });
+            return credentials;
+        }
+        const errorMessage = parseCredentialsErrorMessage(response, data, responseText);
+        // Retry only for 401 + "expired" in the message; other failures are terminal.
+        const canRetry = attempt < MAX_CREDENTIAL_RETRIES &&
+            isExpiredTokenAuthError(response.status, errorMessage);
+        if (!canRetry) {
+            logger.error(AWSCredentialsErrorMessages.API_ERROR, {
+                status: response.status,
+                message: errorMessage,
+                attempt: attempt + 1,
+            });
+            throw new Error(errorMessage);
+        }
+        logger.debug(AWSCredentialsErrorMessages.CREDENTIALS_RETRY(attempt + 1, MAX_CREDENTIAL_RETRIES));
+        // Refresh Cognito session so the next attempt uses a fresh ID token.
+        await refreshUserSession();
+    }
+    // Defensive: the loop always returns on success or throws on failure.
+    throw new Error(AWSCredentialsErrorMessages.API_ERROR);
+}
+/**
+ * Implementation of `getTemporaryAWSCredentials` for {@link ESPRMNeoUser}.
+ */
+ESPRMNeoUser.prototype.getTemporaryAWSCredentials = async function () {
+    return fetchTemporaryAWSCredentials();
+};
+
+export { fetchTemporaryAWSCredentials };
+//# sourceMappingURL=GetTemporaryAWSCredentials.js.map

package/dist/esm/methods/ESPRMNeoUser/GetTemporaryAWSCredentials.js.map

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

package/dist/esm/methods/ESPRMNeoUser/GetUserInfo.js

@@ -0,0 +1,37 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPRMNeoAPIManager } from '../../services/ESPRMNeoAPIManager.js';
+import { APIPathV1, GroupUserAliases } from '../../utils/constants.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("GetUserInfo");
+/**
+ * Implementation of the getUserInfo method for the ESPRMNeoUser class.
+ *
+ * @returns A promise that resolves to RainMaker user info.
+ */
+ESPRMNeoUser.prototype.getUserInfo =
+    async function () {
+        const accessToken = await this.getAccessToken();
+        // Always "me": the backend accepts {userId} = "me" or the RainMaker
+        // custom:user_id claim ONLY — a Cognito `sub` gets 403 Forbidden
+        // (verified against the backend's handleGetUser).
+        const endpoint = APIPathV1.user(GroupUserAliases.CURRENT);
+        logger.debug(`getUserInfo → GET ${endpoint}`);
+        const profile = await ESPRMNeoAPIManager.getInstance().getUserApiWithBearer(endpoint, accessToken);
+        const username = profile.phone_number || profile.email || profile.user_id;
+        return {
+            username,
+            userId: profile.user_id,
+            userAttributes: {
+                ...(profile.email ? { email: profile.email } : {}),
+                ...(profile.phone_number ? { phone_number: profile.phone_number } : {}),
+                ...(profile.user_id ? { user_id: profile.user_id } : {}),
+            },
+        };
+    };
+//# sourceMappingURL=GetUserInfo.js.map

package/dist/esm/methods/ESPRMNeoUser/GetUserInfo.js.map

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

package/dist/esm/methods/ESPRMNeoUser/ListIntegrations.js

@@ -0,0 +1,35 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APIPathV1 } from '../../utils/constants.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("ListIntegrations");
+/**
+ * Implementation of the `listIntegrations` method for the `ESPRMNeoUser` class.
+ */
+ESPRMNeoUser.prototype.listIntegrations = async function () {
+    logger.debug("listIntegrations called");
+    try {
+        const api = ESPSigV4APIManager.getInstance();
+        const response = await api.get(APIPathV1.INTEGRATIONS);
+        const integrations = Array.isArray(response)
+            ? response
+            : (response?.integrations ?? []);
+        logger.debug("listIntegrations succeeded", {
+            count: integrations.length,
+        });
+        return integrations;
+    }
+    catch (error) {
+        logger.error("listIntegrations failed", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+//# sourceMappingURL=ListIntegrations.js.map

package/dist/esm/methods/ESPRMNeoUser/ListIntegrations.js.map

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

package/dist/esm/methods/ESPRMNeoUser/ListSharingRequests.js

@@ -0,0 +1,29 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPRMNeoSharingRequest } from '../../ESPRMNeoSharingRequest.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APIPathV1 } from '../../utils/constants.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("ListSharingRequests");
+/**
+ * Implementation of the `listSharingRequests` method for the `ESPRMNeoUser` class.
+ */
+ESPRMNeoUser.prototype.listSharingRequests = async function () {
+    logger.debug("listSharingRequests called");
+    try {
+        const response = await ESPSigV4APIManager.getInstance().get(APIPathV1.SHARING_REQUESTS_RECEIVED);
+        const requests = (response.sharing_requests ?? []).map((request) => new ESPRMNeoSharingRequest(request));
+        logger.debug("listSharingRequests succeeded", { count: requests.length });
+        return requests;
+    }
+    catch (error) {
+        logger.error("listSharingRequests failed", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+};
+//# sourceMappingURL=ListSharingRequests.js.map

package/dist/esm/methods/ESPRMNeoUser/ListSharingRequests.js.map

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

package/dist/esm/methods/ESPRMNeoUser/Logout.js

@@ -0,0 +1,38 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPRMNeoStorage } from '../../services/ESPRMNeoStorage/ESPRMNeoStorage.js';
+import { NodeMQTTOrchestrator } from '../../services/NodeMQTTOrchestrator.js';
+import { Logger } from '../../utils/logger.js';
+import { failSafe, invalidateServerSession, clearTokens, clearNodeConfigCache, errorDetail } from '../../utils/userUtils.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("Logout");
+/**
+ * Logs out the user:
+ * 1. Best-effort `POST /v1/user/auth/signout`
+ * 2. Disconnect MQTT and reset orchestrator session
+ * 3. Clear tokens, AWS credentials, and node config cache
+ */
+ESPRMNeoUser.prototype.logout = async function () {
+    logger.debug("logout called");
+    try {
+        await failSafe("invalidateServerSession", invalidateServerSession);
+        await failSafe("disconnectMQTT", () => this.disconnectMQTT());
+        await failSafe("resetMqttSession", () => {
+            NodeMQTTOrchestrator.resetSession();
+        });
+        await failSafe("clearTokens", clearTokens);
+        await failSafe("clearAwsCredentials", () => ESPRMNeoStorage.clearTemporaryCredentials());
+        await failSafe("clearNodeConfigCache", clearNodeConfigCache);
+        logger.debug("logout succeeded");
+        return true;
+    }
+    catch (error) {
+        logger.error("logout failed", { error: errorDetail(error) });
+        return false;
+    }
+};
+//# sourceMappingURL=Logout.js.map

package/dist/esm/methods/ESPRMNeoUser/Logout.js.map

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

package/dist/esm/methods/ESPRMNeoUser/MQTT/AssumeRole.js

@@ -0,0 +1,36 @@
+import { ESPRMNeoUser } from '../../../ESPRMNeoUser.js';
+import { APIPathV1 } from '../../../utils/constants.js';
+import { ESPSigV4APIManager } from '../../../services/ESPSigV4APIManager.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Implementation of the `assumeRole` method for the `ESPRMNeoUser` class.
+ *
+ * Exchanges identity (temporary) credentials for assume-role credentials with IoT/MQTT
+ * permissions. The backend signs the user in with the provided credentials and returns
+ * a new credential set for MQTT; this is not refreshing or extending the same credentials.
+ */
+ESPRMNeoUser.prototype.assumeRole = async function (accessKey, secretKey, sessionToken, options) {
+    // Request body: identity (temporary) credentials so backend can assume the IoT role
+    const requestBody = {
+        access_key: accessKey,
+        secret_key: secretKey,
+        session_token: sessionToken,
+    };
+    // Merge optional fields (e.g., include: ["s3", "kvs"])
+    if (options?.include && options.include.length > 0) {
+        requestBody.include = options.include;
+    }
+    const api = ESPSigV4APIManager.getInstance();
+    const response = await api.post(APIPathV1.ASSUME_ROLE, requestBody);
+    // Validate response contains required fields
+    if (!response.access_key || !response.secret_key || !response.session_token) {
+        throw new Error("Invalid assume role response: missing required credential fields");
+    }
+    return response;
+};
+//# sourceMappingURL=AssumeRole.js.map

package/dist/esm/methods/ESPRMNeoUser/MQTT/AssumeRole.js.map

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

package/dist/esm/methods/ESPRMNeoUser/MQTT/ConnectMQTT.js

@@ -0,0 +1,65 @@
+import { ESPRMNeoUser } from '../../../ESPRMNeoUser.js';
+import { ESPRMNeoBase } from '../../../ESPRMNeoBase.js';
+import { ESPRMNeoMqtt } from '../../../services/ESPRMNeoMqtt/ESPRMNeoMqtt.js';
+import { decodeToken } from '../../../services/ESPRMNeoHelpers/DecodeToken.js';
+import { Logger } from '../../../utils/logger.js';
+import { resolveMqttWebSocketEndpoint } from '../../../utils/mqtt.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// ConnectMQTT.ts
+const logger = new Logger("ConnectMQTT");
+/**
+ * Resolves the login identity (email or phone) used in the MQTT client ID.
+ * Prefer phone_number / email claims; fall back to cognito:username.
+ */
+function resolveMqttUserIdentity(idToken) {
+    const payload = decodeToken(idToken);
+    const asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+    const identity = asString(payload.phone_number) ||
+        asString(payload.email) ||
+        asString(payload["cognito:username"]);
+    if (!identity) {
+        throw new Error("Unable to resolve MQTT client identity from ID token (email or phone required)");
+    }
+    return identity;
+}
+/**
+ * Per-session suffix so concurrent sessions (phone + dashboard + reinstall)
+ * do not collide on the same AWS IoT client ID.
+ */
+function createMqttSessionSuffix() {
+    return Math.floor(Math.random() * 1_000_000)
+        .toString()
+        .padStart(6, "0");
+}
+ESPRMNeoUser.prototype.connectMQTT = async function () {
+    try {
+        await this.disconnectMQTT();
+        const config = ESPRMNeoBase.getConfig();
+        const endpoint = resolveMqttWebSocketEndpoint(config.iotEndpoint);
+        const creds = await this.getTemporaryAWSCredentials();
+        const assumeRoleCreds = await this.assumeRole(creds.accessKey, creds.secretKey, creds.sessionToken);
+        const idToken = await this.getIdToken();
+        const identity = resolveMqttUserIdentity(idToken);
+        const credentials = {
+            clientId: `user:${identity}:${createMqttSessionSuffix()}`,
+            endpoint,
+            accessKey: assumeRoleCreds.access_key,
+            secretKey: assumeRoleCreds.secret_key,
+            sessionToken: assumeRoleCreds.session_token,
+            region: config.awsRegion,
+        };
+        await ESPRMNeoMqtt.getInstance().connect(credentials);
+        logger.debug("MQTT connected successfully", { clientId: credentials.clientId });
+        return true;
+    }
+    catch (error) {
+        logger.error("Error in MQTT connection setup", error);
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+};
+//# sourceMappingURL=ConnectMQTT.js.map

package/dist/esm/methods/ESPRMNeoUser/MQTT/ConnectMQTT.js.map

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

package/dist/esm/methods/ESPRMNeoUser/MQTT/DisconnectMQTT.js

@@ -0,0 +1,27 @@
+import { ESPRMNeoUser } from '../../../ESPRMNeoUser.js';
+import { ESPRMNeoMqtt } from '../../../services/ESPRMNeoMqtt/ESPRMNeoMqtt.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("DisconnectMQTT");
+ESPRMNeoUser.prototype.disconnectMQTT = async function () {
+    if (!ESPRMNeoMqtt.hasInstance()) {
+        return;
+    }
+    const mqtt = ESPRMNeoMqtt.getInstance();
+    if (!(await mqtt.isConnected())) {
+        return;
+    }
+    try {
+        await mqtt.disconnect();
+    }
+    catch (error) {
+        logger.error("MQTT disconnection failed", error);
+        throw error;
+    }
+};
+//# sourceMappingURL=DisconnectMQTT.js.map

package/dist/esm/methods/ESPRMNeoUser/MQTT/DisconnectMQTT.js.map

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

package/dist/esm/methods/ESPRMNeoUser/RegisterIntegrationEndpoint.js

@@ -0,0 +1,39 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APIPathV1 } from '../../utils/constants.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("RegisterIntegrationEndpoint");
+/**
+ * Implementation of the `registerIntegrationEndpoint` method for the `ESPRMNeoUser` class.
+ */
+ESPRMNeoUser.prototype.registerIntegrationEndpoint = async function (integrationId, appToken, locale) {
+    logger.debug("registerIntegrationEndpoint called", { integrationId, locale });
+    const api = ESPSigV4APIManager.getInstance();
+    const endpoint = APIPathV1.integrationEndpoints(integrationId);
+    const requestBody = {
+        delivery_credentials: { app_token: appToken },
+        ...(locale !== undefined ? { locale } : {}),
+    };
+    try {
+        const response = await api.put(endpoint, requestBody);
+        logger.debug("registerIntegrationEndpoint succeeded", {
+            integrationId,
+            endpointId: response.endpoint_id,
+        });
+        return response.endpoint_id;
+    }
+    catch (error) {
+        logger.error("registerIntegrationEndpoint failed", {
+            integrationId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+//# sourceMappingURL=RegisterIntegrationEndpoint.js.map

package/dist/esm/methods/ESPRMNeoUser/RegisterIntegrationEndpoint.js.map

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

package/dist/esm/methods/ESPRMNeoUser/SearchESPDevices.js

@@ -0,0 +1,48 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPDevice } from '../../ESPDevice.js';
+import { ESPRMNeoBase } from '../../ESPRMNeoBase.js';
+import { ESPProvError } from '../../utils/error/ESPProvError.js';
+import { ProvErrorCodes } from '../../utils/constants.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("SearchESPDevices");
+/**
+ * Searches for ESP devices with the given prefix.
+ * @param devicePrefix - The prefix of the device name to search for.
+ * @param transport - The transport type (BLE or SoftAP).
+ * @returns A promise that resolves to an array of ESPDevice instances.
+ */
+ESPRMNeoUser.prototype.searchESPDevices = async function (devicePrefix, transport) {
+    logger.debug("searchESPDevices called", { devicePrefix, transport });
+    const provisionAdapter = ESPRMNeoBase.getProvisionAdapter();
+    if (!provisionAdapter) {
+        logger.error("searchESPDevices failed", {
+            error: "MISSING_PROV_ADAPTER",
+        });
+        throw new ESPProvError(ProvErrorCodes.MISSING_PROV_ADAPTER);
+    }
+    try {
+        const espDevices = await provisionAdapter.searchESPDevices(devicePrefix, transport);
+        const devices = espDevices?.map((espDevice) => new ESPDevice(espDevice));
+        logger.debug("searchESPDevices succeeded", {
+            devicePrefix,
+            transport,
+            count: devices?.length ?? 0,
+        });
+        return devices;
+    }
+    catch (error) {
+        logger.error("searchESPDevices failed", {
+            devicePrefix,
+            transport,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+//# sourceMappingURL=SearchESPDevices.js.map

package/dist/esm/methods/ESPRMNeoUser/SearchESPDevices.js.map

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

package/dist/esm/methods/ESPRMNeoUser/UnregisterIntegrationEndpoint.js

@@ -0,0 +1,42 @@
+import { ESPRMNeoUser } from '../../ESPRMNeoUser.js';
+import { ESPSigV4APIManager } from '../../services/ESPSigV4APIManager.js';
+import { APIPathV1, IntegrationSuccessMessages } from '../../utils/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { normalizeApiResponse } from '../../utils/normalizeApiResponse.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("UnregisterIntegrationEndpoint");
+/**
+ * Implementation of the `unregisterIntegrationEndpoint` method for the `ESPRMNeoUser` class.
+ */
+ESPRMNeoUser.prototype.unregisterIntegrationEndpoint = async function (integrationId, endpointId) {
+    logger.debug("unregisterIntegrationEndpoint called", {
+        integrationId,
+        endpointId,
+    });
+    const api = ESPSigV4APIManager.getInstance();
+    const endpoint = APIPathV1.integrationEndpoint(integrationId, endpointId);
+    try {
+        const response = await api.delete(endpoint);
+        logger.debug("unregisterIntegrationEndpoint succeeded", {
+            integrationId,
+            endpointId,
+        });
+        return normalizeApiResponse(response, {
+            message: IntegrationSuccessMessages.ENDPOINT_UNREGISTERED,
+        });
+    }
+    catch (error) {
+        logger.error("unregisterIntegrationEndpoint failed", {
+            integrationId,
+            endpointId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+//# sourceMappingURL=UnregisterIntegrationEndpoint.js.map

package/dist/esm/methods/ESPRMNeoUser/UnregisterIntegrationEndpoint.js.map

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

package/dist/esm/proto/constants.js

@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Generated by the protoc-gen-ts.  DO NOT EDIT!
+ * compiler version: 5.28.2
+ * source: constants.proto
+ * git: https://github.com/thesayyn/protoc-gen-ts */
+var Status;
+(function (Status) {
+    Status[Status["Success"] = 0] = "Success";
+    Status[Status["InvalidSecScheme"] = 1] = "InvalidSecScheme";
+    Status[Status["InvalidProto"] = 2] = "InvalidProto";
+    Status[Status["TooManySessions"] = 3] = "TooManySessions";
+    Status[Status["InvalidArgument"] = 4] = "InvalidArgument";
+    Status[Status["InternalError"] = 5] = "InternalError";
+    Status[Status["CryptoError"] = 6] = "CryptoError";
+    Status[Status["InvalidSession"] = 7] = "InvalidSession";
+})(Status || (Status = {}));
+
+export { Status };
+//# sourceMappingURL=constants.js.map