@microsoft/omnichannel-chat-widget 1.7.8-main.29ce174 → 1.7.8-main.50111af

package/lib/cjs/common/facades/FacadeChatSDK.js

@@ -9,24 +9,15 @@ var _authHelper = require("../../components/livechatwidget/common/authHelper");
 var _omnichannelChatComponents = require("@microsoft/omnichannel-chat-components");
 var _TelemetryHelper = require("../telemetry/TelemetryHelper");
 var _utils = require("../utils");
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-class FacadeChatSDK {
-  isSDKMocked() {
-    return this.sdkMocked;
-  }
-  getChatSDK() {
-    return this.chatSDK;
-  }
-  destroy() {
-    this.token = null;
-    this.expiration = 0;
-  }
-  isTokenSet() {
-    return !(0, _utils.isNullOrEmptyString)(this.token);
-  }
-  constructor(input, disableReauthentication) {
+let FacadeChatSDK = /*#__PURE__*/function () {
+  function FacadeChatSDK(input, disableReauthentication) {
+    _classCallCheck(this, FacadeChatSDK);
     _defineProperty(this, "chatSDK", void 0);
     _defineProperty(this, "chatConfig", void 0);
     _defineProperty(this, "token", "");
@@ -44,311 +35,413 @@ class FacadeChatSDK {
   }
 
   //set default expiration to zero, for undefined or missed exp in jwt
-  convertExpiration() {
-    let expiration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    // Converting expiration to seconds, if contains decimals or is identified as milliseconds
-    if (expiration.toString().length === 13) {
-      return Math.floor(expiration / 1000);
-    }
-    // If the epoch value is already in seconds, return it as is
-    return expiration;
-  }
-  isTokenExpired() {
-    // if expiration is 0, token is not going to be validated ( this is to cover the case of token with no expiration)
-    if (this.expiration === 0) {
-      return false;
+  _createClass(FacadeChatSDK, [{
+    key: "isSDKMocked",
+    value: function isSDKMocked() {
+      return this.sdkMocked;
+    }
+  }, {
+    key: "getChatSDK",
+    value: function getChatSDK() {
+      return this.chatSDK;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.token = null;
+      this.expiration = 0;
+    }
+  }, {
+    key: "isTokenSet",
+    value: function isTokenSet() {
+      return !(0, _utils.isNullOrEmptyString)(this.token);
     }
+  }, {
+    key: "convertExpiration",
+    value: function convertExpiration() {
+      let expiration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      // Converting expiration to seconds, if contains decimals or is identified as milliseconds
+      if (expiration.toString().length === 13) {
+        return Math.floor(expiration / 1000);
+      }
+      // If the epoch value is already in seconds, return it as is
+      return expiration;
+    }
+  }, {
+    key: "isTokenExpired",
+    value: function isTokenExpired() {
+      // if expiration is 0, token is not going to be validated ( this is to cover the case of token with no expiration)
+      if (this.expiration === 0) {
+        return false;
+      }
 
-    // obtain current time in seconds
-    const now = Math.floor(Date.now() / 1000);
+      // obtain current time in seconds
+      const now = Math.floor(Date.now() / 1000);
 
-    // compare expiration time with current time
-    if (now > this.expiration) {
-      console.error("Token is expired", now, this.expiration, now > this.expiration);
-      return true;
+      // compare expiration time with current time
+      if (now > this.expiration) {
+        console.error("Token is expired", now, this.expiration, now > this.expiration);
+        return true;
+      }
+      return false;
     }
-    return false;
-  }
-  enforceBase64Encoding(payload) {
-    //base64url when present, switches the "-" and "_" characters with "+" and "/"
-    const base64Payload = payload.replace(/-/g, "+").replace(/_/g, "/");
-    // since base64 encoding requires padding, we need to add padding to the payload
-    return base64Payload.padEnd(base64Payload.length + (4 - base64Payload.length % 4) % 4, "=");
-  }
-  extractExpFromToken(token) {
-    const tokenParts = token.split(".");
-    const last3digits = token.slice(-3);
+  }, {
+    key: "enforceBase64Encoding",
+    value: function enforceBase64Encoding(payload) {
+      //base64url when present, switches the "-" and "_" characters with "+" and "/"
+      const base64Payload = payload.replace(/-/g, "+").replace(/_/g, "/");
+      // since base64 encoding requires padding, we need to add padding to the payload
+      return base64Payload.padEnd(base64Payload.length + (4 - base64Payload.length % 4) % 4, "=");
+    }
+  }, {
+    key: "extractExpFromToken",
+    value: function extractExpFromToken(token) {
+      const tokenParts = token.split(".");
+      const last3digits = token.slice(-3);
 
-    // token must have 3 parts as JWT format
-    if (tokenParts.length !== 3) {
-      _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
-        Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
-        Description: "Invalid token format",
-        ExceptionDetails: {
-          message: "Invalid token format, must be in JWT format",
-          token: last3digits
-        }
-      });
-      throw new Error("Invalid token format, must be in JWT format");
-    }
-    try {
-      const payload = this.enforceBase64Encoding(tokenParts[1]);
-      // decode payload
-      const decodedPayload = atob(payload);
-      const jsonPayload = JSON.parse(decodedPayload);
-      // check if exp is present in payload
-      if (jsonPayload) {
-        if (jsonPayload.exp) {
-          return jsonPayload.exp;
-        }
-        return 0;
+      // token must have 3 parts as JWT format
+      if (tokenParts.length !== 3) {
+        _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
+          Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
+          Description: "Invalid token format",
+          ExceptionDetails: {
+            message: "Invalid token format, must be in JWT format",
+            token: last3digits
+          }
+        });
+        throw new Error("Invalid token format, must be in JWT format");
       }
-      _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
-        Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
-        Description: "Invalid token payload",
-        ExceptionDetails: {
-          message: "Token payload is not valid JSON",
-          token: last3digits
-        }
-      });
-      throw new Error("Invalid token payload, payload is not valid JSON");
-    } catch (e) {
-      console.error("Failed to decode token", e);
-      _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
-        Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
-        Description: "Failed to decode token",
-        ExceptionDetails: {
-          message: "Failed to decode token",
-          token: last3digits
+      try {
+        const payload = this.enforceBase64Encoding(tokenParts[1]);
+        // decode payload
+        const decodedPayload = atob(payload);
+        const jsonPayload = JSON.parse(decodedPayload);
+        // check if exp is present in payload
+        if (jsonPayload) {
+          if (jsonPayload.exp) {
+            return jsonPayload.exp;
+          }
+          return 0;
         }
-      });
-      throw new Error("Failed to decode token");
-    }
-  }
-  async setToken(token) {
-    // token must be not null, and must be new
-    if (!(0, _utils.isNullOrEmptyString)(token) && token !== this.token) {
-      const last3digits = token.slice(-3);
-      const instant = Math.floor(Date.now() / 1000);
-      this.token = token;
-      // calculate expiration time
-      this.expiration = this.convertExpiration(this.extractExpFromToken(token) || 0);
-      // this is a control , in case the getAuthToken function returns same token
-      if (this.expiration > 0 && this.expiration < instant) {
         _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
-          Event: _TelemetryConstants.TelemetryEvent.NewTokenExpired,
-          Description: "New token is already expired",
+          Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
+          Description: "Invalid token payload",
           ExceptionDetails: {
-            "Instant": instant,
-            "Expiration": this.expiration,
-            "Token": last3digits
+            message: "Token payload is not valid JSON",
+            token: last3digits
           }
         });
-        throw new Error(`New token is already expired, with epoch time ${this.expiration} , last 3 digits of token: ${last3digits}`);
+        throw new Error("Invalid token payload, payload is not valid JSON");
+      } catch (e) {
+        console.error("Failed to decode token", e);
+        _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
+          Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
+          Description: "Failed to decode token",
+          ExceptionDetails: {
+            message: "Failed to decode token",
+            token: last3digits
+          }
+        });
+        throw new Error("Failed to decode token");
       }
     }
-  }
-  async tokenRing() {
-    var _this$chatSDK$chatSDK;
-    if (this.disableReauthentication === true) {
-      // facade feature is disabled, so we are bypassing the re authentication and let it fail.
-      return {
-        result: true,
-        message: "Facade is disabled"
-      };
-    }
-
-    // this is needed for storybooks, specifically for reconnect pane which requires authentication bypass
-    if (this.sdkMocked === true) {
-      return {
-        result: true,
-        message: "Authentication not needed"
-      };
-    }
-    if (!this.isAuthenticated) {
-      return {
-        result: true,
-        message: "Authentication not needed"
-      };
-    }
-    if (this.isTokenSet() && !this.isTokenExpired()) {
-      return {
-        result: true,
-        message: "Token is valid"
-      };
+  }, {
+    key: "setToken",
+    value: async function setToken(token) {
+      // token must be not null, and must be new
+      if (!(0, _utils.isNullOrEmptyString)(token) && token !== this.token) {
+        const last3digits = token.slice(-3);
+        const instant = Math.floor(Date.now() / 1000);
+        this.token = token;
+        // calculate expiration time
+        this.expiration = this.convertExpiration(this.extractExpFromToken(token) || 0);
+        // this is a control , in case the getAuthToken function returns same token
+        if (this.expiration > 0 && this.expiration < instant) {
+          _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
+            Event: _TelemetryConstants.TelemetryEvent.NewTokenExpired,
+            Description: "New token is already expired",
+            ExceptionDetails: {
+              "Instant": instant,
+              "Expiration": this.expiration,
+              "Token": last3digits
+            }
+          });
+          throw new Error(`New token is already expired, with epoch time ${this.expiration} , last 3 digits of token: ${last3digits}`);
+        }
+      }
     }
-    if (this.getAuthToken === undefined && ((_this$chatSDK$chatSDK = this.chatSDK.chatSDKConfig) === null || _this$chatSDK$chatSDK === void 0 ? void 0 : _this$chatSDK$chatSDK.getAuthToken) === undefined) {
-      _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
-        Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
-        Description: "GetAuthToken function is not present",
-        ExceptionDetails: "Missing function : " + (0, _authHelper.getAuthClientFunction)(this.chatConfig)
-      });
-      return {
-        result: false,
-        message: "GetAuthToken function is not present"
-      };
+  }, {
+    key: "corroborateTokenIsSet",
+    value: async function corroborateTokenIsSet(chatSDK) {
+      var _chatSDK$chatSDKConfi;
+      // if getAuthToken is not set, it's because handleAuthentication hasnt being called
+      // so we need to call it 
+      if (this.isAuthenticated && (chatSDK === null || chatSDK === void 0 ? void 0 : (_chatSDK$chatSDKConfi = chatSDK.chatSDKConfig) === null || _chatSDK$chatSDKConfi === void 0 ? void 0 : _chatSDK$chatSDKConfi.getAuthToken) === undefined) {
+        (0, _authHelper.handleAuthentication)(this.chatSDK, this.chatConfig, this.getAuthToken);
+      }
     }
+  }, {
+    key: "tokenRing",
+    value: async function tokenRing() {
+      var _this$chatSDK$chatSDK;
+      if (this.disableReauthentication === true) {
+        // Since we are not validating the token anymore, we at least need to check if the token is set
+        // no need to validate anything other that the token is set
+        await this.corroborateTokenIsSet(this.chatSDK);
+        // facade feature is disabled, so we are bypassing the re authentication and let it fail.
+        return {
+          result: true,
+          message: "Facade is disabled"
+        };
+      }
 
-    // if token is not set, or token is already expired , then go to grab a token
-    this.token = "";
-    this.expiration = 0;
-    try {
-      const ring = await (0, _authHelper.handleAuthentication)(this.chatSDK, this.chatConfig, this.getAuthToken);
-      if (ring.result === true && ring.token) {
-        await this.setToken(ring.token);
-        _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.INFO, {
-          Event: _TelemetryConstants.TelemetryEvent.NewTokenSuccess,
-          Description: "New Token obtained",
-          Data: {
-            "Token_Expiration": this.expiration
-          }
-        });
+      // this is needed for storybooks, specifically for reconnect pane which requires authentication bypass
+      if (this.sdkMocked === true) {
         return {
           result: true,
-          message: "New Token obtained"
+          message: "Authentication not needed"
         };
-      } else {
-        var _ring$error, _ring$error2;
+      }
+      if (!this.isAuthenticated) {
+        return {
+          result: true,
+          message: "Authentication not needed"
+        };
+      }
+      if (this.isTokenSet() && !this.isTokenExpired()) {
+        return {
+          result: true,
+          message: "Token is valid"
+        };
+      }
+      if (this.getAuthToken === undefined && ((_this$chatSDK$chatSDK = this.chatSDK.chatSDKConfig) === null || _this$chatSDK$chatSDK === void 0 ? void 0 : _this$chatSDK$chatSDK.getAuthToken) === undefined) {
         _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
           Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
-          Description: (_ring$error = ring.error) === null || _ring$error === void 0 ? void 0 : _ring$error.message,
-          ExceptionDetails: ring.error
+          Description: "GetAuthToken function is not present",
+          ExceptionDetails: "Missing function : " + (0, _authHelper.getAuthClientFunction)(this.chatConfig)
         });
         return {
           result: false,
-          message: ((_ring$error2 = ring.error) === null || _ring$error2 === void 0 ? void 0 : _ring$error2.message) || "Failed to get token"
+          message: "GetAuthToken function is not present"
+        };
+      }
+
+      // if token is not set, or token is already expired , then go to grab a token
+      this.token = "";
+      this.expiration = 0;
+      try {
+        const ring = await (0, _authHelper.handleAuthentication)(this.chatSDK, this.chatConfig, this.getAuthToken);
+        if ((ring === null || ring === void 0 ? void 0 : ring.result) === true && ring !== null && ring !== void 0 && ring.token) {
+          await this.setToken(ring.token);
+          _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.INFO, {
+            Event: _TelemetryConstants.TelemetryEvent.NewTokenSuccess,
+            Description: "New Token obtained",
+            Data: {
+              "Token_Expiration": this.expiration
+            }
+          });
+          return {
+            result: true,
+            message: "New Token obtained"
+          };
+        } else {
+          var _ring$error, _ring$error2;
+          _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
+            Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
+            Description: ring === null || ring === void 0 ? void 0 : (_ring$error = ring.error) === null || _ring$error === void 0 ? void 0 : _ring$error.message,
+            ExceptionDetails: ring === null || ring === void 0 ? void 0 : ring.error
+          });
+          return {
+            result: false,
+            message: (ring === null || ring === void 0 ? void 0 : (_ring$error2 = ring.error) === null || _ring$error2 === void 0 ? void 0 : _ring$error2.message) || "Failed to get token"
+          };
+        }
+      } catch (e) {
+        console.error("Unexpected error while getting token", e);
+        _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
+          Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
+          Description: "Unexpected error while getting token",
+          ExceptionDetails: e
+        });
+        return {
+          result: false,
+          message: "Unexpected error while getting token"
         };
       }
