homebridge-adt-pulse 3.0.0-beta.3 → 3.0.0-beta.5

package/build/src/lib/api.js

@@ -0,0 +1,1876 @@
+import axios from 'axios';
+import { wrapper } from 'axios-cookiejar-support';
+import { JSDOM } from 'jsdom';
+import _ from 'lodash';
+import { serializeError } from 'serialize-error';
+import { CookieJar } from 'tough-cookie';
+import { detectedNewDoSubmitHandlers, detectedNewGatewayInformation, detectedNewOrbSecurityButtons, detectedNewPanelInformation, detectedNewPanelStatus, detectedNewPortalVersion, detectedNewSensorsInformation, detectedNewSensorsStatus, } from './detect.js';
+import { paramNetworkId, paramSat, requestPathAccessSignIn, requestPathAccessSignInENsPartnerAdt, requestPathAccessSignInNetworkIdXxPartnerAdt, requestPathAjaxSyncCheckServTXx, requestPathKeepAlive, requestPathMfaMfaSignInWorkflowChallenge, requestPathQuickControlArmDisarm, requestPathQuickControlServRunRraCommand, requestPathSummarySummary, requestPathSystemDeviceId1, requestPathSystemGateway, requestPathSystemSystem, textPanelEmergencyKeys, } from './regex.js';
+import { debugLog, fetchErrorMessage, fetchMissingSatCode, fetchTableCells, findNullKeys, generateDynatracePCHeaderValue, generateHash, isPortalSyncCode, parseArmDisarmMessage, parseDoSubmitHandlers, parseOrbSecurityButtons, parseOrbSensors, parseOrbTextSummary, parseSensorsTable, sleep, stackTracer, } from './utility.js';
+export class ADTPulse {
+    #credentials;
+    #internal;
+    #session;
+    constructor(config, internalConfig) {
+        this.#credentials = {
+            fingerprint: config.fingerprint,
+            password: config.password,
+            subdomain: config.subdomain,
+            username: config.username,
+        };
+        this.#internal = {
+            baseUrl: internalConfig.baseUrl ?? `https://${this.#credentials.subdomain}.adtpulse.com`,
+            debug: internalConfig.debug ?? false,
+            logger: internalConfig.logger ?? null,
+            reportedHashes: [],
+            testMode: {
+                enabled: internalConfig.testMode?.enabled ?? false,
+                isDisarmChecked: internalConfig.testMode?.isDisarmChecked ?? false,
+            },
+        };
+        this.#session = {
+            backupSatCode: null,
+            httpClient: wrapper(axios.create({
+                jar: new CookieJar(),
+            })),
+            isAuthenticated: false,
+            isCleanState: true,
+            networkId: null,
+            portalVersion: null,
+        };
+    }
+    async login() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'info', `Attempting to login to "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'LOGIN',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            if (this.isAuthenticated()) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'info', [
+                        'Already logged in',
+                        [
+                            '(',
+                            [
+                                `backup sat code: ${this.#session.backupSatCode}`,
+                                `network id: ${this.#session.networkId}`,
+                                `portal version: ${this.#session.portalVersion}`,
+                            ].join(', '),
+                            ')',
+                        ].join(''),
+                    ].join(' '));
+                }
+                return {
+                    action: 'LOGIN',
+                    success: true,
+                    info: {
+                        backupSatCode: this.#session.backupSatCode,
+                        networkId: this.#session.networkId,
+                        portalVersion: this.#session.portalVersion,
+                    },
+                };
+            }
+            sessions.axiosIndex = await this.#session.httpClient.get(`${this.#internal.baseUrl}/`, this.getRequestConfig());
+            if (typeof sessions.axiosIndex?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'LOGIN',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosIndexRequestPath = sessions.axiosIndex.request.path;
+            const axiosIndexRequestPathValid = requestPathAccessSignIn.test(axiosIndexRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'info', `Request path ➜ ${axiosIndexRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'info', `Request path valid ➜ ${axiosIndexRequestPathValid}`);
+            }
+            if (!axiosIndexRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'error', `"${axiosIndexRequestPath} is not the sign-in page`);
+                }
+                this.handleLoginFailure(axiosIndexRequestPath, sessions.axiosIndex);
+                return {
+                    action: 'LOGIN',
+                    success: false,
+                    info: {
+                        message: `"${axiosIndexRequestPath} is not the sign-in page`,
+                    },
+                };
+            }
+            const loginForm = new URLSearchParams();
+            loginForm.append('usernameForm', this.#credentials.username);
+            loginForm.append('passwordForm', this.#credentials.password);
+            loginForm.append('sun', 'yes');
+            loginForm.append('networkid', '');
+            loginForm.append('fingerprint', this.#credentials.fingerprint);
+            this.#session.portalVersion = axiosIndexRequestPath.replace(requestPathAccessSignIn, '$2');
+            await this.newInformationDispatcher('portal-version', { version: this.#session.portalVersion });
+            sessions.axiosSignin = await this.#session.httpClient.post(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/access/signin.jsp?e=ns&partner=adt`, loginForm, this.getRequestConfig({
+                headers: {
+                    'Cache-Control': 'max-age=0',
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Origin: this.#internal.baseUrl,
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/access/signin.jsp?e=ns&partner=adt`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSignin?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'LOGIN',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSigninRequestPath = sessions.axiosSignin.request.path;
+            const axiosSigninRequestPathValid = requestPathSummarySummary.test(axiosSigninRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'info', `Request path ➜ ${axiosSigninRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'info', `Request path valid ➜ ${axiosSigninRequestPathValid}`);
+            }
+            if (!axiosSigninRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'error', `"${axiosSigninRequestPath}" is not the summary page`);
+                }
+                this.handleLoginFailure(axiosSigninRequestPath, sessions.axiosSignin);
+                return {
+                    action: 'LOGIN',
+                    success: false,
+                    info: {
+                        message: `"${axiosSigninRequestPath}" is not the summary page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSignin.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'error', 'The response body of the summary page is not of type "string"');
+                }
+                return {
+                    action: 'LOGIN',
+                    success: false,
+                    info: {
+                        message: 'The response body of the summary page is not of type "string"',
+                    },
+                };
+            }
+            const matchNetworkId = sessions.axiosSignin.data.match(paramNetworkId);
+            this.#session.networkId = (matchNetworkId !== null && matchNetworkId.length >= 2) ? matchNetworkId[1] : null;
+            const matchSatCode = sessions.axiosSignin.data.match(paramSat);
+            this.#session.backupSatCode = (matchSatCode !== null && matchSatCode.length >= 2) ? matchSatCode[1] : null;
+            if (this.#session.backupSatCode === null && this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'warn', 'Unable to backup sat code, will try again when system becomes available');
+            }
+            this.#session.isAuthenticated = true;
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'success', [
+                    'Login successful',
+                    [
+                        '(',
+                        [
+                            `backup sat code: ${this.#session.backupSatCode}`,
+                            `network id: ${this.#session.networkId}`,
+                            `portal version: ${this.#session.portalVersion}`,
+                        ].join(', '),
+                        ')',
+                    ].join(''),
+                ].join(' '));
+            }
+            return {
+                action: 'LOGIN',
+                success: true,
+                info: {
+                    backupSatCode: this.#session.backupSatCode,
+                    networkId: this.#session.networkId,
+                    portalVersion: this.#session.portalVersion,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.login()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'LOGIN',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async logout() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'info', `Attempting to logout of "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'LOGOUT',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            if (!this.isAuthenticated()) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'info', [
+                        'Already logged out',
+                        [
+                            '(',
+                            [
+                                `backup sat code: ${this.#session.backupSatCode}`,
+                                `network id: ${this.#session.networkId}`,
+                                `portal version: ${this.#session.portalVersion}`,
+                            ].join(', '),
+                            ')',
+                        ].join(''),
+                    ].join(' '));
+                }
+                return {
+                    action: 'LOGOUT',
+                    success: true,
+                    info: {
+                        backupSatCode: this.#session.backupSatCode,
+                        networkId: this.#session.networkId,
+                        portalVersion: this.#session.portalVersion,
+                    },
+                };
+            }
+            sessions.axiosSignout = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/access/signout.jsp?networkid=${this.#session.networkId}&partner=adt`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSignout?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'LOGOUT',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSignoutRequestPath = sessions.axiosSignout.request.path;
+            const axiosSignoutRequestPathValid = requestPathAccessSignInNetworkIdXxPartnerAdt.test(axiosSignoutRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'info', `Request path ➜ ${axiosSignoutRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'info', `Request path valid ➜ ${axiosSignoutRequestPathValid}`);
+            }
+            if (!axiosSignoutRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'error', `"${axiosSignoutRequestPath}" is not the sign-in page with "networkid" and "partner=adt" parameters`);
+                }
+                this.handleLoginFailure(axiosSignoutRequestPath, sessions.axiosSignout);
+                return {
+                    action: 'LOGOUT',
+                    success: false,
+                    info: {
+                        message: `"${axiosSignoutRequestPath}" is not the sign-in page with "networkid" and "partner=adt" parameters`,
+                    },
+                };
+            }
+            this.resetSession();
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'success', [
+                    'Logout successful',
+                    [
+                        '(',
+                        [
+                            `backup sat code: ${this.#session.backupSatCode}`,
+                            `network id: ${this.#session.networkId}`,
+                            `portal version: ${this.#session.portalVersion}`,
+                        ].join(', '),
+                        ')',
+                    ].join(''),
+                ].join(' '));
+            }
+            return {
+                action: 'LOGOUT',
+                success: true,
+                info: {
+                    backupSatCode: this.#session.backupSatCode,
+                    networkId: this.#session.networkId,
+                    portalVersion: this.#session.portalVersion,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.logout()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'LOGOUT',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async getGatewayInformation() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'info', `Attempting to retrieve gateway information from "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'GET_GATEWAY_INFORMATION',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosSystemGateway = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/system/gateway.jsp`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/system/system.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                    'Sec-Fetch-User': undefined,
+                },
+            }));
+            if (typeof sessions.axiosSystemGateway?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'GET_GATEWAY_INFORMATION',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSystemGatewayRequestPath = sessions.axiosSystemGateway.request.path;
+            const axiosSystemGatewayRequestPathValid = requestPathSystemGateway.test(axiosSystemGatewayRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'info', `Request path ➜ ${axiosSystemGatewayRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'info', `Request path valid ➜ ${axiosSystemGatewayRequestPathValid}`);
+            }
+            if (!axiosSystemGatewayRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'error', `"${axiosSystemGatewayRequestPath}" is not the system gateway page`);
+                }
+                this.handleLoginFailure(axiosSystemGatewayRequestPath, sessions.axiosSystemGateway);
+                return {
+                    action: 'GET_GATEWAY_INFORMATION',
+                    success: false,
+                    info: {
+                        message: `"${axiosSystemGatewayRequestPath}" is not the system gateway page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSystemGateway.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'error', 'The response body of the system gateway page is not of type "string"');
+                }
+                return {
+                    action: 'GET_GATEWAY_INFORMATION',
+                    success: false,
+                    info: {
+                        message: 'The response body of the system gateway page is not of type "string"',
+                    },
+                };
+            }
+            sessions.jsdomSystemGateway = new JSDOM(sessions.axiosSystemGateway.data, {
+                url: sessions.axiosSystemGateway.config.url,
+                referrer: sessions.axiosSystemGateway.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomSystemGatewayTableCells = sessions.jsdomSystemGateway.window.document.querySelectorAll('td');
+            const fetchedTableCells = fetchTableCells(jsdomSystemGatewayTableCells, [
+                'Broadband Connection Status:',
+                'Broadband LAN IP Address:',
+                'Broadband LAN MAC:',
+                'Cellular Connection Status:',
+                'Cellular Signal Strength:',
+                'Device LAN IP Address:',
+                'Device LAN MAC:',
+                'Firmware Version:',
+                'Hardware Version:',
+                'Last Update:',
+                'Manufacturer:',
+                'Model:',
+                'Next Update:',
+                'Primary Connection Type:',
+                'Router LAN IP Address:',
+                'Router WAN IP Address:',
+                'Serial Number:',
+                'Status:',
+            ], 1, 1);
+            const gatewayInformation = {
+                communication: {
+                    primaryConnectionType: _.get(fetchedTableCells, ['Primary Connection Type:', 0], null),
+                    broadbandConnectionStatus: _.get(fetchedTableCells, ['Broadband Connection Status:', 0], null),
+                    cellularConnectionStatus: _.get(fetchedTableCells, ['Cellular Connection Status:', 0], null),
+                    cellularSignalStrength: _.get(fetchedTableCells, ['Cellular Signal Strength:', 0], null),
+                },
+                manufacturer: _.get(fetchedTableCells, ['Manufacturer:', 0], null),
+                model: _.get(fetchedTableCells, ['Model:', 0], null),
+                network: {
+                    broadband: {
+                        ip: _.get(fetchedTableCells, ['Broadband LAN IP Address:', 0], null),
+                        mac: _.get(fetchedTableCells, ['Broadband LAN MAC:', 0], null),
+                    },
+                    device: {
+                        ip: _.get(fetchedTableCells, ['Device LAN IP Address:', 0], null),
+                        mac: _.get(fetchedTableCells, ['Device LAN MAC:', 0], null),
+                    },
+                    router: {
+                        lanIp: _.get(fetchedTableCells, ['Router LAN IP Address:', 0], null),
+                        wanIp: _.get(fetchedTableCells, ['Router WAN IP Address:', 0], null),
+                    },
+                },
+                serialNumber: _.get(fetchedTableCells, ['Serial Number:', 0], null),
+                status: _.get(fetchedTableCells, ['Status:', 0], null),
+                update: {
+                    last: _.get(fetchedTableCells, ['Last Update:', 0], null),
+                    next: _.get(fetchedTableCells, ['Next Update:', 0], null),
+                },
+                versions: {
+                    firmware: _.get(fetchedTableCells, ['Firmware Version:', 0], null),
+                    hardware: _.get(fetchedTableCells, ['Hardware Version:', 0], null),
+                },
+            };
+            await this.newInformationDispatcher('gateway-information', gatewayInformation);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'success', `Successfully retrieved gateway information from "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'GET_GATEWAY_INFORMATION',
+                success: true,
+                info: gatewayInformation,
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getGatewayInformation()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'GET_GATEWAY_INFORMATION',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async getPanelInformation() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'info', `Attempting to retrieve panel information from "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'GET_PANEL_INFORMATION',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosSystemDeviceId1 = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/system/device.jsp?id=1`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/system/system.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSystemDeviceId1?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'GET_PANEL_INFORMATION',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSystemDeviceId1RequestPath = sessions.axiosSystemDeviceId1.request.path;
+            const axiosSystemDeviceId1RequestPathValid = requestPathSystemDeviceId1.test(axiosSystemDeviceId1RequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'info', `Request path ➜ ${axiosSystemDeviceId1RequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'info', `Request path valid ➜ ${axiosSystemDeviceId1RequestPathValid}`);
+            }
+            if (!axiosSystemDeviceId1RequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'error', `"${axiosSystemDeviceId1RequestPath}" is not the system device id 1 page`);
+                }
+                this.handleLoginFailure(axiosSystemDeviceId1RequestPath, sessions.axiosSystemDeviceId1);
+                return {
+                    action: 'GET_PANEL_INFORMATION',
+                    success: false,
+                    info: {
+                        message: `"${axiosSystemDeviceId1RequestPath}" is not the system device id 1 page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSystemDeviceId1.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'error', 'The response body of the system device id 1 page is not of type "string"');
+                }
+                return {
+                    action: 'GET_PANEL_INFORMATION',
+                    success: false,
+                    info: {
+                        message: 'The response body of the system device id 1 page is not of type "string"',
+                    },
+                };
+            }
+            sessions.jsdomSystemDeviceId1 = new JSDOM(sessions.axiosSystemDeviceId1.data, {
+                url: sessions.axiosSystemDeviceId1.config.url,
+                referrer: sessions.axiosSystemDeviceId1.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomSystemDeviceId1TableCells = sessions.jsdomSystemDeviceId1.window.document.querySelectorAll('td');
+            const fetchedTableCells = fetchTableCells(jsdomSystemDeviceId1TableCells, [
+                'Emergency Keys:',
+                'Manufacturer/Provider:',
+                'Security Panel Master Code:',
+                'Status:',
+                'Type/Model:',
+            ], 1, 1);
+            const emergencyKeys = _.get(fetchedTableCells, ['Emergency Keys:', 0], null);
+            const parsedEmergencyKeys = (typeof emergencyKeys === 'string') ? emergencyKeys.match(textPanelEmergencyKeys) : null;
+            const manufacturerProvider = _.get(fetchedTableCells, ['Manufacturer/Provider:', 0], null);
+            const parsedManufacturer = (typeof manufacturerProvider === 'string') ? manufacturerProvider.split(' - ')[0] ?? null : null;
+            const parsedProvider = (typeof manufacturerProvider === 'string') ? manufacturerProvider.split(' - ')[1] ?? null : null;
+            const typeModel = _.get(fetchedTableCells, ['Type/Model:', 0], null);
+            const parsedType = (typeof typeModel === 'string') ? typeModel.split(' - ')[0] ?? null : null;
+            const parsedModel = (typeof typeModel === 'string') ? typeModel.split(' - ')[1] ?? null : null;
+            const panelInformation = {
+                emergencyKeys: parsedEmergencyKeys,
+                manufacturer: parsedManufacturer,
+                masterCode: _.get(fetchedTableCells, ['Security Panel Master Code:', 0], null),
+                provider: parsedProvider,
+                type: parsedType,
+                model: parsedModel,
+                status: _.get(fetchedTableCells, ['Status:', 0], null),
+            };
+            await this.newInformationDispatcher('panel-information', panelInformation);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'success', `Successfully retrieved panel information from "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'GET_PANEL_INFORMATION',
+                success: true,
+                info: panelInformation,
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelInformation()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'GET_PANEL_INFORMATION',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async getPanelStatus() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'info', `Attempting to retrieve panel status from "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'GET_PANEL_STATUS',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosSummary = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSummary?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'GET_PANEL_STATUS',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSummaryRequestPath = sessions.axiosSummary.request.path;
+            const axiosSummaryRequestPathValid = requestPathSummarySummary.test(axiosSummaryRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'info', `Request path ➜ ${axiosSummaryRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'info', `Request path valid ➜ ${axiosSummaryRequestPathValid}`);
+            }
+            if (!axiosSummaryRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'error', `"${axiosSummaryRequestPath}" is not the summary page`);
+                }
+                this.handleLoginFailure(axiosSummaryRequestPath, sessions.axiosSummary);
+                return {
+                    action: 'GET_PANEL_STATUS',
+                    success: false,
+                    info: {
+                        message: `"${axiosSummaryRequestPath}" is not the summary page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSummary.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'error', 'The response body of the summary page is not of type "string"');
+                }
+                return {
+                    action: 'GET_PANEL_STATUS',
+                    success: false,
+                    info: {
+                        message: 'The response body of the summary page is not of type "string"',
+                    },
+                };
+            }
+            if (this.#session.backupSatCode === null) {
+                const missingSatCode = fetchMissingSatCode(sessions.axiosSummary);
+                if (missingSatCode !== null) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'success', 'Backup sat code was successfully recovered from previous failed retrieval');
+                    }
+                    this.#session.backupSatCode = missingSatCode;
+                }
+            }
+            sessions.jsdomSummary = new JSDOM(sessions.axiosSummary.data, {
+                url: sessions.axiosSummary.config.url,
+                referrer: sessions.axiosSummary.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomSummaryOrbTextSummary = sessions.jsdomSummary.window.document.querySelector('#divOrbTextSummary');
+            const parsedOrbTextSummary = parseOrbTextSummary(jsdomSummaryOrbTextSummary);
+            await this.newInformationDispatcher('panel-status', parsedOrbTextSummary);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'success', `Successfully retrieved panel status from "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'GET_PANEL_STATUS',
+                success: true,
+                info: parsedOrbTextSummary,
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getPanelStatus()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'GET_PANEL_STATUS',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async setPanelStatus(armTo) {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'info', `Attempting to update panel status to "${armTo}" at "${this.#internal.baseUrl}"`);
+        }
+        if (armTo !== 'away'
+            && armTo !== 'night'
+            && armTo !== 'off'
+            && armTo !== 'stay') {
+            return {
+                action: 'SET_PANEL_STATUS',
+                success: false,
+                info: {
+                    message: `"${armTo}" is an invalid arm to state`,
+                },
+            };
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'SET_PANEL_STATUS',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosSummary = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSummary?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'SET_PANEL_STATUS',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSummaryRequestPath = sessions.axiosSummary.request.path;
+            const axiosSummaryRequestPathValid = requestPathSummarySummary.test(axiosSummaryRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'info', `Request path ➜ ${axiosSummaryRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'info', `Request path valid ➜ ${axiosSummaryRequestPathValid}`);
+            }
+            if (!axiosSummaryRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', `"${axiosSummaryRequestPath}" is not the summary page`);
+                }
+                this.handleLoginFailure(axiosSummaryRequestPath, sessions.axiosSummary);
+                return {
+                    action: 'SET_PANEL_STATUS',
+                    success: false,
+                    info: {
+                        message: `"${axiosSummaryRequestPath}" is not the summary page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSummary.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'The response body of the summary page is not of type "string"');
+                }
+                return {
+                    action: 'SET_PANEL_STATUS',
+                    success: false,
+                    info: {
+                        message: 'The response body of the summary page is not of type "string"',
+                    },
+                };
+            }
+            if (this.#session.backupSatCode === null) {
+                const missingSatCode = fetchMissingSatCode(sessions.axiosSummary);
+                if (missingSatCode !== null) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'success', 'Backup sat code was successfully recovered from previous failed retrieval');
+                    }
+                    this.#session.backupSatCode = missingSatCode;
+                }
+            }
+            sessions.jsdomSummary = new JSDOM(sessions.axiosSummary.data, {
+                url: sessions.axiosSummary.config.url,
+                referrer: sessions.axiosSummary.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomSummaryOrbSecurityButtons = sessions.jsdomSummary.window.document.querySelectorAll('#divOrbSecurityButtons input');
+            const parsedOrbSecurityButtons = parseOrbSecurityButtons(jsdomSummaryOrbSecurityButtons);
+            await this.newInformationDispatcher('orb-security-buttons', parsedOrbSecurityButtons);
+            const armingNightButtonIndex = parsedOrbSecurityButtons.findIndex((parsedOrbSecurityButton) => {
+                const parsedOrbSecurityButtonButtonDisabled = parsedOrbSecurityButton.buttonDisabled;
+                const parsedOrbSecurityButtonButtonText = parsedOrbSecurityButton.buttonText;
+                return (parsedOrbSecurityButtonButtonDisabled && parsedOrbSecurityButtonButtonText === 'Arming Night');
+            });
+            if (this.#session.backupSatCode !== null
+                && armingNightButtonIndex >= 0) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'warn', 'Replacing the stuck "Arming Night" button with a fake "Disarm" button');
+                }
+                parsedOrbSecurityButtons[armingNightButtonIndex] = {
+                    buttonDisabled: false,
+                    buttonId: 'security_button_0',
+                    buttonIndex: 0,
+                    buttonText: 'Disarm',
+                    changeAccessCode: false,
+                    loadingText: 'Disarming',
+                    relativeUrl: 'quickcontrol/armDisarm.jsp',
+                    totalButtons: 1,
+                    urlParams: {
+                        arm: 'off',
+                        armState: (this.#session.isCleanState) ? 'night' : 'night+stay',
+                        href: 'rest/adt/ui/client/security/setArmState',
+                        sat: this.#session.backupSatCode,
+                    },
+                };
+            }
+            let readyButtons = parsedOrbSecurityButtons.filter((parsedOrbSecurityButton) => !parsedOrbSecurityButton.buttonDisabled);
+            if (readyButtons.length < 1) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'Security buttons are not found on the summary page');
+                }
+                return {
+                    action: 'SET_PANEL_STATUS',
+                    success: false,
+                    info: {
+                        message: 'Security buttons are not found on the summary page',
+                    },
+                };
+            }
+            if (this.#internal.testMode.enabled
+                && !this.#internal.testMode.isDisarmChecked) {
+                if (!['off', 'disarmed'].includes(readyButtons[0].urlParams.armState)) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'Test mode is active and system is not disarmed');
+                    }
+                    return {
+                        action: 'SET_PANEL_STATUS',
+                        success: false,
+                        info: {
+                            message: 'Test mode is active and system is not disarmed',
+                        },
+                    };
+                }
+                this.#internal.testMode.isDisarmChecked = true;
+            }
+            while (!['off', 'disarmed'].includes(readyButtons[0].urlParams.armState)) {
+                const armDisarmResponse = await this.armDisarmHandler(readyButtons[0].relativeUrl, readyButtons[0].urlParams.href, readyButtons[0].urlParams.armState, 'off', readyButtons[0].urlParams.sat);
+                if (!armDisarmResponse.success) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'An error occurred in the arm disarm handler (while disarming)');
+                    }
+                    return {
+                        action: 'SET_PANEL_STATUS',
+                        success: false,
+                        info: armDisarmResponse.info,
+                    };
+                }
+                if (armDisarmResponse.info.readyButtons.length < 1) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'Arm disarm handler failed to find new security buttons');
+                    }
+                    return {
+                        action: 'SET_PANEL_STATUS',
+                        success: false,
+                        info: {
+                            message: 'Arm disarm handler failed to find new security buttons',
+                        },
+                    };
+                }
+                readyButtons = armDisarmResponse.info.readyButtons;
+            }
+            let forceArmRequired = false;
+            if (armTo !== 'off') {
+                const armDisarmResponse = await this.armDisarmHandler(readyButtons[0].relativeUrl, readyButtons[0].urlParams.href, readyButtons[0].urlParams.armState, armTo, readyButtons[0].urlParams.sat);
+                if (!armDisarmResponse.success) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'An error occurred in the arm disarm handler (while arming)');
+                    }
+                    return {
+                        action: 'SET_PANEL_STATUS',
+                        success: false,
+                        info: armDisarmResponse.info,
+                    };
+                }
+                forceArmRequired = armDisarmResponse.info.forceArmRequired;
+            }
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'success', `Successfully updated panel status to "${armTo}" at "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'SET_PANEL_STATUS',
+                success: true,
+                info: {
+                    forceArmRequired,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.setPanelStatus()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'SET_PANEL_STATUS',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async getSensorsInformation() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'info', `Attempting to retrieve sensors information from "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'GET_SENSORS_INFORMATION',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosSystem = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/system/system.jsp`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSystem?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'GET_SENSORS_INFORMATION',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSystemRequestPath = sessions.axiosSystem.request.path;
+            const axiosSystemRequestPathValid = requestPathSystemSystem.test(axiosSystemRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'info', `Request path ➜ ${axiosSystemRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'info', `Request path valid ➜ ${axiosSystemRequestPathValid}`);
+            }
+            if (!axiosSystemRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'error', `"${axiosSystemRequestPath}" is not the system page`);
+                }
+                this.handleLoginFailure(axiosSystemRequestPath, sessions.axiosSystem);
+                return {
+                    action: 'GET_SENSORS_INFORMATION',
+                    success: false,
+                    info: {
+                        message: `"${axiosSystemRequestPath}" is not the system page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSystem.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'error', 'The response body of the system page is not of type "string"');
+                }
+                return {
+                    action: 'GET_SENSORS_INFORMATION',
+                    success: false,
+                    info: {
+                        message: 'The response body of the system page is not of type "string"',
+                    },
+                };
+            }
+            sessions.jsdomSystem = new JSDOM(sessions.axiosSystem.data, {
+                url: sessions.axiosSystem.config.url,
+                referrer: sessions.axiosSystem.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomSystemSensorsTable = sessions.jsdomSystem.window.document.querySelectorAll('#systemContentList tr[onclick^="goToUrl(\'device.jsp?id="]');
+            const parsedSensorsTable = parseSensorsTable(jsdomSystemSensorsTable);
+            await this.newInformationDispatcher('sensors-information', parsedSensorsTable);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'success', `Successfully retrieved sensors information from "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'GET_SENSORS_INFORMATION',
+                success: true,
+                info: {
+                    sensors: parsedSensorsTable,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsInformation()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'GET_SENSORS_INFORMATION',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async getSensorsStatus() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'info', `Attempting to retrieve sensors status from "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'GET_SENSORS_STATUS',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosSummary = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSummary?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'GET_SENSORS_STATUS',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSummaryRequestPath = sessions.axiosSummary.request.path;
+            const axiosSummaryRequestPathValid = requestPathSummarySummary.test(axiosSummaryRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'info', `Request path ➜ ${axiosSummaryRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'info', `Request path valid ➜ ${axiosSummaryRequestPathValid}`);
+            }
+            if (!axiosSummaryRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'error', `"${axiosSummaryRequestPath}" is not the summary page`);
+                }
+                this.handleLoginFailure(axiosSummaryRequestPath, sessions.axiosSummary);
+                return {
+                    action: 'GET_SENSORS_STATUS',
+                    success: false,
+                    info: {
+                        message: `"${axiosSummaryRequestPath}" is not the summary page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSummary.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'error', 'The response body of the summary page is not of type "string"');
+                }
+                return {
+                    action: 'GET_SENSORS_STATUS',
+                    success: false,
+                    info: {
+                        message: 'The response body of the summary page is not of type "string"',
+                    },
+                };
+            }
+            if (this.#session.backupSatCode === null) {
+                const missingSatCode = fetchMissingSatCode(sessions.axiosSummary);
+                if (missingSatCode !== null) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'success', 'Backup sat code was successfully recovered from previous failed retrieval');
+                    }
+                    this.#session.backupSatCode = missingSatCode;
+                }
+            }
+            sessions.jsdomSummary = new JSDOM(sessions.axiosSummary.data, {
+                url: sessions.axiosSummary.config.url,
+                referrer: sessions.axiosSummary.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomSummaryOrbSensors = sessions.jsdomSummary.window.document.querySelectorAll('#orbSensorsList tr.p_listRow');
+            const parsedOrbSensors = parseOrbSensors(jsdomSummaryOrbSensors);
+            await this.newInformationDispatcher('sensors-status', parsedOrbSensors);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'success', `Successfully retrieved sensors status from "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'GET_SENSORS_STATUS',
+                success: true,
+                info: {
+                    sensors: parsedOrbSensors,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.getSensorsStatus()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'GET_SENSORS_STATUS',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async performSyncCheck() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'info', `Attempting to perform a sync check from "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'PERFORM_SYNC_CHECK',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosSyncCheck = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/Ajax/SyncCheckServ?t=${Date.now()}`, this.getRequestConfig({
+                headers: {
+                    Accept: '*/*',
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Dest': 'empty',
+                    'Sec-Fetch-Mode': 'cors',
+                    'Sec-Fetch-Site': 'same-origin',
+                    'Sec-Fetch-User': undefined,
+                    'Upgrade-Insecure-Requests': undefined,
+                },
+            }));
+            if (typeof sessions.axiosSyncCheck?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'PERFORM_SYNC_CHECK',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const syncCheckRequestPath = sessions.axiosSyncCheck.request.path;
+            const syncCheckRequestPathValid = requestPathAjaxSyncCheckServTXx.test(syncCheckRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'info', `Request path ➜ ${syncCheckRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'info', `Request path valid ➜ ${syncCheckRequestPathValid}`);
+            }
+            if (!syncCheckRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'error', `"${syncCheckRequestPath}" is not the sync check page`);
+                }
+                this.handleLoginFailure(syncCheckRequestPath, sessions.axiosSyncCheck);
+                return {
+                    action: 'PERFORM_SYNC_CHECK',
+                    success: false,
+                    info: {
+                        message: `"${syncCheckRequestPath}" is not the sync check page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSyncCheck.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'error', 'The response body of the sync check page is not of type "string"');
+                }
+                return {
+                    action: 'PERFORM_SYNC_CHECK',
+                    success: false,
+                    info: {
+                        message: 'The response body of the sync check page is not of type "string"',
+                    },
+                };
+            }
+            if (!isPortalSyncCode(sessions.axiosSyncCheck.data)) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'error', 'The sync code structure is invalid');
+                }
+                return {
+                    action: 'PERFORM_SYNC_CHECK',
+                    success: false,
+                    info: {
+                        message: 'The sync code structure is invalid',
+                    },
+                };
+            }
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'success', `Successfully performed a sync check from "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'PERFORM_SYNC_CHECK',
+                success: true,
+                info: {
+                    syncCode: sessions.axiosSyncCheck.data,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.performSyncCheck()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'PERFORM_SYNC_CHECK',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async performKeepAlive() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.performKeepAlive()', 'info', `Attempting to perform a keep alive from "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'PERFORM_KEEP_ALIVE',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            sessions.axiosKeepAlive = await this.#session.httpClient.post(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/KeepAlive`, '', this.getRequestConfig({
+                headers: {
+                    Accept: '*/*',
+                    'Content-type': 'application/x-www-form-urlencoded',
+                    Origin: this.#internal.baseUrl,
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Dest': 'empty',
+                    'Sec-Fetch-Mode': 'cors',
+                    'Sec-Fetch-Site': 'same-origin',
+                    'Sec-Fetch-User': undefined,
+                    'Upgrade-Insecure-Requests': undefined,
+                    'x-dtpc': generateDynatracePCHeaderValue('keep-alive'),
+                },
+            }));
+            if (typeof sessions.axiosKeepAlive?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.performKeepAlive()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'PERFORM_KEEP_ALIVE',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosKeepAliveRequestPath = sessions.axiosKeepAlive.request.path;
+            const axiosKeepAliveRequestPathValid = requestPathKeepAlive.test(axiosKeepAliveRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.performKeepAlive()', 'info', `Request path ➜ ${axiosKeepAliveRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.performKeepAlive()', 'info', `Request path valid ➜ ${axiosKeepAliveRequestPathValid}`);
+            }
+            if (!axiosKeepAliveRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.performKeepAlive()', 'error', `"${axiosKeepAliveRequestPath}" is not the keep alive page`);
+                }
+                this.handleLoginFailure(axiosKeepAliveRequestPath, sessions.axiosKeepAlive);
+                return {
+                    action: 'PERFORM_KEEP_ALIVE',
+                    success: false,
+                    info: {
+                        message: `"${axiosKeepAliveRequestPath}" is not the keep alive page`,
+                    },
+                };
+            }
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.performKeepAlive()', 'success', `Successfully performed a keep alive from "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'PERFORM_KEEP_ALIVE',
+                success: true,
+                info: null,
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.performKeepAlive()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'PERFORM_KEEP_ALIVE',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    isAuthenticated() {
+        return this.#session.isAuthenticated;
+    }
+    async armDisarmHandler(relativeUrl, href, armState, arm, sat) {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'info', `Attempting to update arm state from "${armState}" to "${arm}" on "${this.#internal.baseUrl}"`);
+        }
+        if (armState === arm
+            || (armState === 'disarmed'
+                && arm === 'off')) {
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'info', `No need to change arm state from "${armState}" to "${arm}" due to its equivalence`);
+            }
+            return {
+                action: 'ARM_DISARM_HANDLER',
+                success: true,
+                info: {
+                    forceArmRequired: false,
+                    readyButtons: [],
+                },
+            };
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'ARM_DISARM_HANDLER',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            const armDisarmForm = new URLSearchParams();
+            armDisarmForm.append('href', href);
+            armDisarmForm.append('armstate', armState);
+            armDisarmForm.append('arm', arm);
+            armDisarmForm.append('sat', sat);
+            sessions.axiosSetArmMode = await this.#session.httpClient.post(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/${relativeUrl}`, armDisarmForm, this.getRequestConfig({
+                headers: {
+                    'Cache-Control': 'max-age=0',
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Origin: this.#internal.baseUrl,
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Dest': 'iframe',
+                    'Sec-Fetch-Mode': 'navigate',
+                    'Sec-Fetch-Site': 'same-origin',
+                    'Sec-Fetch-User': undefined,
+                },
+            }));
+            if (typeof sessions.axiosSetArmMode?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'ARM_DISARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSetArmModeRequestPath = sessions.axiosSetArmMode.request.path;
+            const axiosSetArmModeRequestPathValid = requestPathQuickControlArmDisarm.test(axiosSetArmModeRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'info', `Request path ➜ ${axiosSetArmModeRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'info', `Request path valid ➜ ${axiosSetArmModeRequestPathValid}`);
+            }
+            if (!axiosSetArmModeRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'error', `"${axiosSetArmModeRequestPath}" is not the arm disarm page`);
+                }
+                this.handleLoginFailure(axiosSetArmModeRequestPath, sessions.axiosSetArmMode);
+                return {
+                    action: 'ARM_DISARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: `"${axiosSetArmModeRequestPath}" is not the arm disarm page`,
+                    },
+                };
+            }
+            let forceArmRequired = false;
+            if (arm !== 'off') {
+                const forceArmResponse = await this.forceArmHandler(sessions.axiosSetArmMode, relativeUrl);
+                if (!forceArmResponse.success) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'error', 'An error occurred in the force arm handler');
+                    }
+                    return {
+                        action: 'ARM_DISARM_HANDLER',
+                        success: false,
+                        info: forceArmResponse.info,
+                    };
+                }
+                forceArmRequired = forceArmResponse.info.forceArmRequired;
+            }
+            this.#session.isCleanState = false;
+            await sleep(6000);
+            sessions.axiosSummary = await this.#session.httpClient.get(`${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`, this.getRequestConfig({
+                headers: {
+                    Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/summary/summary.jsp`,
+                    'Sec-Fetch-Site': 'same-origin',
+                },
+            }));
+            if (typeof sessions.axiosSummary?.request === 'undefined') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'error', 'The HTTP client responded without the "request" object');
+                }
+                return {
+                    action: 'ARM_DISARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: 'The HTTP client responded without the "request" object',
+                    },
+                };
+            }
+            const axiosSummaryRequestPath = sessions.axiosSummary.request.path;
+            const axiosSummaryRequestPathValid = requestPathSummarySummary.test(axiosSummaryRequestPath);
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'info', `Request path ➜ ${axiosSummaryRequestPath}`);
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'info', `Request path valid ➜ ${axiosSummaryRequestPathValid}`);
+            }
+            if (!axiosSummaryRequestPathValid) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'error', `"${axiosSummaryRequestPath}" is not the summary page`);
+                }
+                this.handleLoginFailure(axiosSummaryRequestPath, sessions.axiosSummary);
+                return {
+                    action: 'ARM_DISARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: `"${axiosSummaryRequestPath}" is not the summary page`,
+                    },
+                };
+            }
+            if (typeof sessions.axiosSummary.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'error', 'The response body of the summary page is not of type "string"');
+                }
+                return {
+                    action: 'ARM_DISARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: 'The response body of the summary page is not of type "string"',
+                    },
+                };
+            }
+            if (this.#session.backupSatCode === null) {
+                const missingSatCode = fetchMissingSatCode(sessions.axiosSummary);
+                if (missingSatCode !== null) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'success', 'Backup sat code was successfully recovered from previous failed retrieval');
+                    }
+                    this.#session.backupSatCode = missingSatCode;
+                }
+            }
+            sessions.jsdomSummary = new JSDOM(sessions.axiosSummary.data, {
+                url: sessions.axiosSummary.config.url,
+                referrer: sessions.axiosSummary.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomSummaryOrbSecurityButtons = sessions.jsdomSummary.window.document.querySelectorAll('#divOrbSecurityButtons input');
+            const parsedOrbSecurityButtons = parseOrbSecurityButtons(jsdomSummaryOrbSecurityButtons);
+            await this.newInformationDispatcher('orb-security-buttons', parsedOrbSecurityButtons);
+            let readyButtons = parsedOrbSecurityButtons.filter((parsedOrbSecurityButton) => !parsedOrbSecurityButton.buttonDisabled);
+            if (['disarmed', 'off'].includes(armState)
+                && ['night'].includes(arm)
+                && readyButtons.length === 0) {
+                readyButtons = [
+                    {
+                        buttonDisabled: false,
+                        buttonId: 'security_button_0',
+                        buttonIndex: 0,
+                        buttonText: 'Disarm',
+                        changeAccessCode: false,
+                        loadingText: 'Disarming',
+                        relativeUrl,
+                        totalButtons: 1,
+                        urlParams: {
+                            arm: 'off',
+                            armState: (this.#session.isCleanState) ? 'night' : 'night+stay',
+                            href,
+                            sat,
+                        },
+                    },
+                ];
+            }
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'success', `Successfully updated arm state from "${armState}" to "${arm}" on "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'ARM_DISARM_HANDLER',
+                success: true,
+                info: {
+                    forceArmRequired,
+                    readyButtons,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.armDisarmHandler()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'ARM_DISARM_HANDLER',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async forceArmHandler(response, relativeUrl) {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'info', `Attempting to force arm on "${this.#internal.baseUrl}"`);
+        }
+        try {
+            const internet = await this.isPortalAccessible();
+            const sessions = {};
+            if (!internet.success) {
+                return {
+                    action: 'FORCE_ARM_HANDLER',
+                    success: false,
+                    info: internet.info,
+                };
+            }
+            if (typeof response.data !== 'string') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'error', 'The response body of the arm disarm page is not of type "string"');
+                }
+                return {
+                    action: 'FORCE_ARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: 'The response body of the arm disarm page is not of type "string"',
+                    },
+                };
+            }
+            sessions.jsdomArmDisarm = new JSDOM(response.data, {
+                url: response.config.url,
+                referrer: response.config.headers.Referer,
+                contentType: 'text/html',
+                pretendToBeVisual: true,
+            });
+            const jsdomArmDisarmDoSubmitHandlers = sessions.jsdomArmDisarm.window.document.querySelectorAll('.p_armDisarmWrapper input');
+            const jsdomArmDisarmArmDisarmMessage = sessions.jsdomArmDisarm.window.document.querySelector('.p_armDisarmWrapper div:first-child');
+            const parsedArmDisarmMessage = parseArmDisarmMessage(jsdomArmDisarmArmDisarmMessage);
+            const parsedDoSubmitHandlers = parseDoSubmitHandlers(jsdomArmDisarmDoSubmitHandlers);
+            await this.newInformationDispatcher('do-submit-handlers', parsedDoSubmitHandlers);
+            if (parsedDoSubmitHandlers.length === 0
+                || parsedArmDisarmMessage === null) {
+                if (this.#internal.testMode.enabled) {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'error', 'Test mode is active but no doors or windows were open');
+                    }
+                    return {
+                        action: 'FORCE_ARM_HANDLER',
+                        success: false,
+                        info: {
+                            message: 'Test mode is active but no doors or windows were open',
+                        },
+                    };
+                }
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'info', 'Force arming not required');
+                }
+                return {
+                    action: 'FORCE_ARM_HANDLER',
+                    success: true,
+                    info: {
+                        forceArmRequired: false,
+                    },
+                };
+            }
+            const tracker = {
+                complete: false,
+                errorMessage: null,
+                requestUrl: null,
+            };
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'warn', `Portal message ➜ "${parsedArmDisarmMessage}"`);
+            }
+            for (let i = 0; i < parsedDoSubmitHandlers.length; i += 1) {
+                const forceArmRelativeUrl = parsedDoSubmitHandlers[i].relativeUrl;
+                const forceArmSat = parsedDoSubmitHandlers[i].urlParams.sat;
+                const forceArmHref = parsedDoSubmitHandlers[i].urlParams.href;
+                const forceArmArmState = parsedDoSubmitHandlers[i].urlParams.armState;
+                const forceArmArm = parsedDoSubmitHandlers[i].urlParams.arm;
+                if ((tracker.complete
+                    && tracker.errorMessage === null)
+                    || forceArmArmState === null
+                    || forceArmArm === null) {
+                    continue;
+                }
+                const forceArmForm = new URLSearchParams();
+                forceArmForm.append('sat', forceArmSat);
+                forceArmForm.append('href', forceArmHref);
+                forceArmForm.append('armstate', forceArmArmState);
+                forceArmForm.append('arm', forceArmArm);
+                sessions.axiosForceArm = await this.#session.httpClient.post(this.#internal.baseUrl + forceArmRelativeUrl, forceArmForm, this.getRequestConfig({
+                    headers: {
+                        Accept: '*/*',
+                        'Content-type': 'application/x-www-form-urlencoded',
+                        Origin: this.#internal.baseUrl,
+                        Referer: `${this.#internal.baseUrl}/myhome/${this.#session.portalVersion}/${relativeUrl}`,
+                        'Sec-Fetch-Dest': 'empty',
+                        'Sec-Fetch-Mode': 'cors',
+                        'Sec-Fetch-Site': 'same-origin',
+                        'Sec-Fetch-User': undefined,
+                        'x-dtpc': generateDynatracePCHeaderValue('force-arm'),
+                    },
+                }));
+                if (typeof sessions.axiosForceArm?.request === 'undefined') {
+                    if (this.#internal.debug) {
+                        debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'error', 'The HTTP client responded without the "request" object');
+                    }
+                    return {
+                        action: 'FORCE_ARM_HANDLER',
+                        success: false,
+                        info: {
+                            message: 'The HTTP client responded without the "request" object',
+                        },
+                    };
+                }
+                const axiosForceArmRequestPath = sessions.axiosForceArm.request.path;
+                const axiosForceArmRequestPathValid = requestPathQuickControlServRunRraCommand.test(axiosForceArmRequestPath);
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'info', `Request path ➜ ${axiosForceArmRequestPath}`);
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'info', `Request path valid ➜ ${axiosForceArmRequestPathValid}`);
+                }
+                if (!axiosForceArmRequestPathValid) {
+                    tracker.errorMessage = `"${axiosForceArmRequestPath}" is not the run rra command page`;
+                    tracker.requestUrl = axiosForceArmRequestPath;
+                    continue;
+                }
+                if (typeof sessions.axiosForceArm.data !== 'string') {
+                    tracker.errorMessage = 'The response body of the run rra command page is not of type "string"';
+                    tracker.requestUrl = axiosForceArmRequestPath;
+                    continue;
+                }
+                if (!sessions.axiosForceArm.data.includes('1.0-OKAY')) {
+                    tracker.errorMessage = 'The response body of the run rra command page does not include "1.0-OKAY"';
+                    tracker.requestUrl = axiosForceArmRequestPath;
+                    continue;
+                }
+                tracker.complete = true;
+                tracker.errorMessage = null;
+                tracker.requestUrl = null;
+            }
+            if (tracker.errorMessage !== null) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'error', tracker.errorMessage);
+                }
+                this.handleLoginFailure(tracker.requestUrl, sessions.axiosForceArm);
+                return {
+                    action: 'FORCE_ARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: tracker.errorMessage,
+                    },
+                };
+            }
+            if (!tracker.complete) {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'error', 'Force arming failed because the "Arm Anyway" button was not found');
+                }
+                return {
+                    action: 'FORCE_ARM_HANDLER',
+                    success: false,
+                    info: {
+                        message: 'Force arming failed because the "Arm Anyway" button was not found',
+                    },
+                };
+            }
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'success', `Successfully forced arm on "${this.#internal.baseUrl}"`);
+            }
+            return {
+                action: 'FORCE_ARM_HANDLER',
+                success: true,
+                info: {
+                    forceArmRequired: true,
+                },
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.forceArmHandler()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'FORCE_ARM_HANDLER',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async isPortalAccessible() {
+        let errorObject;
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.isPortalAccessible()', 'info', `Attempting to check if "${this.#internal.baseUrl}" is accessible`);
+        }
+        try {
+            const response = await axios.head(this.#internal.baseUrl, this.getRequestConfig());
+            if (response.status !== 200 || response.statusText !== 'OK') {
+                if (this.#internal.debug) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.isPortalAccessible()', 'error', `The portal at "${this.#internal.baseUrl}" is not accessible`);
+                }
+                return {
+                    action: 'IS_PORTAL_ACCESSIBLE',
+                    success: false,
+                    info: {
+                        message: `The portal at "${this.#internal.baseUrl}" is not accessible`,
+                    },
+                };
+            }
+            if (this.#internal.debug) {
+                debugLog(this.#internal.logger, 'api.ts / ADTPulse.isPortalAccessible()', 'success', `Successfully checked if "${this.#internal.baseUrl}" is accessible`);
+            }
+            return {
+                action: 'IS_PORTAL_ACCESSIBLE',
+                success: true,
+                info: null,
+            };
+        }
+        catch (error) {
+            errorObject = serializeError(error);
+        }
+        if (this.#internal.debug) {
+            debugLog(this.#internal.logger, 'api.ts / ADTPulse.isPortalAccessible()', 'error', 'Method encountered an error during execution');
+            stackTracer('serialize-error', errorObject);
+        }
+        return {
+            action: 'IS_PORTAL_ACCESSIBLE',
+            success: false,
+            info: {
+                error: errorObject,
+            },
+        };
+    }
+    async newInformationDispatcher(type, data) {
+        const dataHash = generateHash(`${type}: ${JSON.stringify(data)}`);
+        if (this.#internal.reportedHashes.find((reportedHash) => dataHash === reportedHash) === undefined) {
+            let detectedNew = false;
+            switch (type) {
+                case 'do-submit-handlers':
+                    detectedNew = await detectedNewDoSubmitHandlers(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                case 'gateway-information':
+                    detectedNew = await detectedNewGatewayInformation(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                case 'orb-security-buttons':
+                    detectedNew = await detectedNewOrbSecurityButtons(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                case 'panel-information':
+                    detectedNew = await detectedNewPanelInformation(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                case 'panel-status':
+                    detectedNew = await detectedNewPanelStatus(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                case 'portal-version':
+                    detectedNew = await detectedNewPortalVersion(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                case 'sensors-information':
+                    detectedNew = await detectedNewSensorsInformation(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                case 'sensors-status':
+                    detectedNew = await detectedNewSensorsStatus(data, this.#internal.logger, this.#internal.debug);
+                    break;
+                default:
+                    break;
+            }
+            if (detectedNew) {
+                this.#internal.reportedHashes.push(dataHash);
+            }
+        }
+    }
+    getRequestConfig(extraConfig) {
+        const defaultConfig = {
+            family: 4,
+            headers: {
+                Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+                'Accept-Encoding': 'gzip, deflate, br',
+                'Accept-Language': 'en-US,en;q=0.9',
+                Connection: 'keep-alive',
+                Host: `${this.#credentials.subdomain}.adtpulse.com`,
+                'Sec-Fetch-Dest': 'document',
+                'Sec-Fetch-Mode': 'navigate',
+                'Sec-Fetch-Site': 'none',
+                'Sec-Fetch-User': '?1',
+                'Upgrade-Insecure-Requests': '1',
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+                'sec-ch-ua-mobile': '?0',
+                'sec-ch-ua-platform': '"macOS"',
+            },
+            timeout: 15000,
+            validateStatus: undefined,
+        };
+        if (extraConfig === undefined) {
+            return defaultConfig;
+        }
+        return _.merge(_.omit(defaultConfig, findNullKeys(extraConfig)), _.omit(extraConfig, findNullKeys(extraConfig)));
+    }
+    handleLoginFailure(requestPath, session) {
+        if (requestPath === null) {
+            return;
+        }
+        if (requestPathAccessSignIn.test(requestPath)
+            || requestPathAccessSignInENsPartnerAdt.test(requestPath)
+            || requestPathMfaMfaSignInWorkflowChallenge.test(requestPath)) {
+            if (this.#internal.debug) {
+                const errorMessage = fetchErrorMessage(session);
+                if (requestPathAccessSignIn.test(requestPath) || requestPathAccessSignInENsPartnerAdt.test(requestPath)) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.handleLoginFailure()', 'error', 'Either the username or password is incorrect, fingerprint format is invalid, or was signed out due to inactivity');
+                }
+                if (requestPathMfaMfaSignInWorkflowChallenge.test(requestPath)) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.handleLoginFailure()', 'error', 'Either the fingerprint expired or "Trust this device" was not selected after completing MFA challenge');
+                }
+                if (errorMessage !== null) {
+                    debugLog(this.#internal.logger, 'api.ts / ADTPulse.handleLoginFailure()', 'warn', `Portal message ➜ "${errorMessage}"`);
+                }
+            }
+            this.resetSession();
+        }
+    }
+    resetSession() {
+        this.#session = {
+            backupSatCode: null,
+            httpClient: wrapper(axios.create({
+                jar: new CookieJar(),
+            })),
+            isAuthenticated: false,
+            isCleanState: true,
+            networkId: null,
+            portalVersion: null,
+        };
+    }
+}
+//# sourceMappingURL=api.js.map