noibu-react-native 0.1.2 → 0.2.0

package/android/.gitignore

@@ -0,0 +1,13 @@
+build/
+.idea
+.gradle
+local.properties
+*.iml
+*.hprof
+.cxx/
+*.keystore
+!debug.keystore
+gradle
+gradle*
+!gradle.properties
+settings.gradle

package/android/build.gradle

@@ -0,0 +1,79 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["Noibu_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.5.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Noibu_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Noibu_" + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.noibu:sessionreplay-recorder:0.1.0"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "noibusessionreplay"
+    codegenJavaPackageName = "com.noibu.sessionreplay.reactnative"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,7 @@
+#make sure these are acutally used
+Noibu_kotlinVersion=1.7.22
+Noibu_minSdkVersion=21
+Noibu_targetSdkVersion=34
+Noibu_compileSdkVersion=34
+Noibu_ndkversion=21.4.7075529
+android.useAndroidX=true

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+<manifest
+        xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.noibu.sessionreplay.reactnative">
+
+</manifest>

package/android/src/main/java/com/noibu/sessionreplay/reactnative/NoibuSessionReplayModule.kt

@@ -0,0 +1,107 @@
+package com.noibu.sessionreplay.reactnative
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+import com.noibu.sessionreplay.SessionReplayConfig
+import com.noibu.sessionreplay.models.ApplicationFramework
+import com.noibu.sessionreplay.models.LogLevel
+
+import com.noibu.sessionreplay.SessionReplay
+
+class NoibuSessionReplayModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    init {
+        NoibuSessionReplayModule.reactContext = reactContext
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    private fun sendEvent(eventName: String, params: WritableMap?) {
+        Log.d("SessionReplayModule", "will send event: ${params}")
+        reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(eventName, params)
+    }
+
+    @ReactMethod
+    fun initialize(
+        projectId: String,
+        userId: String?,
+        logLevel: String,
+        allowMeteredNetworkUsage: Boolean,
+        enableWebViewCapture: Boolean,
+        allowedDomains: ReadableArray,
+        disableOnLowEndDevices: Boolean,
+        enableDailyNetworkUsageLimit: Boolean,
+        maximumDailyNetworkUsageInMB: Double,
+        promise: Promise
+    ) {
+        val allowedActivities = listOf<String>(); // not supported
+        val disallowedActivities = listOf<String>(); // not supported
+
+        // We use two parameters because the react method parameters do not accept nullable primitive types.
+        // Moreover, the Long data type is not supported. Js numbers are translated into doubles.
+        val maximumDailyNetworkUsageInMBLong =
+            if (enableDailyNetworkUsageLimit) maximumDailyNetworkUsageInMB.toLong() else null
+
+        val config = SessionReplayConfig(
+            projectId,
+            userId,
+            LogLevel.valueOf(logLevel),
+            allowMeteredNetworkUsage,
+            enableWebViewCapture,
+            readableArrayToList(allowedDomains),
+            ApplicationFramework.ReactNative,
+            allowedActivities,
+            disallowedActivities,
+            disableOnLowEndDevices,
+            maximumDailyNetworkUsageInMBLong
+        )
+
+        Handler(Looper.getMainLooper()).post {
+            promise.resolve(
+                SessionReplay.initialize(
+                    currentActivity!!.getApplicationContext(),
+                    config,
+                    currentActivity
+                ) { param ->
+                    Handler(Looper.getMainLooper()).post {
+                        val params = Arguments.createMap()
+                        params.putString("message", param)
+                        sendEvent("noibuRecordingEvent", params)
+                    }
+                }
+            )
+        }
+    }
+
+    @ReactMethod
+    fun setCustomUserId(customUserId: String, promise: Promise) {
+        promise.resolve(SessionReplay.setCustomUserId(customUserId))
+    }
+
+    @ReactMethod
+    fun setCustomSessionId(customSessionId: String, promise: Promise) {
+        promise.resolve(SessionReplay.setCustomSessionId(customSessionId))
+    }
+
+    private fun readableArrayToList(arr: ReadableArray): List<String> {
+        val ret = mutableListOf<String>()
+
+        for (i in 0 until arr.size()) {
+            ret.add(arr.getString(i))
+        }
+
+        return ret
+    }
+
+    companion object {
+        const val NAME = "NativeSessionRecorder"
+        private var reactContext: ReactApplicationContext? = null
+    }
+}

package/android/src/main/java/com/noibu/sessionreplay/reactnative/NoibuSessionReplayPackage.kt

@@ -0,0 +1,17 @@
+package com.noibu.sessionreplay.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.JavaScriptModule
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class NoibuSessionReplayPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(NoibuSessionReplayModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/dist/api/clientConfig.d.ts

@@ -7,10 +7,10 @@ import { CustomerConfig, StoredConfig } from '../types/Config';
  * storing and retrieval.
  */
 export default class ClientConfig {
-    private readonly pageVisitId;
-    private browserId;
+    readonly pageVisitId: string;
+    browserId: StoredConfig['BrowserId'];
     private pageVisitSeq;
-    private lastActiveTime;
+    lastActiveTime: Date;
     private readonly noibuErrorURL;
     private cltErrorPostCounter;
     private readonly maxSocketInactiveTime;
@@ -30,17 +30,16 @@ export default class ClientConfig {
     static configureInstance({ noibuErrorURL, customerConfig, }: {
         noibuErrorURL: string;
         customerConfig: CustomerConfig;
-    }): void;
+    }): Promise<void>;
     /**
      * gets the singleton instance
-     * @returns {ClientConfig}
      */
     static getInstance(): ClientConfig;
     /** lockClient will disable the client script for a single pagevisit for
      * duration given in minuntes */
     lockClient(duration: number, msg: string): Promise<void>;
     /** Locks the client until the next page loads */
-    lockClientUntilNextPage(msg: string): void;
+    lockClientUntilNextPage(msg: string): Promise<void>;
     /**  Updates the config object to store the given last active time */
     updateLastActiveTime(lastActiveTime: Date): Promise<void>;
     /**  Gets the current page visit sequence number that should be used */
@@ -98,7 +97,7 @@ export default class ClientConfig {
      * and disable the client if required
      * severity expects one of the SEVERITY_x level constants, or else error will be used
      */
-    postNoibuErrorAndOptionallyDisableClient(errorMsg: string, disableClient: boolean, severity: (typeof SEVERITY)[keyof typeof SEVERITY], keepAlive?: boolean): Promise<void>;
+    postNoibuErrorAndOptionallyDisableClient(errorMsg: any, disableClient: boolean, severity: (typeof SEVERITY)[keyof typeof SEVERITY], keepAlive?: boolean): Promise<void>;
     /**
      * Returns true if the page visit is considered to be inactive
      */

package/dist/api/clientConfig.js

@@ -1,5 +1,5 @@
 import uuid from 'react-native-uuid';
-import { MAX_METROPLEX_SOCKET_INNACTIVE_TIME, SEVERITY, NOIBU_BROWSER_ID_KYWRD, PV_SEQ_NUM_RESET_TIME_MINUTES, JS_ENV, MAX_PAGEVISIT_VISITED, CLIENT_LOCK_TIME_MINUTES, GET_SCRIPT_ID, MAX_COLLECT_ERROR_LOG } from '../constants.js';
+import { MAX_METROPLEX_SOCKET_INNACTIVE_TIME, SEVERITY, NOIBU_BROWSER_ID_KYWRD, PV_SEQ_NUM_RESET_TIME_MINUTES, JS_ENV, MAX_PAGEVISIT_VISITED, CLIENT_LOCK_TIME_MINUTES, GET_SCRIPT_ID, GET_DEVICE_ENV, MAX_COLLECT_ERROR_LOG } from '../constants.js';
 import { stringifyJSON, getMaxSubstringAllowed, getUserAgent, makeRequest } from '../utils/function.js';
 import Storage from '../storage/storage.js';
 import { noibuLog } from '../utils/log.js';
@@ -44,8 +44,6 @@ class ClientConfig {
         this.lastActiveTime = new Date();
         // error URL to send Noibu errors to
         this.noibuErrorURL = noibuErrorURL;
-        // sets up this.browserId, this.isClientDisabled, this.pageVisitSeq
-        this._setupStorageVars();
         // error sent to backend counter
         this.cltErrorPostCounter = 0;
         // variables for checking if the socket is inactive
@@ -58,18 +56,16 @@ class ClientConfig {
         this.blockedElements = customerConfig.blockedElements;
     }
     /** Configures the singleton instance */
-    static configureInstance({ noibuErrorURL, customerConfig, }) {
+    static async configureInstance({ noibuErrorURL, customerConfig, }) {
         if (!this.instance) {
-            // Set this.noibuErrorURL preemptively in case ClientConfig isn't able to be
-            // configured properly and throws an error.
-            // This will ensure we get the expected error POST request at the correct URL.
             ClientConfig.noibuErrorURL = noibuErrorURL;
             this.instance = new ClientConfig(noibuErrorURL, customerConfig);
+            // sets up this.browserId, this.isClientDisabled, this.pageVisitSeq
+            await this.instance._setupStorageVars();
         }
     }
     /**
      * gets the singleton instance
-     * @returns {ClientConfig}
      */
     static getInstance() {
         if (!this.instance) {
@@ -86,11 +82,11 @@ class ClientConfig {
         noibuLSObject.DisabledStatus = true;
         noibuLSObject.ClientUnlockTime = expiryTime;
         await this._storeBrowserData(noibuLSObject);
-        this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
+        await this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
     }
     /** Locks the client until the next page loads */
     lockClientUntilNextPage(msg) {
-        this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
+        return this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
     }
     /**  Updates the config object to store the given last active time */
     async updateLastActiveTime(lastActiveTime) {
@@ -167,7 +163,7 @@ class ClientConfig {
     async _setupStorageVars() {
         const storage = Storage.getInstance();
         if (!(await storage.isAvailable())) {
-            this.postNoibuErrorAndOptionallyDisableClient(`Storage is unavailable, disabling client. ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
+            void this.postNoibuErrorAndOptionallyDisableClient(`Storage is unavailable, disabling client. ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
             return;
         }
         // getting the current content of the storage
@@ -177,6 +173,7 @@ class ClientConfig {
             noibuLSObject.CurrentPageVisitCount = 0;
         }
         this.browserId = noibuLSObject.BrowserId;
+        noibuLog('ClientConfig - _setupStorageVars', { noibuLSObject });
         this.pageVisitSeq = noibuLSObject.CurrentPageVisitCount;
         this.isClientDisabled = noibuLSObject.DisabledStatus;
         // If the client has been disabled just return.
@@ -201,7 +198,7 @@ class ClientConfig {
             // setting the lock time
             noibuLSObject.ClientUnlockTime = expiryTime;
             noibuLSObject.DisabledStatus = true;
-            this.postNoibuErrorAndOptionallyDisableClient(`Hit max page visits, disabling client for ${CLIENT_LOCK_TIME_MINUTES}mins`, true, SEVERITY.error);
+            await this.postNoibuErrorAndOptionallyDisableClient(`Hit max page visits, disabling client for ${CLIENT_LOCK_TIME_MINUTES}mins`, true, SEVERITY.error);
         }
         // we now check if we successfully saved the data
         const savedData = await this._storeBrowserData(noibuLSObject);
@@ -209,7 +206,7 @@ class ClientConfig {
         // error happened, thus we disable collect.
         if (!savedData.BrowserId) {
             // we do not set a lock expiry date here since we cannot store to storage
-            this.postNoibuErrorAndOptionallyDisableClient(`Null browser in storage, disabling client`, true, SEVERITY.error);
+            void this.postNoibuErrorAndOptionallyDisableClient(`Null browser in storage, disabling client`, true, SEVERITY.error);
             this.browserId = '';
         }
     }
@@ -267,7 +264,7 @@ class ClientConfig {
             return data;
         }
         catch (e) {
-            this.postNoibuErrorAndOptionallyDisableClient(`Error writing browser data to storage, disabling client: ${e.message}, ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
+            await this.postNoibuErrorAndOptionallyDisableClient(`Error writing browser data to storage, disabling client: ${e.message}, ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
             // sending empty fields if we encountered errors while storing in the LS
             return this._generateNewBrowserData();
         }
@@ -315,7 +312,8 @@ class ClientConfig {
             pageVisitId: this.pageVisitId,
             scriptId: GET_SCRIPT_ID(),
             ua: await getUserAgent(),
-            error: errorMsg,
+            deviceEnv: GET_DEVICE_ENV(),
+            error: stringifyJSON(errorMsg),
         };
         // if the page visits sends more errors than the
         // allowed threshold we disable the client
@@ -347,7 +345,7 @@ class ClientConfig {
             });
         }
         else {
-            unwrapNoibuWrapped(fetch)(this.noibuErrorURL, {
+            void unwrapNoibuWrapped(fetch)(this.noibuErrorURL, {
                 method: 'POST',
                 headers,
                 body: stringifyJSON(errorContent),

package/dist/api/helpCode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * HelpCode class is responsible for help code feature related functionality
+ */
+export default class HelpCode {
+    /**
+     * Singleton instance
+     * @returns {HelpCode}
+     */
+    static getInstance(): HelpCode;
+    requestContext: {
+        resolve: null;
+        reject: null;
+        promise: null;
+    } | null;
+    /**
+     * Handles the received help code event.
+     * @param {CustomEvent<string>} event - The event object with string detail property.
+     * @returns {void}
+     */
+    receiveHelpCode(event: CustomEvent<string>): void;
+    /**
+     * Requests a help code and returns a Promise that resolves when the help code is obtained
+     * or rejects if the noibu connection is unavailable.
+  
+     * @returns {Promise<string>} Promise object representing the help code request.
+     * @throws {string} Throws an error if the noibu connection is unavailable.
+     */
+    requestHelpCode(): Promise<string>;
+}

package/dist/api/inputManager.d.ts

@@ -0,0 +1,87 @@
+/** this class controls the input that customers can inject into
+ * our script via the NoibuJS SDK
+ */
+export default class InputManager {
+    /** gets the singleton instance */
+    static getInstance(): InputManager;
+    customIDs: {};
+    customErrorsCount: number;
+    TOO_MANY_IDS_ADDED_MSG: string;
+    ID_NAME_ALREADY_ADDED_MSG: string;
+    NAME_TOO_LONG_MSG: string;
+    VALUE_TOO_LONG_MSG: string;
+    INVALID_NAME_TYPE_MSG: string;
+    INVALID_VALUE_TYPE_MSG: string;
+    NAME_HAS_NO_LENGTH_MSG: string;
+    VALUE_HAS_NO_LENGTH_MSG: string;
+    SUCCESS_MSG: string;
+    ERROR_HAS_NO_MSG_MSG: string;
+    ERROR_HAS_NO_STACK_MSG: string;
+    NULL_CUSTOM_ERR_MSG: string;
+    ERROR_ALREADY_RECEIVED_MSG: string;
+    INVALID_ERROR_SOURCE_MSG: string;
+    TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT_MSG: string;
+    /** exposes functions to the window of the browser for the clients
+     * to interact with on their end
+     */
+    exposeFunctions(): {
+        requestHelpCode: (alert?: boolean) => Promise<string>;
+        addCustomAttribute: (name: string, value: string) => Promise<string>;
+        addError: (customError: Error) => string;
+        addJsSdkError: (customError: string, errorSource: string) => string;
+    };
+    /**
+     * gets the sdk object that will be assigned to a window variable
+     * @returns {{
+     *    requestHelpCode: (alert?: boolean) => Promise<string>,
+     *    addCustomAttribute: (name: string, value: string) => Promise<string>,
+     *    addError: (customError: Error) => string,
+     *    addJsSdkError: (customError: string, errorSource: string) => string
+     * }}
+     */
+    _getSDKWindowObject(): {
+        requestHelpCode: (alert?: boolean) => Promise<string>;
+        addCustomAttribute: (name: string, value: string) => Promise<string>;
+        addError: (customError: Error) => string;
+        addJsSdkError: (customError: string, errorSource: string) => string;
+    };
+    /**
+     * validates the custom error that was passed
+     * @param  {} customError
+     */
+    _validateCustomError(customError: any): string;
+    /**
+     * Validates and sets the custom error to our internal trackers
+     * @param  {} customError
+     */
+    _validateAndSetCustomError(customError: any): string;
+    /**
+     * adds an error from a JS Sdk to the session
+     * @param  {} customError
+     * @param {string} errorSource
+     */
+    _addErrorFromJSSdk(customError: any, errorSource: string): string;
+    /**
+     * adds a custom Error to the session
+     * @param  {} customError
+     */
+    _addCustomError(customError: any): string;
+    /**
+     * adds a custom id to the session
+     * @param  {} name
+     * @param  {} value
+     */
+    _addCustomAttribute(name: any, value: any): Promise<string>;
+    /**
+     * validation function for customer input
+     * @param  {} name
+     * @param  {} value
+     */
+    _validateCustomIDInput(name: any, value: any): string;
+    /**
+     * Requests a help code from the HelpCode instance.
+     * @param {boolean} [alertUser=true] - Whether to alert the user about the help code request.
+     * @returns {Promise<string>} A promise that resolves with the requested help code.
+     */
+    _requestHelpCode(): Promise<string>;
+}

package/dist/api/metroplexSocket.d.ts

@@ -0,0 +1,156 @@
+import { END_AT_ATT_NAME } from '../constants';
+/** Manages the socket to Metroplex */
+export default class MetroplexSocket {
+    _initialURL: string;
+    ackedOnce: boolean;
+    connectionCount: number;
+    connectionPromise: Promise<any>;
+    connectionURL: string;
+    currentConnectionAttempts: number;
+    forceClosed: boolean;
+    helpCodeCb: null | ((...args: any[]) => any);
+    initialReferingURL: string;
+    static instance: MetroplexSocket;
+    instanceId: string | number[];
+    isRetryLoopDisabled: boolean;
+    latestReceivedSeqNumStoredTime: Date;
+    latestReceivedSeqNumber: number;
+    messageSequenceNum: number;
+    metroRetryFrequencyMS: 30000;
+    metroplexTypeLock: Record<any, any>;
+    pageVisitInfoSent: boolean;
+    postURL: string;
+    previousMessageType: string;
+    retryMessageQueue: any[];
+    retryMetroplexInterval: null | number;
+    scriptInstanceId: string | number[] | undefined;
+    sessionLength: number;
+    sessionStartTime: any;
+    sessionTimestamp: Date;
+    socket: WebSocket | null;
+    socketInstanceId: string | number[] | null;
+    socketCloseCodes: string[];
+    socketOpens: string[];
+    /**
+     * Creates an instance of metroplex
+     * id of script, to make sure only a single socket is open
+     */
+    constructor(scriptInstanceId?: string | number[]);
+    /**
+     * gets the singleton instance
+     * @returns {MetroplexSocket}
+     */
+    static getInstance(scriptInstanceId?: string | number[]): MetroplexSocket;
+    /**
+     * Adds the seq num field to the given payload depending on whether its
+     * a page visit part or video frag
+     */
+    _addSeqNumToPayload(type: string, payload: any): void;
+    /**
+     * sets the seq num in the payload for the given key and increments the
+     * global seq number
+     */
+    _setSeqNumInPayloadAndIncrementSeqNum(payloadKey: string, payload: any): void;
+    /** requests help code and saves a callback to be called on response */
+    requestHelpCode(cb: (typeof this)['helpCodeCb']): Promise<boolean>;
+    /**
+     * Immediately sends a message to Metroplex over the web socket
+     * Queues the message if the connection isn't open yet.
+     * returns true if message was sent succefully, false otherwise
+     */
+    sendMessage(type: string, payload: any): Promise<boolean>;
+    /** Updates the latest pv message sent timestamp if events contain any user steps
+     */
+    _updateLatestPvTimestamp(events: any[]): Promise<void>;
+    /** returns true if the socket is either connecting or connected to metroplex */
+    isConnected(): boolean;
+    /** returns true if we are connecting to the socket */
+    isConnecting(): boolean;
+    /** close will close the socket opened for video frag transmission */
+    close(): void;
+    /** Connects the web socket to metroplex and calls callback upon successfully connecting
+     */
+    handleConnect(forceOpen: boolean): Promise<void>;
+    /**
+     * connectSocket will establish a websocket connection to the metroplex
+     * service
+     */
+    connectSocket(): Promise<any>;
+    /** Calculates and sets the end_at field of the payload
+     * @param  {} payload
+     * @param  {} isPageVisit
+     */
+    addEndTimeToPayload(payload: any, isPageVisit: boolean): typeof payload & {
+        [END_AT_ATT_NAME]: string;
+    };
+    /** open handler for socket */
+    _onSocketOpen(): Promise<void>;
+    /** message handler for socket
+     * @param  {} event
+     */
+    _onSocketMessage(event: any): Promise<void>;
+    /**
+     * Returns true if the message's payload has the payload type given and has a sequence
+     * number higher than seqNum
+     */
+    _messagePayloadHasLargerSeqNum(message: any, payloadType: string, seqNum: number): any;
+    /**
+     * removes messages from the retry queue that are smaller than the
+     * latest stored message in metroplex
+     */
+    _clearRetryQueue(seqNum: number): void;
+    /** will resend everything that is in the retry queue */
+    _sendUnconfirmedMessages(socketWasAlreadyOpen: boolean): Promise<void>;
+    /** sets up the interval to empty the queue as we receive confirmation messages from metroplex */
+    setupRetryMechanism(): void;
+    /** sets up events that will trigger the event queue to be emptied */
+    _setupOffloadEvents(): void;
+    /**
+     * will handle the final moments of a page being active. It
+     * will try to empty both the queues with beacons.
+     */
+    _handleUnload(): Promise<void>;
+    /**
+     * will post full page visit to metroplex. It
+     * will try to empty both the queues with beacons.
+     */
+    postFullPageVisit(maxMessageSize: number): Promise<void>;
+    /**
+     * will send a message to metroplex via a post request that will outlive the current page
+     */
+    postMessage(msg: any): Promise<void>;
+    /**
+     * Stringifies the payload into JSON, sends it to the back end if the session
+     * is active and returns true. If inactive the session and socket are closed
+     * and this method returns false.
+     */
+    _sendSocketMessage(payload: any): Promise<void>;
+    /**
+     * Closes the socket connection if the session is inactive. Returns true if the
+     * session is inactive
+     */
+    closeIfInactive(): Promise<boolean>;
+    /** will get page information, calling this will increase the connection count */
+    getPageInformation(): Promise<{
+        br_id: string;
+        pv_id: string;
+        v: 5;
+        seq: number | null;
+        on_url: string;
+        ref_url: string;
+        start_at: string;
+        conc: number;
+        cv: 2;
+        last: boolean;
+        script_id: string;
+        script_inst_id: string | number[] | undefined;
+        mp_sock_inst_id: string | number[];
+        sock_inst_id: string | number[] | null;
+        video_recorder: string;
+    }>;
+    /**
+     * Try to parse help code response and fire custom event
+     * @param {String} response
+     */
+    _tryProcessHelpCodeResponse(response: any): boolean;
+}