-    } catch (e) {
-      console.error("Unexpected error while getting token", e);
-      _TelemetryHelper.TelemetryHelper.logFacadeChatSDKEvent(_TelemetryConstants.LogLevel.ERROR, {
-        Event: _TelemetryConstants.TelemetryEvent.NewTokenFailed,
-        Description: "Unexpected error while getting token",
-        ExceptionDetails: e
-      });
-      return {
-        result: false,
-        message: "Unexpected error while getting token"
-      };
     }
-  }
-  async validateAndExecuteCall(functionName, fn) {
-    const pingResponse = await this.tokenRing();
-    if (pingResponse.result === true) {
-      return fn();
-    }
-    const executionErrorMessage = `Authentication failed: Process to get a token failed for ${functionName}, ${pingResponse.message}`;
-    //telemetry is already logged in tokenRing, so no need to log again, just return the error and communicate to the console
-    console.error(executionErrorMessage);
-    _omnichannelChatComponents.BroadcastService.postMessage({
-      eventName: _TelemetryConstants.BroadcastEvent.OnWidgetError,
-      payload: {
-        errorMessage: executionErrorMessage
+  }, {
+    key: "validateAndExecuteCall",
+    value: async function validateAndExecuteCall(functionName, fn) {
+      const pingResponse = await this.tokenRing();
+      if (pingResponse.result === true) {
+        return fn();
       }
-    });
-    throw new Error(executionErrorMessage);
-  }
-  async initialize() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("initialize", () => this.chatSDK.initialize(optionalParams));
-  }
-  async getChatReconnectContext() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("getChatReconnectContext", () => this.chatSDK.getChatReconnectContext(optionalParams));
-  }
-  async startChat() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("startChat", () => this.chatSDK.startChat(optionalParams));
-  }
-  async endChat() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("endChat", () => this.chatSDK.endChat(optionalParams));
-  }
-  async getCurrentLiveChatContext() {
-    return this.validateAndExecuteCall("getCurrentLiveChatContext", () => this.chatSDK.getCurrentLiveChatContext());
-  }
-  async getConversationDetails() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("getConversationDetails", () => this.chatSDK.getConversationDetails(optionalParams));
-  }
+      const executionErrorMessage = `Authentication failed: Process to get a token failed for ${functionName}, ${pingResponse.message}`;
+      //telemetry is already logged in tokenRing, so no need to log again, just return the error and communicate to the console
+      console.error(executionErrorMessage);
+      _omnichannelChatComponents.BroadcastService.postMessage({
+        eventName: _TelemetryConstants.BroadcastEvent.OnWidgetError,
+        payload: {
+          errorMessage: executionErrorMessage
+        }
+      });
+      throw new Error(executionErrorMessage);
+    }
+  }, {
+    key: "initialize",
+    value: async function initialize() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("initialize", () => this.chatSDK.initialize(optionalParams));
+    }
+  }, {
+    key: "getChatReconnectContext",
+    value: async function getChatReconnectContext() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("getChatReconnectContext", () => this.chatSDK.getChatReconnectContext(optionalParams));
+    }
+  }, {
+    key: "startChat",
+    value: async function startChat() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("startChat", () => this.chatSDK.startChat(optionalParams));
+    }
+  }, {
+    key: "endChat",
+    value: async function endChat() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("endChat", () => this.chatSDK.endChat(optionalParams));
+    }
+  }, {
+    key: "getCurrentLiveChatContext",
+    value: async function getCurrentLiveChatContext() {
+      return this.validateAndExecuteCall("getCurrentLiveChatContext", () => this.chatSDK.getCurrentLiveChatContext());
+    }
+  }, {
+    key: "getConversationDetails",
+    value: async function getConversationDetails() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("getConversationDetails", () => this.chatSDK.getConversationDetails(optionalParams));
+    }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async getPreChatSurvey() {
-    let parse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    //prechat survey is obtained from config object, which is not required to be authenticated
-    // removing the tokenRing function from this call for backward compatibility
-    // TODO ::  wrap this function around authentication
-    return this.chatSDK.getPreChatSurvey(parse);
-  }
-  async getLiveChatConfig(optionalParams) {
-    return this.validateAndExecuteCall("getLiveChatConfig", () => this.chatSDK.getLiveChatConfig(optionalParams));
-  }
-  async getChatToken() {
-    let cached = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    let optionalParams = arguments.length > 1 ? arguments[1] : undefined;
-    return this.validateAndExecuteCall("getChatToken", () => this.chatSDK.getChatToken(cached, optionalParams));
-  }
-  async getCallingToken() {
-    return this.validateAndExecuteCall("getCallingToken", () => this.chatSDK.getCallingToken());
-  }
-  async getMessages() {
-    return this.validateAndExecuteCall("getMessages", () => this.chatSDK.getMessages());
-  }
-  async getDataMaskingRules() {
-    return this.validateAndExecuteCall("getDataMaskingRules", () => this.chatSDK.getDataMaskingRules());
-  }
-  async sendMessage(message) {
-    return this.validateAndExecuteCall("sendMessage", () => this.chatSDK.sendMessage(message));
-  }
-  async onNewMessage(onNewMessageCallback) {
-    let optionalParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      disablePolling: false
-    };
-    return this.validateAndExecuteCall("onNewMessage", () => this.chatSDK.onNewMessage(onNewMessageCallback, optionalParams));
-  }
-  async sendTypingEvent() {
-    return this.validateAndExecuteCall("sendTypingEvent", () => this.chatSDK.sendTypingEvent());
-  }
-  async onTypingEvent(onTypingEventCallback) {
-    return this.validateAndExecuteCall("onTypingEvent", () => this.chatSDK.onTypingEvent(onTypingEventCallback));
-  }
-  async onAgentEndSession(onAgentEndSessionCallback) {
-    return this.validateAndExecuteCall("onAgentEndSession", () => this.chatSDK.onAgentEndSession(onAgentEndSessionCallback));
-  }
-  async uploadFileAttachment(fileInfo) {
-    return this.validateAndExecuteCall("uploadFileAttachment", () => this.chatSDK.uploadFileAttachment(fileInfo));
-  }
-  async downloadFileAttachment(fileMetadata) {
-    return this.validateAndExecuteCall("downloadFileAttachment", () => this.chatSDK.downloadFileAttachment(fileMetadata));
-  }
-  async emailLiveChatTranscript(body) {
-    let optionalParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return this.validateAndExecuteCall("emailLiveChatTranscript", () => this.chatSDK.emailLiveChatTranscript(body, optionalParams));
-  }
-  async getLiveChatTranscript() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("getLiveChatTranscript", () => this.chatSDK.getLiveChatTranscript(optionalParams));
-  }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }, {
+    key: "getPreChatSurvey",
+    value: async function getPreChatSurvey() {
+      let parse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      //prechat survey is obtained from config object, which is not required to be authenticated
+      // removing the tokenRing function from this call for backward compatibility
+      // TODO ::  wrap this function around authentication
+      return this.chatSDK.getPreChatSurvey(parse);
+    }
+  }, {
+    key: "getLiveChatConfig",
+    value: async function getLiveChatConfig(optionalParams) {
+      return this.validateAndExecuteCall("getLiveChatConfig", () => this.chatSDK.getLiveChatConfig(optionalParams));
+    }
+  }, {
+    key: "getChatToken",
+    value: async function getChatToken() {
+      let cached = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      let optionalParams = arguments.length > 1 ? arguments[1] : undefined;
+      return this.validateAndExecuteCall("getChatToken", () => this.chatSDK.getChatToken(cached, optionalParams));
+    }
+  }, {
+    key: "getCallingToken",
+    value: async function getCallingToken() {
+      return this.validateAndExecuteCall("getCallingToken", () => this.chatSDK.getCallingToken());
+    }
+  }, {
+    key: "getMessages",
+    value: async function getMessages() {
+      return this.validateAndExecuteCall("getMessages", () => this.chatSDK.getMessages());
+    }
+  }, {
+    key: "getDataMaskingRules",
+    value: async function getDataMaskingRules() {
+      return this.validateAndExecuteCall("getDataMaskingRules", () => this.chatSDK.getDataMaskingRules());
+    }
+  }, {
+    key: "sendMessage",
+    value: async function sendMessage(message) {
+      return this.validateAndExecuteCall("sendMessage", () => this.chatSDK.sendMessage(message));
+    }
+  }, {
+    key: "onNewMessage",
+    value: async function onNewMessage(onNewMessageCallback) {
+      let optionalParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+        disablePolling: false
+      };
+      return this.validateAndExecuteCall("onNewMessage", () => this.chatSDK.onNewMessage(onNewMessageCallback, optionalParams));
+    }
+  }, {
+    key: "sendTypingEvent",
+    value: async function sendTypingEvent() {
+      return this.validateAndExecuteCall("sendTypingEvent", () => this.chatSDK.sendTypingEvent());
+    }
+  }, {
+    key: "onTypingEvent",
+    value: async function onTypingEvent(onTypingEventCallback) {
+      return this.validateAndExecuteCall("onTypingEvent", () => this.chatSDK.onTypingEvent(onTypingEventCallback));
+    }
+  }, {
+    key: "onAgentEndSession",
+    value: async function onAgentEndSession(onAgentEndSessionCallback) {
+      return this.validateAndExecuteCall("onAgentEndSession", () => this.chatSDK.onAgentEndSession(onAgentEndSessionCallback));
+    }
+  }, {
+    key: "uploadFileAttachment",
+    value: async function uploadFileAttachment(fileInfo) {
+      return this.validateAndExecuteCall("uploadFileAttachment", () => this.chatSDK.uploadFileAttachment(fileInfo));
+    }
+  }, {
+    key: "downloadFileAttachment",
+    value: async function downloadFileAttachment(fileMetadata) {
+      return this.validateAndExecuteCall("downloadFileAttachment", () => this.chatSDK.downloadFileAttachment(fileMetadata));
+    }
+  }, {
+    key: "emailLiveChatTranscript",
+    value: async function emailLiveChatTranscript(body) {
+      let optionalParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return this.validateAndExecuteCall("emailLiveChatTranscript", () => this.chatSDK.emailLiveChatTranscript(body, optionalParams));
+    }
+  }, {
+    key: "getLiveChatTranscript",
+    value: async function getLiveChatTranscript() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("getLiveChatTranscript", () => this.chatSDK.getLiveChatTranscript(optionalParams));
+    }
 
