cidaas-javascript-sdk 4.2.1 → 4.2.2

package/dist/web-auth/WebAuth.js

@@ -1,15 +1,3 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -19,48 +7,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-exports.__esModule = true;
-exports.WebAuth = exports.createPreloginWebauth = void 0;
-var authentication_1 = require("../authentication");
-var Helper_1 = require("./Helper");
-var LoginService_1 = require("./LoginService");
-var UserService_1 = require("./UserService");
-var TokenService_1 = require("./TokenService");
-var VerificationService_1 = require("./VerificationService");
-var ConsentService_1 = require("./ConsentService");
-var createPreloginWebauth = function (authority) {
+import { Authentication, OidcManager } from '../authentication';
+import { Helper, CustomException } from "./Helper";
+import { LoginService } from "./LoginService";
+import { UserService } from "./UserService";
+import { TokenService } from "./TokenService";
+import { VerificationService } from "./VerificationService";
+import { ConsentService } from "./ConsentService";
+export const createPreloginWebauth = (authority) => {
     return new WebAuth({ 'authority': authority });
 };
-exports.createPreloginWebauth = createPreloginWebauth;
-var WebAuth = /** @class */ (function () {
-    function WebAuth(settings) {
+export class WebAuth {
+    constructor(settings) {
         try {
             if (!settings.response_type) {
                 settings.response_type = "code";
@@ -71,13 +29,13 @@ var WebAuth = /** @class */ (function () {
             if (settings.authority && settings.authority.charAt(settings.authority.length - 1) === '/') {
                 settings.authority = settings.authority.slice(0, settings.authority.length - 1);
             }
-            var usermanager = new authentication_1.OidcManager(settings);
+            var usermanager = new OidcManager(settings);
             window.webAuthSettings = settings;
             window.usermanager = usermanager;
             window.localeSettings = null;
-            window.authentication = new authentication_1.Authentication(window.webAuthSettings, window.usermanager);
+            window.authentication = new Authentication(window.webAuthSettings, window.usermanager);
             window.usermanager.events.addSilentRenewError(function () {
-                throw new Helper_1.CustomException("Error while renewing silent login", 500);
+                throw new CustomException("Error while renewing silent login", 500);
             });
         }
         catch (ex) {
@@ -89,12 +47,12 @@ var WebAuth = /** @class */ (function () {
      * Generate and redirect to authz url in same window for logging in.
      * @param {LoginRedirectOptions} options options options to over-ride the client config for redirect login
      */
-    WebAuth.prototype.loginWithBrowser = function (options) {
+    loginWithBrowser(options) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.loginOrRegisterWithBrowser('login', options);
-    };
+    }
     ;
     /**
      * Generate and open authz url in a popup window.
@@ -104,12 +62,12 @@ var WebAuth = /** @class */ (function () {
      * @returns {Promise<User>} Authenticated user
      * @throws error if unable to get the parse and get user
      */
-    WebAuth.prototype.popupSignIn = function (options) {
+    popupSignIn(options) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.popupSignIn(options);
-    };
+    }
     ;
     /**
      * Generate and navigate to authz url in an iFrame.
@@ -119,23 +77,23 @@ var WebAuth = /** @class */ (function () {
      * @returns {Promise<User>} Authenticated user
      * @throws error if unable to get the parse and get user
      */
-    WebAuth.prototype.silentSignIn = function (options) {
+    silentSignIn(options) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.silentSignIn(options);
-    };
+    }
     ;
     /**
      * Generate and redirect to authz url in same window for register view.
      * @param {LoginRedirectOptions} options options options to over-ride the client config for redirect login
      */
-    WebAuth.prototype.registerWithBrowser = function (options) {
+    registerWithBrowser(options) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.loginOrRegisterWithBrowser('register', options);
-    };
+    }
     ;
     /**
      * Once login successful, it will automatically redirects you to the redirect url whatever you mentioned in the options.
@@ -145,12 +103,12 @@ var WebAuth = /** @class */ (function () {
      * @returns {Promise<User>} Authenticated user
      * @throws error if unable to get the parse and get user
      */
-    WebAuth.prototype.loginCallback = function (url) {
+    loginCallback(url) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.loginCallback(url);
-    };
+    }
     ;
     /**
      * To complete the popup login process, call **popupSignInCallback()** from the popup login window.
@@ -159,23 +117,23 @@ var WebAuth = /** @class */ (function () {
      * @param {string} url optional url to read sign-in callback state from
      * @param {boolean} keepOpen true to keep the popup open even after sign in, else false
      */
-    WebAuth.prototype.popupSignInCallback = function (url, keepOpen) {
+    popupSignInCallback(url, keepOpen) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.popupSignInCallback(url, keepOpen);
-    };
+    }
     ;
     /**
      * Returns a promise to notify the parent window of response from authz service
      * @param {string} url optional url to check authz response, if none window.location is used
      */
-    WebAuth.prototype.silentSignInCallback = function (url) {
+    silentSignInCallback(url) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.silentSignInCallback(url);
-    };
+    }
     ;
     /**
      * To get the user profile information by using oidc-client-ts library, call **getUserInfo()**. This will return the basic user profile details along with groups, roles and whatever scopes you mentioned in the options.
@@ -189,65 +147,60 @@ var WebAuth = /** @class */ (function () {
      * ```
      * @return {Promise<User|null>} returns authenticated user if present, else null
      */
-    WebAuth.prototype.getUserInfo = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!window.usermanager) {
-                            return [2 /*return*/, Promise.reject(new Helper_1.CustomException("UserManager cannot be empty", 417))];
-                        }
-                        return [4 /*yield*/, window.usermanager.getUser()];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
+    getUserInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!window.usermanager) {
+                return Promise.reject(new CustomException("UserManager cannot be empty", 417));
+            }
+            return yield window.usermanager.getUser();
         });
-    };
+    }
     ;
     /**
      * logout by using oidc-client-ts library
      * @param {LogoutRedirectOptions} options optional options to over-ride logout options on redirect
      */
-    WebAuth.prototype.logout = function (options) {
+    logout(options) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.logout(options);
-    };
+    }
     ;
     /**
      * logout by using oidc-client-ts library
      * @param {PopupSignOutOptions} options optional options to over-ride logout options using popup window
      */
-    WebAuth.prototype.popupSignOut = function (options) {
+    popupSignOut(options) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.popupSignOut(options);
-    };
+    }
     ;
     /**
      * get the logout call state from the url provided, if none is provided current window url is used
      * @returns {Promise<LogoutResponse>} logout response from auth service
      */
-    WebAuth.prototype.logoutCallback = function (url) {
+    logoutCallback(url) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
         return window.authentication.logoutCallback(url);
-    };
+    }
     ;
     /**
      * listen to popup sign out event
      * @param {string} url optional url to override to check for sign out state
      * @param {boolean} keepOpen true to keep the popup open even after sign out, else false
      */
-    WebAuth.prototype.popupSignOutCallback = function (url, keepOpen) {
+    popupSignOutCallback(url, keepOpen) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
+        url = url || window.webAuthSettings.post_logout_redirect_uri;
         return window.authentication.popupSignOutCallback(url, keepOpen);
-    };
+    }
     ;
     /**
      * To get the generated login url, call **getLoginURL()**. This will call authz service and generate login url to be used.
@@ -262,13 +215,13 @@ var WebAuth = /** @class */ (function () {
      * @param {LoginRequestOptions} options login options to override {@link window.webAuthSettings} provided
      * @return {Promise<string>} authz url for login
      */
-    WebAuth.prototype.getLoginURL = function (options) {
+    getLoginURL(options) {
         if (!window.webAuthSettings || !window.authentication) {
-            return Promise.reject(new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
+            return Promise.reject(new CustomException("Settings or Authentication instance in OIDC cannot be empty", 417));
         }
-        return new Promise(function (resolve, reject) {
+        return new Promise((resolve, reject) => {
             try {
-                window.usermanager.getClient().createSigninRequest(__assign(__assign({}, window.webAuthSettings), (options && { options: options } || {}))).then(function (signinRequest) {
+                window.usermanager.getClient().createSigninRequest(Object.assign(Object.assign({}, window.webAuthSettings), (options && { options } || {}))).then((signinRequest) => {
                     resolve(signinRequest.url);
                 });
             }
@@ -276,7 +229,7 @@ var WebAuth = /** @class */ (function () {
                 reject(e);
             }
         });
-    };
+    }
     ;
     /**
      * Each and every proccesses starts with requestId, it is an entry point to login or register. For getting the requestId, call **getRequestId()**.
@@ -289,13 +242,13 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.getRequestId = function () {
+    getRequestId() {
         var _a, _b;
-        var ui_locales = window.webAuthSettings.ui_locales;
-        var options = __assign({ 'client_id': window.webAuthSettings.client_id, 'redirect_uri': window.webAuthSettings.redirect_uri, 'response_type': (_a = window.webAuthSettings.response_type) !== null && _a !== void 0 ? _a : 'token', "response_mode": (_b = window.webAuthSettings.response_mode) !== null && _b !== void 0 ? _b : 'fragment', "scope": window.webAuthSettings.scope, "nonce": new Date().getTime().toString() }, (ui_locales && { ui_locales: ui_locales } || {}));
-        var serviceURL = window.webAuthSettings.authority + '/authz-srv/authrequest/authz/generate';
-        return Helper_1.Helper.createHttpPromise(options, serviceURL, false, "POST");
-    };
+        const ui_locales = window.webAuthSettings.ui_locales;
+        const options = Object.assign({ 'client_id': window.webAuthSettings.client_id, 'redirect_uri': window.webAuthSettings.redirect_uri, 'response_type': (_a = window.webAuthSettings.response_type) !== null && _a !== void 0 ? _a : 'token', "response_mode": (_b = window.webAuthSettings.response_mode) !== null && _b !== void 0 ? _b : 'fragment', "scope": window.webAuthSettings.scope, "nonce": new Date().getTime().toString() }, (ui_locales && { ui_locales } || {}));
+        const serviceURL = window.webAuthSettings.authority + '/authz-srv/authrequest/authz/generate';
+        return Helper.createHttpPromise(options, serviceURL, false, "POST");
+    }
     ;
     /**
      * To get the tenant basic information, call **getTenantInfo()**. This will return the basic tenant details such as tenant name and allowed login with types (Email, Mobile, Username).
@@ -308,10 +261,10 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.getTenantInfo = function () {
-        var _serviceURL = window.webAuthSettings.authority + "/public-srv/tenantinfo/basic";
-        return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
-    };
+    getTenantInfo() {
+        const _serviceURL = window.webAuthSettings.authority + "/public-srv/tenantinfo/basic";
+        return Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
+    }
     ;
     /**
      * To logout the user by using cidaas internal api, call **logoutUser()**.
@@ -323,9 +276,9 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.logoutUser = function (options) {
+    logoutUser(options) {
         window.location.href = window.webAuthSettings.authority + "/session/end_session?access_token_hint=" + options.access_token + "&post_logout_redirect_uri=" + window.webAuthSettings.post_logout_redirect_uri;
-    };
+    }
     ;
     /**
      * To get the client basic information, call **getClientInfo()**. This will return the basic client details such as client name and its details.
@@ -341,10 +294,10 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.getClientInfo = function (options) {
-        var _serviceURL = window.webAuthSettings.authority + "/public-srv/public/" + options.requestId;
-        return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
-    };
+    getClientInfo(options) {
+        const _serviceURL = window.webAuthSettings.authority + "/public-srv/public/" + options.requestId;
+        return Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
+    }
     ;
     /**
      * To get all devices information associated to the client, call **getDevicesInfo()**
@@ -360,14 +313,14 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.getDevicesInfo = function (options, accessToken) {
+    getDevicesInfo(options, accessToken) {
         options.userAgent = window.navigator.userAgent;
-        var _serviceURL = window.webAuthSettings.authority + "/device-srv/devices";
+        const _serviceURL = window.webAuthSettings.authority + "/device-srv/devices";
         if (window.navigator.userAgent) {
-            return Helper_1.Helper.createHttpPromise(options, _serviceURL, false, "GET", accessToken);
+            return Helper.createHttpPromise(options, _serviceURL, false, "GET", accessToken);
         }
-        return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "GET", accessToken);
-    };
+        return Helper.createHttpPromise(undefined, _serviceURL, false, "GET", accessToken);
+    }
     ;
     /**
      * To delete device associated to the client, call **deleteDevice()**
@@ -385,14 +338,14 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.deleteDevice = function (options, accessToken) {
-        var _serviceURL = window.webAuthSettings.authority + "/device-srv/device/" + options.device_id;
+    deleteDevice(options, accessToken) {
+        const _serviceURL = window.webAuthSettings.authority + "/device-srv/device/" + options.device_id;
         options.userAgent = window.navigator.userAgent;
         if (window.navigator.userAgent) {
-            return Helper_1.Helper.createHttpPromise(options, _serviceURL, false, "DELETE", accessToken);
+            return Helper.createHttpPromise(options, _serviceURL, false, "DELETE", accessToken);
         }
-        return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "DELETE", accessToken);
-    };
+        return Helper.createHttpPromise(undefined, _serviceURL, false, "DELETE", accessToken);
+    }
     ;
     /**
      * To handle registration, first you need the registration fields. To get the registration fields, call **getRegistrationSetup()**. This will return the fields that has to be needed while registration.
@@ -409,10 +362,10 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.getRegistrationSetup = function (options) {
-        var serviceURL = window.webAuthSettings.authority + '/registration-setup-srv/public/list?acceptlanguage=' + options.acceptlanguage + '&requestId=' + options.requestId;
-        return Helper_1.Helper.createHttpPromise(undefined, serviceURL, false, 'GET');
-    };
+    getRegistrationSetup(options) {
+        const serviceURL = window.webAuthSettings.authority + '/registration-setup-srv/public/list?acceptlanguage=' + options.acceptlanguage + '&requestId=' + options.requestId;
+        return Helper.createHttpPromise(undefined, serviceURL, false, 'GET');
+    }
     ;
     /**
      * to generate device info, call **createDeviceInfo()**.
@@ -426,78 +379,78 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.createDeviceInfo = function () {
-        var value = ('; ' + document.cookie).split("; cidaas_dr=").pop().split(';')[0];
+    createDeviceInfo() {
+        const value = ('; ' + document.cookie).split(`; cidaas_dr=`).pop().split(';')[0];
         if (!value) {
-            var options = {
+            const options = {
                 userAgent: window.navigator.userAgent
             };
-            var serviceURL = window.webAuthSettings.authority + '/device-srv/deviceinfo';
-            return Helper_1.Helper.createHttpPromise(options, serviceURL, false, 'POST');
+            const serviceURL = window.webAuthSettings.authority + '/device-srv/deviceinfo';
+            return Helper.createHttpPromise(options, serviceURL, false, 'POST');
         }
-    };
+    }
     ;
     /**
      * get the user profile information
      * @param options
      * @returns
      */
-    WebAuth.prototype.getUserProfile = function (options) {
-        return UserService_1.UserService.getUserProfile(options);
-    };
+    getUserProfile(options) {
+        return UserService.getUserProfile(options);
+    }
     ;
     /**
      * renew token using refresh token
      * @param options
      * @returns
      */
-    WebAuth.prototype.renewToken = function (options) {
-        return TokenService_1.TokenService.renewToken(options);
-    };
+    renewToken(options) {
+        return TokenService.renewToken(options);
+    }
     ;
     /**
      * get access token from code
      * @param options
      * @returns
      */
-    WebAuth.prototype.getAccessToken = function (options) {
-        return TokenService_1.TokenService.getAccessToken(options);
-    };
+    getAccessToken(options) {
+        return TokenService.getAccessToken(options);
+    }
     ;
     /**
      * validate access token
      * @param options
      * @returns
      */
-    WebAuth.prototype.validateAccessToken = function (options) {
-        return TokenService_1.TokenService.validateAccessToken(options);
-    };
+    validateAccessToken(options) {
+        return TokenService.validateAccessToken(options);
+    }
     ;
     /**
      * login with username and password
      * @param options
      */
-    WebAuth.prototype.loginWithCredentials = function (options) {
-        LoginService_1.LoginService.loginWithCredentials(options);
-    };
+    loginWithCredentials(options) {
+        LoginService.loginWithCredentials(options);
+    }
     ;
     /**
      * login with social
      * @param options
      * @param queryParams
      */
-    WebAuth.prototype.loginWithSocial = function (options, queryParams) {
-        LoginService_1.LoginService.loginWithSocial(options, queryParams);
-    };
+    loginWithSocial(options, queryParams) {
+        LoginService.loginWithSocial(options, queryParams);
+    }
     ;
     /**
      * register with social
      * @param options
      * @param queryParams
      */
-    WebAuth.prototype.registerWithSocial = function (options, queryParams) {
-        LoginService_1.LoginService.registerWithSocial(options, queryParams);
-    };
+    registerWithSocial(options, queryParams) {
+        LoginService.registerWithSocial(options, queryParams);
+    }
     ;
     /**
      * register user
@@ -505,210 +458,210 @@ var WebAuth = /** @class */ (function () {
      * @param headers
      * @returns
      */
-    WebAuth.prototype.register = function (options, headers) {
-        return UserService_1.UserService.register(options, headers);
-    };
+    register(options, headers) {
+        return UserService.register(options, headers);
+    }
     ;
     /**
      * get invite info
      * @param options
      * @returns
      */
-    WebAuth.prototype.getInviteUserDetails = function (options) {
-        return UserService_1.UserService.getInviteUserDetails(options);
-    };
+    getInviteUserDetails(options) {
+        return UserService.getInviteUserDetails(options);
+    }
     ;
     /**
      * get Communication status
      * @param options
      * @returns
      */
-    WebAuth.prototype.getCommunicationStatus = function (options, headers) {
-        return UserService_1.UserService.getCommunicationStatus(options, headers);
-    };
+    getCommunicationStatus(options, headers) {
+        return UserService.getCommunicationStatus(options, headers);
+    }
     ;
     /**
      * initiate verification
      * @param options
      * @returns
      */
-    WebAuth.prototype.initiateAccountVerification = function (options) {
-        VerificationService_1.VerificationService.initiateAccountVerification(options);
-    };
+    initiateAccountVerification(options) {
+        VerificationService.initiateAccountVerification(options);
+    }
     ;
     /**
      * verify account
      * @param options
      * @returns
      */
-    WebAuth.prototype.verifyAccount = function (options) {
-        return VerificationService_1.VerificationService.verifyAccount(options);
-    };
+    verifyAccount(options) {
+        return VerificationService.verifyAccount(options);
+    }
     ;
     /**
      * initiate reset password
      * @param options
      * @returns
      */
-    WebAuth.prototype.initiateResetPassword = function (options) {
-        return UserService_1.UserService.initiateResetPassword(options);
-    };
+    initiateResetPassword(options) {
+        return UserService.initiateResetPassword(options);
+    }
     ;
     /**
      * handle reset password
      * @param options
      */
-    WebAuth.prototype.handleResetPassword = function (options) {
-        return UserService_1.UserService.handleResetPassword(options);
-    };
+    handleResetPassword(options) {
+        return UserService.handleResetPassword(options);
+    }
     ;
     /**
     * reset password
     * @param options
     */
-    WebAuth.prototype.resetPassword = function (options) {
-        return UserService_1.UserService.resetPassword(options);
-    };
+    resetPassword(options) {
+        return UserService.resetPassword(options);
+    }
     ;
     /**
      * get mfa list
      * @param options
      * @returns
      */
-    WebAuth.prototype.getMFAList = function (options) {
-        return VerificationService_1.VerificationService.getMFAList(options);
-    };
+    getMFAList(options) {
+        return VerificationService.getMFAList(options);
+    }
     ;
     /**
      * cancel mfa
      * @param options
      * @returns
      */
-    WebAuth.prototype.cancelMFA = function (options) {
-        return VerificationService_1.VerificationService.cancelMFA(options);
-    };
+    cancelMFA(options) {
+        return VerificationService.cancelMFA(options);
+    }
     ;
     /**
      * passwordless login
      * @param options
      */
-    WebAuth.prototype.passwordlessLogin = function (options) {
-        LoginService_1.LoginService.passwordlessLogin(options);
-    };
+    passwordlessLogin(options) {
+        LoginService.passwordlessLogin(options);
+    }
     ;
     /**
      * get user consent details
      * @param options
      * @returns
      */
-    WebAuth.prototype.getConsentDetails = function (options) {
-        return ConsentService_1.ConsentService.getConsentDetails(options);
-    };
+    getConsentDetails(options) {
+        return ConsentService.getConsentDetails(options);
+    }
     ;
     /**
      * accept consent
      * @param options
      * @returns
      */
-    WebAuth.prototype.acceptConsent = function (options) {
-        return ConsentService_1.ConsentService.acceptConsent(options);
-    };
+    acceptConsent(options) {
+        return ConsentService.acceptConsent(options);
+    }
     ;
     /**
      * get scope consent details
      * @param options
      * @returns
      */
-    WebAuth.prototype.loginPrecheck = function (options) {
-        return TokenService_1.TokenService.loginPrecheck(options);
-    };
+    loginPrecheck(options) {
+        return TokenService.loginPrecheck(options);
+    }
     ;
     /**
      * get scope consent version details
      * @param options
      * @returns
      */
-    WebAuth.prototype.getConsentVersionDetails = function (options) {
-        return ConsentService_1.ConsentService.getConsentVersionDetails(options);
-    };
+    getConsentVersionDetails(options) {
+        return ConsentService.getConsentVersionDetails(options);
+    }
     ;
     /**
      * accept scope Consent
      * @param options
      * @returns
      */
-    WebAuth.prototype.acceptScopeConsent = function (options) {
-        return ConsentService_1.ConsentService.acceptScopeConsent(options);
-    };
+    acceptScopeConsent(options) {
+        return ConsentService.acceptScopeConsent(options);
+    }
     ;
     /**
      * accept claim Consent
      * @param options
      * @returns
      */
-    WebAuth.prototype.acceptClaimConsent = function (options) {
-        return ConsentService_1.ConsentService.acceptClaimConsent(options);
-    };
+    acceptClaimConsent(options) {
+        return ConsentService.acceptClaimConsent(options);
+    }
     ;
     /**
      * revoke claim Consent
      * @param options
      * @returns
      */
-    WebAuth.prototype.revokeClaimConsent = function (options) {
-        return ConsentService_1.ConsentService.revokeClaimConsent(options);
-    };
+    revokeClaimConsent(options) {
+        return ConsentService.revokeClaimConsent(options);
+    }
     ;
     /**
      * get Deduplication details
      * @param options
      * @returns
      */
-    WebAuth.prototype.getDeduplicationDetails = function (options) {
-        return UserService_1.UserService.getDeduplicationDetails(options);
-    };
+    getDeduplicationDetails(options) {
+        return UserService.getDeduplicationDetails(options);
+    }
     ;
     /**
      * deduplication login
      * @param options
      */
-    WebAuth.prototype.deduplicationLogin = function (options) {
-        UserService_1.UserService.deduplicationLogin(options);
-    };
+    deduplicationLogin(options) {
+        UserService.deduplicationLogin(options);
+    }
     ;
     /**
      * register Deduplication
      * @param options
      * @returns
      */
-    WebAuth.prototype.registerDeduplication = function (options) {
-        return UserService_1.UserService.registerDeduplication(options);
-    };
+    registerDeduplication(options) {
+        return UserService.registerDeduplication(options);
+    }
     ;
     /**
      * accepts any as the request
      * consent continue login
      * @param options
      */
-    WebAuth.prototype.consentContinue = function (options) {
-        LoginService_1.LoginService.consentContinue(options);
-    };
+    consentContinue(options) {
+        LoginService.consentContinue(options);
+    }
     ;
     /**
      * mfa continue login
      * @param options
      */
-    WebAuth.prototype.mfaContinue = function (options) {
-        LoginService_1.LoginService.mfaContinue(options);
-    };
+    mfaContinue(options) {
+        LoginService.mfaContinue(options);
+    }
     ;
     /**
      * change password continue
      * @param options
      */
-    WebAuth.prototype.firstTimeChangePassword = function (options) {
-        LoginService_1.LoginService.firstTimeChangePassword(options);
-    };
+    firstTimeChangePassword(options) {
+        LoginService.firstTimeChangePassword(options);
+    }
     ;
     /**
      * change password
@@ -716,9 +669,9 @@ var WebAuth = /** @class */ (function () {
      * @param access_token
      * @returns
      */
-    WebAuth.prototype.changePassword = function (options, access_token) {
-        return UserService_1.UserService.changePassword(options, access_token);
-    };
+    changePassword(options, access_token) {
+        return UserService.changePassword(options, access_token);
+    }
     ;
     /**
      * update profile
@@ -727,9 +680,9 @@ var WebAuth = /** @class */ (function () {
      * @param sub
      * @returns
      */
-    WebAuth.prototype.updateProfile = function (options, access_token, sub) {
-        return UserService_1.UserService.updateProfile(options, access_token, sub);
-    };
+    updateProfile(options, access_token, sub) {
+        return UserService.updateProfile(options, access_token, sub);
+    }
     ;
     /**
      * To get user activities, call **getUserActivities()**.
@@ -751,17 +704,17 @@ var WebAuth = /** @class */ (function () {
      * });
      * ```
      */
-    WebAuth.prototype.getUserActivities = function (options, accessToken) {
-        var serviceURL = window.webAuthSettings.authority + '/activity-streams-srv/user-activities';
-        return Helper_1.Helper.createHttpPromise(options, serviceURL, false, 'POST', accessToken);
-    };
+    getUserActivities(options, accessToken) {
+        const serviceURL = window.webAuthSettings.authority + '/activity-streams-srv/user-activities';
+        return Helper.createHttpPromise(options, serviceURL, false, 'POST', accessToken);
+    }
     /**
      * @param access_token
      * @returns
      */
-    WebAuth.prototype.getAllVerificationList = function (access_token) {
-        return VerificationService_1.VerificationService.getAllVerificationList(access_token);
-    };
+    getAllVerificationList(access_token) {
+        return VerificationService.getAllVerificationList(access_token);
+    }
     ;
     /**
      * initiate link accoount
@@ -769,9 +722,9 @@ var WebAuth = /** @class */ (function () {
      * @param access_token
      * @returns
      */
-    WebAuth.prototype.initiateLinkAccount = function (options, access_token) {
-        return UserService_1.UserService.initiateLinkAccount(options, access_token);
-    };
+    initiateLinkAccount(options, access_token) {
+        return UserService.initiateLinkAccount(options, access_token);
+    }
     ;
     /**
      * complete link accoount
@@ -779,9 +732,9 @@ var WebAuth = /** @class */ (function () {
      * @param access_token
      * @returns
      */
-    WebAuth.prototype.completeLinkAccount = function (options, access_token) {
-        return UserService_1.UserService.completeLinkAccount(options, access_token);
-    };
+    completeLinkAccount(options, access_token) {
+        return UserService.completeLinkAccount(options, access_token);
+    }
     ;
     /**
      * get linked users
@@ -789,9 +742,9 @@ var WebAuth = /** @class */ (function () {
      * @param sub
      * @returns
      */
-    WebAuth.prototype.getLinkedUsers = function (access_token, sub) {
-        return UserService_1.UserService.getLinkedUsers(access_token, sub);
-    };
+    getLinkedUsers(access_token, sub) {
+        return UserService.getLinkedUsers(access_token, sub);
+    }
     ;
     /**
      * unlink accoount
@@ -799,9 +752,9 @@ var WebAuth = /** @class */ (function () {
      * @param identityId
      * @returns
      */
-    WebAuth.prototype.unlinkAccount = function (access_token, identityId) {
-        return UserService_1.UserService.unlinkAccount(access_token, identityId);
-    };
+    unlinkAccount(access_token, identityId) {
+        return UserService.unlinkAccount(access_token, identityId);
+    }
     ;
     /**
     * To change profile image, call **updateProfileImage()**.
@@ -820,70 +773,70 @@ var WebAuth = /** @class */ (function () {
     * });
     * ```
     */
-    WebAuth.prototype.updateProfileImage = function (options, access_token) {
-        var serviceURL = window.webAuthSettings.authority + "/image-srv/profile/upload";
-        var form = document.createElement('form');
+    updateProfileImage(options, access_token) {
+        const serviceURL = window.webAuthSettings.authority + "/image-srv/profile/upload";
+        const form = document.createElement('form');
         form.action = serviceURL;
         form.method = 'POST';
-        var image_key = document.createElement('input');
+        const image_key = document.createElement('input');
         image_key.setAttribute('type', 'hidden');
         image_key.setAttribute('name', 'image_key');
         form.appendChild(image_key);
-        var photo = document.createElement('input');
+        const photo = document.createElement('input');
         photo.setAttribute('type', 'file');
         photo.setAttribute('hidden', 'true');
         photo.setAttribute("name", "photo");
         form.appendChild(photo);
-        var formdata = new FormData(form);
+        const formdata = new FormData(form);
         formdata.set('image_key', options.image_key);
         formdata.set('photo', options.photo, options.filename);
-        return Helper_1.Helper.createHttpPromise(options, serviceURL, undefined, 'POST', access_token, null, formdata);
-    };
+        return Helper.createHttpPromise(options, serviceURL, undefined, 'POST', access_token, null, formdata);
+    }
     ;
     /**
      * enrollVerification
      * @param options
      * @returns
      */
-    WebAuth.prototype.initiateEnrollment = function (options, accessToken) {
-        return VerificationService_1.VerificationService.initiateEnrollment(options, accessToken);
-    };
+    initiateEnrollment(options, accessToken) {
+        return VerificationService.initiateEnrollment(options, accessToken);
+    }
     ;
     /**
      * update the status of notification
      * @param status_id
      * @returns
      */
-    WebAuth.prototype.getEnrollmentStatus = function (status_id, accessToken) {
-        return VerificationService_1.VerificationService.getEnrollmentStatus(status_id, accessToken);
-    };
+    getEnrollmentStatus(status_id, accessToken) {
+        return VerificationService.getEnrollmentStatus(status_id, accessToken);
+    }
     ;
     /**
      * enrollVerification
      * @param options
      * @returns
      */
-    WebAuth.prototype.enrollVerification = function (options) {
-        return VerificationService_1.VerificationService.enrollVerification(options);
-    };
+    enrollVerification(options) {
+        return VerificationService.enrollVerification(options);
+    }
     ;
     /**
      * checkVerificationTypeConfigured
      * @param options
      * @returns
      */
-    WebAuth.prototype.checkVerificationTypeConfigured = function (options) {
-        return VerificationService_1.VerificationService.checkVerificationTypeConfigured(options);
-    };
+    checkVerificationTypeConfigured(options) {
+        return VerificationService.checkVerificationTypeConfigured(options);
+    }
     ;
     /**
      * deleteUserAccount
      * @param options
      * @returns
      */
-    WebAuth.prototype.deleteUserAccount = function (options) {
-        return UserService_1.UserService.deleteUserAccount(options);
-    };
+    deleteUserAccount(options) {
+        return UserService.deleteUserAccount(options);
+    }
     ;
     /**
      * getMissingFields
@@ -904,15 +857,15 @@ var WebAuth = /** @class */ (function () {
      * ```
      *
      */
-    WebAuth.prototype.getMissingFields = function (trackId, useSocialProvider) {
+    getMissingFields(trackId, useSocialProvider) {
         if (useSocialProvider) {
-            var _serviceURL = window.webAuthSettings.authority + "/public-srv/public/trackinfo/" + useSocialProvider.requestId + "/" + trackId;
-            return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
+            const _serviceURL = window.webAuthSettings.authority + "/public-srv/public/trackinfo/" + useSocialProvider.requestId + "/" + trackId;
+            return Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
         }
         else {
-            return TokenService_1.TokenService.getMissingFields(trackId);
+            return TokenService.getMissingFields(trackId);
         }
-    };
+    }
     ;
     /**
      * progressiveRegistration
@@ -920,68 +873,66 @@ var WebAuth = /** @class */ (function () {
      * @param headers
      * @returns
      */
-    WebAuth.prototype.progressiveRegistration = function (options, headers) {
-        return LoginService_1.LoginService.progressiveRegistration(options, headers);
-    };
+    progressiveRegistration(options, headers) {
+        return LoginService.progressiveRegistration(options, headers);
+    }
     ;
     /**
      * device code flow - initiate
      */
-    WebAuth.prototype.initiateDeviceCode = function (clientId) {
-        return TokenService_1.TokenService.initiateDeviceCode(clientId);
-    };
+    initiateDeviceCode(clientId) {
+        return TokenService.initiateDeviceCode(clientId);
+    }
     /**
      * device code flow - verify
      * @param code
      */
-    WebAuth.prototype.deviceCodeVerify = function (code) {
-        TokenService_1.TokenService.deviceCodeVerify(code);
-    };
+    deviceCodeVerify(code) {
+        TokenService.deviceCodeVerify(code);
+    }
     /**
      * check if an user exists
      * @param options
      * @returns
      */
-    WebAuth.prototype.userCheckExists = function (options) {
-        return UserService_1.UserService.userCheckExists(options);
-    };
+    userCheckExists(options) {
+        return UserService.userCheckExists(options);
+    }
     ;
     /**
      * To set accept language
      * @param acceptLanguage
      */
-    WebAuth.prototype.setAcceptLanguageHeader = function (acceptLanguage) {
+    setAcceptLanguageHeader(acceptLanguage) {
         window.localeSettings = acceptLanguage;
-    };
+    }
     /**
      * initiate mfa
      * @param options
      * @returns
      */
-    WebAuth.prototype.initiateMFA = function (options, accessToken) {
+    initiateMFA(options, accessToken) {
         // TODO: remove accessToken parameter in the next major release
         if (accessToken) {
-            return VerificationService_1.VerificationService.initiateMFA(options, accessToken);
+            return VerificationService.initiateMFA(options, accessToken);
         }
-        return VerificationService_1.VerificationService.initiateMFA(options);
-    };
+        return VerificationService.initiateMFA(options);
+    }
     ;
     /**
      * authenticate mfa
      * @param options
      * @returns
      */
-    WebAuth.prototype.authenticateMFA = function (options) {
-        return VerificationService_1.VerificationService.authenticateMFA(options);
-    };
+    authenticateMFA(options) {
+        return VerificationService.authenticateMFA(options);
+    }
     ;
     /**
      * offline token check
      */
-    WebAuth.prototype.offlineTokenCheck = function (accessToken) {
-        return TokenService_1.TokenService.offlineTokenCheck(accessToken);
-    };
+    offlineTokenCheck(accessToken) {
+        return TokenService.offlineTokenCheck(accessToken);
+    }
     ;
-    return WebAuth;
-}());
-exports.WebAuth = WebAuth;
+}