senza-sdk 4.2.65-d2761c0.0 → 4.3.1-ca3d96f.0

package/src/{alarmManager.js → implementation/alarmManager.js}

@@ -1,29 +1,9 @@
+import { AlarmManager as AlarmManagerInterface } from "../interface/alarmManager";
 import { getFCID, sdkLogger } from "./utils";
 import { EventListenersManager } from "./eventListenersManager";
 import { lifecycle } from "./lifecycle";
 
-/**
- * AlarmManager is a singleton class that manages the alarms in the application. It fires events whose types are the names of the alarms.
- * @fires MyAlarm
- */
-class AlarmManager extends EventTarget {
-
-    /**
-     * alarm event
-     *
-     * @event AlarmManager#MyAlarm
-     * @description Fired when time of 'MyAlarm' arrives. If this alarm triggers the application load and the application doesn't call
-     * lifecycle.moveToForeground() in the alarm callback (i.e. the application remains in the background after the callback is completed),
-     * the application will be unloaded.
-     * NOTE: If you perform async operations in the callback (without moving to foreground), you must wait for the async
-     * operation to finish before returning from the callback, otherwise the application will be unloaded before the async operation is finished.<br>
-     * @example
-     * alarmManager.addEventListener("MyAlarm", async (e) => {
-     *     console.log("alarm MyAlarm arrived with data", e.detail);
-     *     await fetch("http://www.example.com");
-     * });
-     * alarmManager.addAlarm("MyAlarm", Date.now() + 60*60*1000, "MyData");
-     */
+class AlarmManager extends AlarmManagerInterface {
     constructor() {
         super();
 
@@ -36,10 +16,10 @@ class AlarmManager extends EventTarget {
             timeoutMs: 15000 // Default timeout of 15 seconds, can be overridden by _setDefaultTimeout
         });
 
-        typeof document !== "undefined" && document.addEventListener("hs/alarmFiredEvent",async (e) => {
+        typeof document !== "undefined" && document.addEventListener("hs/alarmFiredEvent", async (e) => {
 
             if (e.detail?.alarmName) {
-                const logger = sdkLogger.withFields({alarmName: e.detail?.alarmName});
+                const logger = sdkLogger.withFields({ alarmName: e.detail?.alarmName });
                 logger.log("Got hs/alarmFiredEvent", JSON.stringify(e.detail));
 
                 const timeBeforeAlarmHandling = Date.now();
@@ -53,7 +33,7 @@ class AlarmManager extends EventTarget {
                 this._targetState = sourceState;
 
                 // Create the custom event with payload
-                const event = new CustomEvent(e.detail.alarmName, {detail: e.detail.payload});
+                const event = new CustomEvent(e.detail.alarmName, { detail: e.detail.payload });
 
                 // Dispatch the event and wait for all listeners
                 await this._eventManager.dispatch(e.detail.alarmName, event);
@@ -67,7 +47,7 @@ class AlarmManager extends EventTarget {
                     if (!this._moveToForegroundHasBeenCalled && window.cefQuery) {
                         logger.log("Application is about to be terminated since didn't move to foreground");
                         const message = { type: "terminating" };
-                        const request = { target:"TC", waitForResponse: false, message: JSON.stringify(message) };
+                        const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
                         window.cefQuery({
                             request: JSON.stringify(request),
                             persistent: false,
@@ -113,7 +93,7 @@ class AlarmManager extends EventTarget {
         this._eventManager.addEventListener(type, callback);
     }
 
-    removeEventListener(type, callback){
+    removeEventListener(type, callback) {
         this._eventManager.removeEventListener(type, callback);
     }
 
@@ -126,17 +106,12 @@ class AlarmManager extends EventTarget {
         this._targetState = "background";
     }
 
-    /** Set alarm to be fired at the specified time, event when ui is released
-     * @param {string} alarmName unique name for the alarm
-     * @param {number} alarmTime target time for the alarm to be fired, represented by the number of milliseconds elapsed since the epoch
-     * @param {string} [data] data to be passed back when the alarm is fired
-     * */
     addAlarm(alarmName, alarmTime, data = "", toleranceBefore = 0, toleranceAfter = 0) {
         if (typeof data !== "string") {
             throw Error("data must be a string");
         }
         const FCID = getFCID();
-        const logger = sdkLogger.withFields({alarmName, FCID});
+        const logger = sdkLogger.withFields({ alarmName, FCID });
         logger.log(`addAlarm called for ${alarmName} to be fired at ${alarmTime} with tolerance of ${toleranceBefore} minutes before and ${toleranceAfter} minutes after`);
         if (window.cefQuery) {
             const message = {
@@ -144,11 +119,11 @@ class AlarmManager extends EventTarget {
                 fcid: FCID,
                 alarmName,
                 alarmTime,
-                toleranceBefore: Math.trunc(toleranceBefore*60*1000),
-                toleranceAfter: Math.trunc(toleranceAfter*60*1000),
+                toleranceBefore: Math.trunc(toleranceBefore * 60 * 1000),
+                toleranceAfter: Math.trunc(toleranceAfter * 60 * 1000),
                 payload: data
             };
-            const request = { target:"TC", waitForResponse: false, message: JSON.stringify(message) };
+            const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
             window.cefQuery({
                 request: JSON.stringify(request),
                 persistent: false,
@@ -164,13 +139,9 @@ class AlarmManager extends EventTarget {
         }
     }
 
-    /** Delete the specified alarm
-     * @param {string} alarmName name of alarm to be deleted
-     *
-     * */
     deleteAlarm(alarmName) {
         const FCID = getFCID();
-        const logger = sdkLogger.withFields({alarmName, FCID});
+        const logger = sdkLogger.withFields({ alarmName, FCID });
         logger.log(`deleteAlarm called for ${alarmName}`);
         if (window.cefQuery) {
             const message = {
@@ -178,7 +149,7 @@ class AlarmManager extends EventTarget {
                 fcid: FCID,
                 alarmName
             };
-            const request = { target:"TC", waitForResponse: false, message: JSON.stringify(message) };
+            const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
             window.cefQuery({
                 request: JSON.stringify(request),
                 persistent: false,
@@ -194,18 +165,15 @@ class AlarmManager extends EventTarget {
         }
     }
 
-    /** Delete all alarms
-     *
-     * */
     deleteAllAlarms() {
         if (window.cefQuery) {
             const FCID = getFCID();
-            const logger = sdkLogger.withFields({FCID});
+            const logger = sdkLogger.withFields({ FCID });
             const message = {
                 type: "deleteAllAlarms",
                 fcid: FCID
             };
-            const request = { target:"TC", waitForResponse: false, message: JSON.stringify(message) };
+            const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
             window.cefQuery({
                 request: JSON.stringify(request),
                 persistent: false,
@@ -221,11 +189,6 @@ class AlarmManager extends EventTarget {
         }
     }
 
-    /** Async function that asks for all active alarms
-     * @returns {Promise} when resolved, returns an array of objects containing alarmName and alarmTime fields
-     * @throws {string} error string in case of an error
-     *
-     * */
     getActiveAlarms() {
         throw Error("NOT IMPLEMENTED");
         // if (window.cefQuery) {

package/src/implementation/api.js

@@ -0,0 +1,363 @@
+import { getFCID, sdkLogger, getVersion } from "./utils.js";
+import { sessionInfo } from "./SessionInfo.js";
+import { lifecycle } from "./lifecycle.js";
+import { alarmManager } from "./alarmManager.js";
+
+let authToken;
+
+const API_VERSION = "1.0";
+let interfaceVersion;
+
+/** @namespace auth
+ *@example
+ * import { auth } from "senza-sdk";
+ **/
+export const auth = {
+
+    /** Should be called upon startup and be embedded in future requests */
+    getToken,
+
+    /** Should be called upon '401' event (unauthorized) */
+    forceTokenUpdate,
+
+    getClientAssertion
+
+};
+
+import { remotePlayer } from "./remotePlayer.js";
+export { remotePlayer };
+
+/** Should be called once to init the library
+ *@example
+ * import { init } from "senza-sdk";
+ * await init();
+ **/
+export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFunc) {
+    interfaceVersion = interfaceApiVersion;
+    sdkLogger.addfields({ interfaceVersion });
+    sdkLogger.log(`init. Interface version: ${interfaceVersion}. Implementation version: ${getVersion()}`);
+
+    if (!window.diagnostics) {
+        // ------------------------------------------------------------------------------------------------
+        // -- Do NOT change this log, as ui-streamer is checking this string to detect abnormal behavior --
+        // ------------------------------------------------------------------------------------------------
+        sdkLogger.error("[ init ] window.diagnostics is undefined");
+    }
+
+    if (window.cefQuery) {
+
+        // First, check compatability with ui-streamer api version
+        await new Promise((resolve, reject) => {
+            window.cefQuery({
+                request: "apiVersion " + API_VERSION,
+                persistent: false,
+                onSuccess: () => {
+                    sdkLogger.log("api version compatability check succeeded");
+                    resolve();
+                },
+                onFailure: (code, msg) => {
+                    sdkLogger.error("api version compatability check failed: " + msg);
+                    reject(msg);
+                }
+            });
+        });
+
+        const sessionInfoStr = await new Promise((resolve) => {
+            window.cefQuery({
+                request: "sessionInfo",
+                persistent: false,
+                onSuccess: (response) => {
+                    sdkLogger.log("sessionInfo request successfully returned " + response);
+                    resolve(response);
+                },
+                onFailure: (code, msg) => {
+                    sdkLogger.error(`sessionInfo request failed: ${code} ${msg}`);
+                }
+            });
+        });
+
+        sessionInfo.setSessionInfoStr(sessionInfoStr);
+        const sessionInfoObj = JSON.parse(sessionInfoStr);
+        authToken = sessionInfoObj?.settings?.webUI?.backendHeaders?.Authorization;
+        sdkLogger.log(`authToken: token = ${authToken}`);
+        // Listen to updateSession event to set the new token
+        document.addEventListener("updateSession", (e) => {
+            authToken = e.detail?.updateObj;
+            sdkLogger.log(`onUpdateSessionEvent: token = ${authToken}`);
+        });
+
+        // Set default alarm timeout using UI-Streamer settings
+        const alarmTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.alarmTimeout;
+        if (alarmTimeout) {
+            alarmManager._setDefaultTimeout(alarmTimeout);
+        }
+
+        // Get trigger event
+        const triggerEventStr = await new Promise((resolve) => {
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            const message = { type: "triggerEvent", fcid: FCID };
+            const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
+            window.cefQuery({
+                request: JSON.stringify(request),
+                persistent: false,
+                onSuccess: (response) => {
+                    logger.log(`triggerEvent request successfully returned '${response}'`);
+                    resolve(response);
+                },
+                onFailure: (code, msg) => {
+                    logger.error(`triggerEvent request failed: ${code} ${msg}`);
+                    resolve("");
+                }
+            });
+        });
+        let triggerEvent = {};
+        if (triggerEventStr) {
+            try {
+                triggerEvent = JSON.parse(triggerEventStr);
+            } catch (e) {
+                sdkLogger.error(`failed to parse trigger event string ${triggerEventStr}: ${e.message}`);
+            }
+        }
+
+        // Initialize lifecycle first to make sure the state is updated.
+        await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
+        await remotePlayer._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
+
+        const devSequence = sessionInfoObj?.settings?.["ui-streamer"]?.devSequence;
+        if (devSequence) {
+            initSequenceFunc({ lifecycle, remotePlayer });
+            showSequenceFunc(true);
+        }
+
+    } else {
+        authToken = getPlatformInfo().sessionInfo?.settings?.webUI?.backendHeaders?.Authorization;
+        sdkLogger.log(`authToken dummy: token = ${authToken}`);
+    }
+
+    // override window.close() since it's not allowed to close the application this way
+    window.close = () => {
+        sdkLogger.warn("window.close is disabled on Senza platform. Use lifecycle.exitApplication() instead.");
+    };
+
+
+}
+
+// Returns the platform information, including version, pod, pod ip and session info.
+export function getPlatformInfo() {
+    if (typeof window !== "undefined" && window.diagnostics) {
+        try {
+            const platformInfo = window.diagnostics() || {};
+            platformInfo.sessionInfo = sessionInfo.sessionInfoObj;
+            return platformInfo;
+        } catch (e) {
+            sdkLogger.error("Could not get platform info", e.stack);
+        }
+
+    } else {
+        if (typeof window !== "undefined" && !window.diagnostics) {
+            sdkLogger.error("[ getPlatformInfo ] window.diagnostics is undefined");
+        }
+        return {
+            version: "X.X.XX-X",
+            pod: "ui-streamer-X.X.XX-X-QWERT-ASDFG-XXX-XXXXXX-XXXXX",
+            podIP: "0.0.0.0",
+            sessionInfo: {
+                userAgent: "SynamediaSenza/XX.YY.ZZ",
+                connectionId: "dummy",
+                deviceId: "123456789",
+                community: "LocalDev",
+                tenant: "XXXXXX",
+                tenantId: "XXXXXX",
+                manifest: {
+                    transcontainer: "X.X.XX-X"
+                },
+                settings: {
+                    webUI: {
+                        backendHeaders: {
+                            Authorization: "Bearer dummytoken"
+                        }
+                    }
+                },
+                homeSessionInfo: {
+                    tenantId: "XXXXXX",
+                    community: "LocalDev"
+                }
+            }
+        };
+    }
+}
+
+async function getToken() {
+    if (!authToken) {
+        sdkLogger.log("getToken wait for promise updateSession event");
+        return new Promise((resolve) => {
+            // Listen to updateSession event to set the new token
+            document.addEventListener("updateSession", (e) => {
+                authToken = e.detail?.updateObj;
+                sdkLogger.log(`onUpdateSessionEvent: token= ${authToken}`);
+                resolve(authToken);
+            }, { once: true });
+        });
+    }
+    return Promise.resolve(authToken);
+}
+
+function forceTokenUpdate() {
+    authToken = null;
+
+    if (window.cefQuery) {
+        const FCID = getFCID();
+        const logger = sdkLogger.withFields({ FCID });
+        logger.log("forceTokenUpdate: sending updateSessionRequest");
+        const message = {
+            type: "updateSessionRequest",
+            updateKey: "authorization",
+            parentPath: "settings.webUI.backendHeaders.Authorization",
+            fcid: FCID
+        };
+        const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
+        window.cefQuery({
+            request: JSON.stringify(request),
+            persistent: false,
+            onSuccess: () => {
+                logger.log("updateSessionRequest successfully sent");
+            },
+            onFailure: (code, msg) => {
+                logger.error(`updateSessionRequest failed: ${code} ${msg}`);
+            }
+        });
+    } else {
+        sdkLogger.error("forceTokenUpdate: window.cefQuery is undefined");
+    }
+}
+
+/** Returns a boolean that indicates whether we are running in an e2e environment, or on local browser */
+export function isRunningE2E() {
+    return !!(typeof window !== "undefined" && window.cefQuery);
+}
+
+/** Call this API once after application startup, when the ui is ready to accept keys/events */
+export function uiReady() {
+    if (window.cefQuery) {
+        window.cefQuery({
+            request: "uiReady",
+            persistent: false,
+            onSuccess: () => {
+                sdkLogger.log("uiReady request successfully sent");
+            },
+            onFailure: (code, msg) => {
+                sdkLogger.error(`uiReady request failed: ${code} ${msg}`);
+            }
+        });
+    } else {
+        sdkLogger.error("uiReady: window.cefQuery is undefined");
+    }
+}
+
+export { lifecycle } from "./lifecycle.js";
+export { deviceManager } from "./deviceManager.js";
+export { platformManager } from "./platformManager.js";
+export { alarmManager };
+export { messageManager } from "./messageManager.js";
+export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
+
+import "./devHelper.js";
+
+/**
+ * The function receives a license response and passes it to platform.
+ * @param {number} statusCode status code that was received from the license server
+ * @param {ArrayBuffer|string} licenseResponse a license response that was received from the license server to be passed to platform.
+ * @param {string} fcid a fcid received with the license request
+ * @param {string} sessionId a sessionId received with the license request
+ * In case of success licenceResponse is of type @type {ArrayBuffer}
+ * In case of error licenseResponse is of type @type {string}
+ */
+export function writeLicenseResponse(statusCode, licenseResponse, fcid, sessionId) {
+
+    if (statusCode >= 200 && statusCode < 300) {
+        licenseResponse = window.btoa(String.fromCharCode.apply(null, new Uint8Array(licenseResponse))); // to base64
+    }
+
+    if (window.cefQuery) {
+        const message = {
+            type: "updateLicense",
+            sessionId,
+            fcid
+        };
+        message[statusCode >= 200 && statusCode < 300 ? "response" : "error"] = licenseResponse;
+        const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
+        window.cefQuery({
+            request: JSON.stringify(request),
+            persistent: false,
+            onSuccess: () => {
+                sdkLogger.log("updateLicense request successfully sent");
+            },
+            onFailure: (code, msg) => {
+                sdkLogger.error(`updateLicense request failed: ${code} ${msg}`);
+            }
+        });
+    }
+
+}
+
+export class ClientAssertionError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+
+/**
+ * @typedef Token
+ * @property {string} hostplatform_assertion The client assertion token.
+*/
+
+/**
+ * Async function that returns the client assertion
+ * @return {Promise<Token>} Promise which is resolved to a client assertion object when getClientAssertion has been successfully performed. * client assertion object contains hostplatform_assertion property which holds the client assertion token.
+ * Failure to getClientAssertion for any reason, result in the promise being rejected.
+ * Error status codes:
+ * Status code 400 - Tenant configuration is missing
+ * Status code 0 - General error
+ *  @example
+ * try {
+ *     const client_assertion = await auth.getClientAssertion();
+ *     console.log("Client assertion token is", client_assertion.hostplatform_assertion);
+ * } catch (e) {
+ *     console.error("getClientAssertion failed", e);
+ * }
+ */
+export function getClientAssertion() {
+    if (window.cefQuery) {
+        sdkLogger.log("getClientAssertion is called");
+
+        return new Promise((resolve, reject) => {
+            window.cefQuery({
+                request: "client_assertion",
+                persistent: false,
+                onSuccess: (response) => {
+                    try {
+                        const json_response = JSON.parse(response);
+                        sdkLogger.log(`client_assertion request successfully returned ${response}`);
+                        resolve(json_response);
+                    } catch (e) {
+                        sdkLogger.error(`Failed to parse client assertion ${response}: ${e.message}`);
+                        reject(new ClientAssertionError(0, "Failed to parse client assertion"));
+                    }
+
+                },
+                onFailure: (code, msg) => {
+                    sdkLogger.log(`client_assertion request failed: ${code} ${msg}`);
+                    reject(new ClientAssertionError(code, msg));
+                }
+            });
+        });
+    }
+    sdkLogger.warn("getClientAssertion is not supported if NOT running e2e");
+}
+
+import * as senzaSDK from "./api.js";
+if (typeof window !== "undefined") {
+    window.senzaSDKImplementation = window.senzaSDKImplementation || senzaSDK; // this is only for testing purposes which allows us to use and test senza APIs in pipeline tests
+}

package/src/{deviceManager.js → implementation/deviceManager.js}

@@ -1,5 +1,5 @@
+import { DeviceManager as DeviceManagerInterface } from "../interface/deviceManager";
 import { getFCID, sdkLogger, getRestResponse } from "./utils";
-import { isRunningE2E } from "./api";
 import { sessionInfo } from "./SessionInfo";
 
 const wifiInfo = {};
@@ -35,10 +35,7 @@ async function getWifiStatus() {
     }
 }
 
-/**
- * DeviceManager is a singleton class that manages the device
- */
-class DeviceManager extends EventTarget {
+class DeviceManager extends DeviceManagerInterface {
 
     constructor() {
         super();
@@ -46,15 +43,7 @@ class DeviceManager extends EventTarget {
         wifiInfo.quality = 0;
         wifiInfo.ssid = "unknown";
         wifiInfo.bssid = "unknown";
-        /**
-         * @deprecated Instead, call deviceManager.getWifiInfo() periodically
-         * @event DeviceManager#wifiInfoUpdated
-         * @example
-         * deviceManager.addEventListener("wifiInfoUpdated", () => {
-         *   console.info("Wifi info has been updated to", deviceManager.wifiInfo);
-         * });
-         *
-         */
+
         typeof document !== "undefined" && document.addEventListener("wifiSignalReport", (e) => {
             wifiInfo.level = e.detail.level;
             wifiInfo.quality = e.detail.quality;
@@ -65,20 +54,9 @@ class DeviceManager extends EventTarget {
 
     }
 
-    /**
-     * @property {object} DeviceInfo
-     * @property {string} DeviceInfo.deviceId
-     * @property {string} DeviceInfo.modelNumber
-     * @property {string} DeviceInfo.connectionId
-     * @property {string} DeviceInfo.community
-     * @property {string} DeviceInfo.tenant
-     * @property {string} DeviceInfo.clientIp
-     * @property {string} DeviceInfo.countryCode A 2-letter code as defined in ISO_3166-1
-     * @property {string} DeviceInfo.connectionType The type of device used during the current connection. Possible values are "device" which mean real device, "simulator" - simulated device - that used during development.
-     */
     get deviceInfo() {
         const sessionInfoObj = sessionInfo.sessionInfoObj;
-        if (isRunningE2E() && sessionInfoObj) {
+        if (sessionInfoObj) {
             return {
                 deviceId: sessionInfoObj.deviceId,
                 modelNumber: sessionInfoObj.modelNumber,
@@ -90,36 +68,13 @@ class DeviceManager extends EventTarget {
                 connectionType: (!sessionInfoObj.connectionType || sessionInfoObj.connectionType === "direct") ? "device" : sessionInfoObj.connectionType
             };
         }
-        sdkLogger.log("getDeviceInfo running locally, returning dummy info");
-        return {
-            deviceId: "123456789",
-            modelNumber: "ABC",
-            connectionId: "dummy",
-            community: "LocalDev",
-            tenant: "XXXXXX",
-            clientIp: "0.0.0.0",
-            countryCode: "XX",
-            connectionType: "simulator"
-        };
+        return super.deviceInfo;
     }
 
-    /**
-     * @deprecated use deviceManager.getWifiInfo() instead
-     * @property {object} WifiInfo
-     * @property {number} WifiInfo.level
-     * @property {number} WifiInfo.quality
-     * @property {string} WifiInfo.ssid
-     * @property {string} WifiInfo.bssid
-     */
     get wifiInfo() {
         return wifiInfo;
     }
 
-    /**
-     * Reboot the device
-     * @return {Promise} Promise which is resolved when the reboot command has been successfully processed.
-     * Failure to process the reboot command will result in the promise being rejected.
-     */
     reboot() {
         return new Promise((resolve, reject) => {
             if (window.cefQuery) {
@@ -149,11 +104,6 @@ class DeviceManager extends EventTarget {
         });
     }
 
-    /**
-     * Delete current wifi configuration and forget network
-     * @return {Promise} Promise which is resolved when the clearWifi command has been successfully processed.
-     * Failure to process the clearWifi command will result in the promise being rejected.
-     */
     clearWifi() {
         return new Promise((resolve, reject) => {
             const FCID = getFCID();
@@ -178,16 +128,6 @@ class DeviceManager extends EventTarget {
         });
     }
 
-    /**
-     * Send raw data directly to a customer's device via the USB serial connection of a Senza device.
-     * This function is specifically designed for customers who have their devices connected to a Senza device.
-     * Using this API, these customers can transmit messages or data directly to their connected devices.
-     * The transmission occurs through the Senza device's USB serial interface, facilitating direct communication
-     * between the customer's web application and their device.
-     * @param {String} data raw data to be passed to the device
-     * @return {Promise} Promise which is resolved when the command has been successfully processed.
-     * Failure to process the command will result in the promise being rejected.
-     */
     sendDataToDevice(data) {
         if (typeof data !== "string") {
             throw new Error("data must be of type 'string'");
@@ -219,12 +159,6 @@ class DeviceManager extends EventTarget {
         });
     }
 
-    /**
-     * Perform device factory reset.
-     * @param {Boolean} [reboot=true] a flag that is passed to the device to indicate whether it should reboot after the factory reset. defaults to true.
-     * @return {Promise} Promise which is resolved when factoryReset has been successfully performed
-     * Failure to factoryReset for any reason, result in the promise being rejected.
-     */
     async factoryReset(reboot = true) {
         if (typeof reboot !== "boolean") {
             throw new Error("reboot param must be of type 'boolean'");
@@ -282,12 +216,6 @@ class DeviceManager extends EventTarget {
      * @property {number}   quality a measure of the signal quality, in the range 0 to 100 (the higher, the better). The quality value is derived from the signal EVM.
      * */
 
-    /**
-     * Get Wi-Fi info - access point data and status (the status is cached for 5 seconds)
-     * @returns {WiFiInfo} An object containing the Wi-Fi info
-     * @alpha API has not yet been released
-     * */
-    // This api is part of epic HSDEV-4185
     async getWifiInfo() {
         await Promise.all([getWifiApData(), getWifiStatus()]);
         return { ...wifi_ap_data, ...wifi_status };
@@ -295,7 +223,7 @@ class DeviceManager extends EventTarget {
 }
 
 /**
- *
+
  * @module
  * @example
  * import { deviceManager } from "senza-sdk";