-  // response from origin is unknown, but this definition breaks create adapter for shimAdapter, switching to any until type is returned from origin
-  async createChatAdapter() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("createChatAdapter", () => this.chatSDK.createChatAdapter(optionalParams));
-  }
-  async isVoiceVideoCallingEnabled() {
-    this.tokenRing();
-    return this.chatSDK.isVoiceVideoCallingEnabled();
-  }
-  async getVoiceVideoCalling() {
-    let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("getVoiceVideoCalling", () => this.chatSDK.getVoiceVideoCalling(params));
-  }
-  async getPostChatSurveyContext() {
-    return this.validateAndExecuteCall("getPostChatSurveyContext", () => this.chatSDK.getPostChatSurveyContext());
-  }
-  async getAgentAvailability() {
-    let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return this.validateAndExecuteCall("getAgentAvailability", () => this.chatSDK.getAgentAvailability(optionalParams));
-  }
-}
+    // response from origin is unknown, but this definition breaks create adapter for shimAdapter, switching to any until type is returned from origin
+  }, {
+    key: "createChatAdapter",
+    value: async function createChatAdapter() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("createChatAdapter", () => this.chatSDK.createChatAdapter(optionalParams));
+    }
+  }, {
+    key: "isVoiceVideoCallingEnabled",
+    value: async function isVoiceVideoCallingEnabled() {
+      this.tokenRing();
+      return this.chatSDK.isVoiceVideoCallingEnabled();
+    }
+  }, {
+    key: "getVoiceVideoCalling",
+    value: async function getVoiceVideoCalling() {
+      let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("getVoiceVideoCalling", () => this.chatSDK.getVoiceVideoCalling(params));
+    }
+  }, {
+    key: "getPostChatSurveyContext",
+    value: async function getPostChatSurveyContext() {
+      return this.validateAndExecuteCall("getPostChatSurveyContext", () => this.chatSDK.getPostChatSurveyContext());
+    }
+  }, {
+    key: "getAgentAvailability",
+    value: async function getAgentAvailability() {
+      let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.validateAndExecuteCall("getAgentAvailability", () => this.chatSDK.getAgentAvailability(optionalParams));
+    }
+  }]);
+  return FacadeChatSDK;
+}();
 exports.FacadeChatSDK = FacadeChatSDK;