@microsoft/teams-js 2.0.0-beta.6-dev.6 → 2.0.0-beta.6-dev.9

package/dist/MicrosoftTeams.js

@@ -1122,7 +1122,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 ;// CONCATENATED MODULE: ./src/internal/constants.ts
-var version = "2.0.0-beta.6-dev.6";
+var version = "2.0.0-beta.6-dev.9";
 /**
  * @hidden
  * The client version when all SDK APIs started to check platform compatibility for the APIs was 1.6.0.
@@ -2366,8 +2366,6 @@ var runtime = {
         location: undefined,
         logs: undefined,
         mail: undefined,
-        media: undefined,
-        meeting: undefined,
         meetingRoom: undefined,
         menus: undefined,
         monetization: undefined,
@@ -2405,8 +2403,6 @@ var teamsRuntimeConfig = {
             update: {},
         },
         logs: {},
-        media: {},
-        meeting: {},
         meetingRoom: {},
         menus: {},
         monetization: {},
@@ -2495,6 +2491,29 @@ function generateBackCompatRuntimeConfig(highestSupportedVersion) {
 function applyRuntimeConfig(runtimeConfig) {
     runtime = deepFreeze(runtimeConfig);
 }
+/**
+ * @hidden
+ * Hide from docs.
+ * ------
+ * Constant used to set minimum runtime configuration
+ * while un-initializing an app in unit test case.
+ *
+ * @internal
+ */
+var _minRuntimeConfigToUninitialize = {
+    apiVersion: 1,
+    supports: {
+        pages: {
+            appButton: {},
+            tabs: {},
+            config: {},
+            backStack: {},
+            fullTrust: {},
+        },
+        teamsCore: {},
+        logs: {},
+    },
+};
 
 ;// CONCATENATED MODULE: ./src/public/dialog.ts
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
@@ -5008,9 +5027,9 @@ var __extends = (undefined && undefined.__extends) || (function () {
 
 
 
-
 /**
- * @alpha
+ * @deprecated
+ * As of 2.0.0-beta.6, use media only for backwards compatibility of existing code.
  */
 var media;
 (function (media) {
@@ -5031,20 +5050,35 @@ var media;
         return File;
     }());
     media.File = File;
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Launch camera, capture image or choose image from gallery and return the images as a File[] object to the callback.
+     *
+     * @params callback - Callback will be called with an @see SdkError if there are any.
+     * If error is null or undefined, the callback will be called with a collection of @see File objects
+     * @remarks
+     * Note: Currently we support getting one File through this API, i.e. the file arrays size will be one.
+     * Note: For desktop, this API is not supported. Callback will be resolved with ErrorCode.NotSupported.
+     *
+     */
     function captureImage(callback) {
+        if (!callback) {
+            throw new Error('[captureImage] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (!GlobalVars.isFramelessWindow) {
-                    throw { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
-                }
-                if (!isCurrentSDKVersionAtLeast(captureImageMobileSupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                resolve(sendAndHandleSdkError('captureImage'));
-            });
-        };
-        return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+        if (!GlobalVars.isFramelessWindow) {
+            var notSupportedError = { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
+            callback(notSupportedError, undefined);
+            return;
+        }
+        if (!isCurrentSDKVersionAtLeast(captureImageMobileSupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError, undefined);
+            return;
+        }
+        sendMessageToParent('captureImage', callback);
     }
     media.captureImage = captureImage;
     /**
@@ -5065,95 +5099,105 @@ var media;
             }
             return _this;
         }
+        /**
+         * Gets the media in chunks irrespective of size, these chunks are assembled and sent back to the webapp as file/blob
+         * @param callback - callback is called with the @see SdkError if there is an error
+         * If error is null or undefined, the callback will be called with @see Blob.
+         */
         Media.prototype.getMedia = function (callback) {
-            var _this = this;
+            if (!callback) {
+                throw new Error('[get Media] Callback cannot be null');
+            }
             ensureInitialized(FrameContexts.content, FrameContexts.task);
-            var wrappedFunction = function () {
-                return new Promise(function (resolve) {
-                    if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
-                        throw { errorCode: ErrorCode.OLD_PLATFORM };
-                    }
-                    if (!validateGetMediaInputs(_this.mimeType, _this.format, _this.content)) {
-                        throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                    }
-                    // Call the new get media implementation via callbacks if the client version is greater than or equal to '2.0.0'
-                    if (isCurrentSDKVersionAtLeast(getMediaCallbackSupportVersion)) {
-                        resolve(_this.getMediaViaCallback());
-                    }
-                    else {
-                        resolve(_this.getMediaViaHandler());
-                    }
-                });
-            };
-            return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+            if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
+                var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+                callback(oldPlatformError, null);
+                return;
+            }
+            if (!validateGetMediaInputs(this.mimeType, this.format, this.content)) {
+                var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+                callback(invalidInput, null);
+                return;
+            }
+            // Call the new get media implementation via callbacks if the client version is greater than or equal to '2.0.0'
+            if (isCurrentSDKVersionAtLeast(getMediaCallbackSupportVersion)) {
+                this.getMediaViaCallback(callback);
+            }
+            else {
+                this.getMediaViaHandler(callback);
+            }
         };
-        Media.prototype.getMediaViaCallback = function () {
-            var _this = this;
-            return new Promise(function (resolve, reject) {
-                var helper = {
-                    mediaMimeType: _this.mimeType,
-                    assembleAttachment: [],
-                };
-                var localUriId = [_this.content];
-                sendMessageToParent('getMedia', localUriId, function (mediaResult) {
+        Media.prototype.getMediaViaCallback = function (callback) {
+            var helper = {
+                mediaMimeType: this.mimeType,
+                assembleAttachment: [],
+            };
+            var localUriId = [this.content];
+            function handleGetMediaCallbackRequest(mediaResult) {
+                if (callback) {
                     if (mediaResult && mediaResult.error) {
-                        reject(mediaResult.error);
-                    }
-                    else if (!mediaResult || !mediaResult.mediaChunk) {
-                        reject({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' });
-                    }
-                    else if (mediaResult.mediaChunk.chunkSequence <= 0) {
-                        var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
-                        resolve(file);
+                        callback(mediaResult.error, null);
                     }
                     else {
-                        // Keep pushing chunks into assemble attachment
-                        var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
-                        helper.assembleAttachment.push(assemble);
-                    }
-                });
-            });
-        };
-        Media.prototype.getMediaViaHandler = function () {
-            var _this = this;
-            return new Promise(function (resolve, reject) {
-                var actionName = generateGUID();
-                var helper = {
-                    mediaMimeType: _this.mimeType,
-                    assembleAttachment: [],
-                };
-                var params = [actionName, _this.content];
-                _this.content && sendMessageToParent('getMedia', params);
-                registerHandler('getMedia' + actionName, function (response) {
-                    try {
-                        var mediaResult = JSON.parse(response);
-                        if (mediaResult.error) {
-                            reject(mediaResult.error);
-                            removeHandler('getMedia' + actionName);
+                        if (mediaResult && mediaResult.mediaChunk) {
+                            // If the chunksequence number is less than equal to 0 implies EOF
+                            // create file/blob when all chunks have arrived and we get 0/-1 as chunksequence number
+                            if (mediaResult.mediaChunk.chunkSequence <= 0) {
+                                var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
+                                callback(mediaResult.error, file);
+                            }
+                            else {
+                                // Keep pushing chunks into assemble attachment
+                                var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
+                                helper.assembleAttachment.push(assemble);
+                            }
                         }
-                        else if (!mediaResult || !mediaResult.mediaChunk) {
-                            reject({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' });
-                            removeHandler('getMedia' + actionName);
+                        else {
+                            callback({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' }, null);
                         }
-                        else if (mediaResult.mediaChunk.chunkSequence <= 0) {
+                    }
+                }
+            }
+            sendMessageToParent('getMedia', localUriId, handleGetMediaCallbackRequest);
+        };
+        Media.prototype.getMediaViaHandler = function (callback) {
+            var actionName = generateGUID();
+            var helper = {
+                mediaMimeType: this.mimeType,
+                assembleAttachment: [],
+            };
+            var params = [actionName, this.content];
+            this.content && callback && sendMessageToParent('getMedia', params);
+            function handleGetMediaRequest(response) {
+                if (callback) {
+                    var mediaResult = JSON.parse(response);
+                    if (mediaResult.error) {
+                        callback(mediaResult.error, null);
+                        removeHandler('getMedia' + actionName);
+                    }
+                    else {
+                        if (mediaResult.mediaChunk) {
                             // If the chunksequence number is less than equal to 0 implies EOF
                             // create file/blob when all chunks have arrived and we get 0/-1 as chunksequence number
-                            var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
-                            resolve(file);
-                            removeHandler('getMedia' + actionName);
+                            if (mediaResult.mediaChunk.chunkSequence <= 0) {
+                                var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
+                                callback(mediaResult.error, file);
+                                removeHandler('getMedia' + actionName);
+                            }
+                            else {
+                                // Keep pushing chunks into assemble attachment
+                                var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
+                                helper.assembleAttachment.push(assemble);
+                            }
                         }
                         else {
-                            // Keep pushing chunks into assemble attachment
-                            var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
-                            helper.assembleAttachment.push(assemble);
+                            callback({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' }, null);
+                            removeHandler('getMedia' + actionName);
                         }
                     }
-                    catch (err) {
-                        // catch JSON.parse() errors
-                        reject({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'Error parsing the response: ' + response });
-                    }
-                });
-            });
+                }
+            }
+            registerHandler('getMedia' + actionName, handleGetMediaRequest);
         };
         return Media;
     }(File));
@@ -5168,26 +5212,38 @@ var media;
         function MediaController(controllerCallback) {
             this.controllerCallback = controllerCallback;
         }
+        /**
+         * @hidden
+         * Hide from docs
+         * --------
+         * Function to notify the host client to programatically control the experience
+         * @param mediaEvent indicates what the event that needs to be signaled to the host client
+         * Optional; @param callback is used to send app if host client has successfully handled the notification event or not
+         */
         MediaController.prototype.notifyEventToHost = function (mediaEvent, callback) {
             ensureInitialized(FrameContexts.content, FrameContexts.task);
             try {
                 throwExceptionIfMobileApiIsNotSupported(nonFullScreenVideoModeAPISupportVersion);
             }
             catch (err) {
-                var wrappedRejectedErrorFn = function () { return Promise.reject(err); };
-                return callCallbackWithSdkErrorFromPromiseAndReturnPromise(wrappedRejectedErrorFn, callback);
+                if (callback) {
+                    callback(err);
+                }
+                return;
             }
-            var params = {
-                mediaType: this.getMediaType(),
-                mediaControllerEvent: mediaEvent,
-            };
-            var wrappedFunction = function () {
-                return new Promise(function (resolve) { return resolve(sendAndHandleSdkError('media.controller', [params])); });
-            };
-            return callCallbackWithSdkErrorFromPromiseAndReturnPromise(wrappedFunction, callback);
+            var params = { mediaType: this.getMediaType(), mediaControllerEvent: mediaEvent };
+            sendMessageToParent('media.controller', [params], function (err) {
+                if (callback) {
+                    callback(err);
+                }
+            });
         };
+        /**
+         * Function to programatically stop the ongoing media event
+         * Optional; @param callback is used to send app if host client has successfully stopped the event or not
+         */
         MediaController.prototype.stop = function (callback) {
-            return Promise.resolve(this.notifyEventToHost(MediaControllerEvent.StopRecording, callback));
+            this.notifyEventToHost(MediaControllerEvent.StopRecording, callback);
         };
         return MediaController;
     }());
@@ -5203,14 +5259,16 @@ var media;
             return MediaType.Video;
         };
         VideoController.prototype.notifyEventToApp = function (mediaEvent) {
+            if (!this.controllerCallback) {
+                // Early return as app has not registered with the callback
+                return;
+            }
             switch (mediaEvent) {
                 case MediaControllerEvent.StartRecording:
-                    this.controllerCallback.onRecordingStarted();
-                    break;
-                // TODO - Should discuss whether this function should be required
-                case MediaControllerEvent.StopRecording:
-                    this.controllerCallback.onRecordingStopped && this.controllerCallback.onRecordingStopped();
-                    break;
+                    if (this.controllerCallback.onRecordingStarted) {
+                        this.controllerCallback.onRecordingStarted();
+                        break;
+                    }
             }
         };
         return VideoController;
@@ -5271,109 +5329,128 @@ var media;
         ImageOutputFormats[ImageOutputFormats["IMAGE"] = 1] = "IMAGE";
         ImageOutputFormats[ImageOutputFormats["PDF"] = 2] = "PDF";
     })(ImageOutputFormats = media.ImageOutputFormats || (media.ImageOutputFormats = {}));
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Select an attachment using camera/gallery
+     *
+     * @param mediaInputs - The input params to customize the media to be selected
+     * @param callback - The callback to invoke after fetching the media
+     */
     function selectMedia(mediaInputs, callback) {
+        if (!callback) {
+            throw new Error('[select Media] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                throwExceptionIfMediaCallIsNotSupportedOnMobile(mediaInputs);
-                if (!validateSelectMediaInputs(mediaInputs)) {
-                    throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                }
-                var params = [mediaInputs];
-                // What comes back from native at attachments would just be objects and will be missing getMedia method on them.
-                resolve(sendMessageToParentAsync('selectMedia', params));
-            }).then(function (_a) {
-                var err = _a[0], localAttachments = _a[1], mediaEvent = _a[2];
-                // MediaControllerEvent response is used to notify the app about events and is a partial response to selectMedia
-                if (mediaEvent) {
-                    if (isVideoControllerRegistered(mediaInputs)) {
-                        mediaInputs.videoProps.videoController.notifyEventToApp(mediaEvent);
-                    }
-                    return [];
-                }
-                // Media Attachments are final response to selectMedia
-                if (!localAttachments) {
-                    throw err;
-                }
-                var mediaArray = [];
-                for (var _i = 0, localAttachments_1 = localAttachments; _i < localAttachments_1.length; _i++) {
-                    var attachment = localAttachments_1[_i];
-                    mediaArray.push(new Media(attachment));
+        if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError, null);
+            return;
+        }
+        try {
+            throwExceptionIfMediaCallIsNotSupportedOnMobile(mediaInputs);
+        }
+        catch (err) {
+            callback(err, null);
+            return;
+        }
+        if (!validateSelectMediaInputs(mediaInputs)) {
+            var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+            callback(invalidInput, null);
+            return;
+        }
+        var params = [mediaInputs];
+        // What comes back from native as attachments would just be objects and will be missing getMedia method on them
+        sendMessageToParent('selectMedia', params, function (err, localAttachments, mediaEvent) {
+            // MediaControllerEvent response is used to notify the app about events and is a partial response to selectMedia
+            if (mediaEvent) {
+                if (isVideoControllerRegistered(mediaInputs)) {
+                    mediaInputs.videoProps.videoController.notifyEventToApp(mediaEvent);
                 }
-                return mediaArray;
-            });
-        };
-        return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+                return;
+            }
+            // Media Attachments are final response to selectMedia
+            if (!localAttachments) {
+                callback(err, null);
+                return;
+            }
+            var mediaArray = [];
+            for (var _i = 0, localAttachments_1 = localAttachments; _i < localAttachments_1.length; _i++) {
+                var attachment = localAttachments_1[_i];
+                mediaArray.push(new Media(attachment));
+            }
+            callback(err, mediaArray);
+        });
     }
     media.selectMedia = selectMedia;
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * View images using native image viewer
+     * @param uriList - list of URIs for images to be viewed - can be content URI or server URL. Supports up to 10 Images in a single call
+     * @param callback - returns back error if encountered, returns null in case of success
+     */
     function viewImages(uriList, callback) {
+        if (!callback) {
+            throw new Error('[view images] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                if (!validateViewImagesInput(uriList)) {
-                    throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                }
-                resolve(sendAndHandleSdkError('viewImages', uriList));
-            });
-        };
-        return callCallbackWithSdkErrorFromPromiseAndReturnPromise(wrappedFunction, callback);
+        if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError);
+            return;
+        }
+        if (!validateViewImagesInput(uriList)) {
+            var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+            callback(invalidInput);
+            return;
+        }
+        var params = [uriList];
+        sendMessageToParent('viewImages', params, callback);
     }
     media.viewImages = viewImages;
-    function scanBarCode(callbackOrConfig, configMaybe) {
-        var callback;
-        var config;
-        // Because the callback isn't the second parameter in the original v1 method we need to
-        // do a bit of trickery to see which of the two ways were used to call into
-        // the flow and if the first parameter is a callback (v1) or a config object (v2)
-        if (callbackOrConfig === undefined) {
-            // no first parameter - the second one might be a config, definitely no callback
-            config = configMaybe;
-        }
-        else {
-            if (typeof callbackOrConfig === 'object') {
-                // the first parameter is an object - it's the config! No callback.
-                config = callbackOrConfig;
-            }
-            else {
-                // otherwise, it's a function, so a callback. The second parameter might be a callback
-                callback = callbackOrConfig;
-                config = configMaybe;
-            }
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Scan Barcode/QRcode using camera
+     * @remarks
+     * Note: For desktop and web, this API is not supported. Callback will be resolved with ErrorCode.NotSupported.
+     *
+     * @param callback - callback to invoke after scanning the barcode
+     * @param config - optional input configuration to customize the barcode scanning experience
+     */
+    function scanBarCode(callback, config) {
+        if (!callback) {
+            throw new Error('[media.scanBarCode] Callback cannot be null');
         }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (GlobalVars.hostClientType === HostClientType.desktop ||
-                    GlobalVars.hostClientType === HostClientType.web ||
-                    GlobalVars.hostClientType === HostClientType.rigel ||
-                    GlobalVars.hostClientType === HostClientType.teamsRoomsWindows ||
-                    GlobalVars.hostClientType === HostClientType.teamsRoomsAndroid ||
-                    GlobalVars.hostClientType === HostClientType.teamsPhones ||
-                    GlobalVars.hostClientType === HostClientType.teamsDisplays) {
-                    throw { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
-                }
-                if (!isCurrentSDKVersionAtLeast(scanBarCodeAPIMobileSupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                if (!validateScanBarCodeInput(config)) {
-                    throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                }
-                resolve(sendAndHandleSdkError('media.scanBarCode', config));
-            });
-        };
-        return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+        if (GlobalVars.hostClientType === HostClientType.desktop ||
+            GlobalVars.hostClientType === HostClientType.web ||
+            GlobalVars.hostClientType === HostClientType.rigel ||
+            GlobalVars.hostClientType === HostClientType.teamsRoomsWindows ||
+            GlobalVars.hostClientType === HostClientType.teamsRoomsAndroid ||
+            GlobalVars.hostClientType === HostClientType.teamsPhones ||
+            GlobalVars.hostClientType === HostClientType.teamsDisplays) {
+            var notSupportedError = { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
+            callback(notSupportedError, null);
+            return;
+        }
+        if (!isCurrentSDKVersionAtLeast(scanBarCodeAPIMobileSupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError, null);
+            return;
+        }
+        if (!validateScanBarCodeInput(config)) {
+            var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+            callback(invalidInput, null);
+            return;
+        }
+        sendMessageToParent('media.scanBarCode', [config], callback);
     }
     media.scanBarCode = scanBarCode;
-    function isSupported() {
-        return runtime.supports.media ? true : false;
-    }
-    media.isSupported = isSupported;
 })(media || (media = {}));
 
 ;// CONCATENATED MODULE: ./src/public/location.ts
@@ -5439,10 +5516,9 @@ var location_location;
 
 
 
-
-
 /**
- * @alpha
+ * @deprecated
+ * As of 2.0.0-beta.6, use meeting only for backwards compatibility of existing code.
  */
 var meeting;
 (function (meeting) {
@@ -5455,102 +5531,156 @@ var meeting;
         MeetingType["Broadcast"] = "Broadcast";
         MeetingType["MeetNow"] = "MeetNow";
     })(MeetingType = meeting.MeetingType || (meeting.MeetingType = {}));
+    var CallType;
+    (function (CallType) {
+        CallType["OneOnOneCall"] = "oneOnOneCall";
+        CallType["GroupCall"] = "groupCall";
+    })(CallType = meeting.CallType || (meeting.CallType = {}));
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Allows an app to get the incoming audio speaker setting for the meeting user
+     *
+     * @param callback - Callback contains 2 parameters, error and result.
+     *
+     * error can either contain an error of type SdkError, incase of an error, or null when fetch is successful
+     * result can either contain the true/false value, incase of a successful fetch or null when the fetching fails
+     * result: True means incoming audio is muted and false means incoming audio is unmuted
+     */
     function getIncomingClientAudioState(callback) {
+        if (!callback) {
+            throw new Error('[get incoming client audio state] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(getIncomingClientAudioStateHelper, callback);
+        sendMessageToParent('getIncomingClientAudioState', callback);
     }
     meeting.getIncomingClientAudioState = getIncomingClientAudioState;
-    function getIncomingClientAudioStateHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('getIncomingClientAudioState'));
-        });
-    }
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Allows an app to toggle the incoming audio speaker setting for the meeting user from mute to unmute or vice-versa
+     *
+     * @param callback - Callback contains 2 parameters, error and result.
+     * error can either contain an error of type SdkError, incase of an error, or null when toggle is successful
+     * result can either contain the true/false value, incase of a successful toggle or null when the toggling fails
+     * result: True means incoming audio is muted and false means incoming audio is unmuted
+     */
     function toggleIncomingClientAudio(callback) {
+        if (!callback) {
+            throw new Error('[toggle incoming client audio] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(toggleIncomingClientAudioHelper, callback);
+        sendMessageToParent('toggleIncomingClientAudio', callback);
     }
     meeting.toggleIncomingClientAudio = toggleIncomingClientAudio;
-    function toggleIncomingClientAudioHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('toggleIncomingClientAudio'));
-        });
-    }
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * @hidden
+     * Hide from docs
+     *
+     * Allows an app to get the meeting details for the meeting
+     *
+     * @param callback - Callback contains 2 parameters, error and meetingDetailsResponse.
+     * error can either contain an error of type SdkError, incase of an error, or null when get is successful
+     * result can either contain a IMeetingDetailsResponse value, incase of a successful get or null when the get fails
+     *
+     * @internal
+     */
     function getMeetingDetails(callback) {
+        if (!callback) {
+            throw new Error('[get meeting details] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage, FrameContexts.settings, FrameContexts.content);
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(getMeetingDetailsHelper, callback);
+        sendMessageToParent('meeting.getMeetingDetails', callback);
     }
     meeting.getMeetingDetails = getMeetingDetails;
-    function getMeetingDetailsHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.getMeetingDetails'));
-        });
-    }
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * @hidden
+     * Allows an app to get the authentication token for the anonymous or guest user in the meeting
+     *
+     * @param callback - Callback contains 2 parameters, error and authenticationTokenOfAnonymousUser.
+     * error can either contain an error of type SdkError, incase of an error, or null when get is successful
+     * authenticationTokenOfAnonymousUser can either contain a string value, incase of a successful get or null when the get fails
+     *
+     * @internal
+     */
     function getAuthenticationTokenForAnonymousUser(callback) {
+        if (!callback) {
+            throw new Error('[get Authentication Token For AnonymousUser] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(getAuthenticationTokenForAnonymousUserHelper, callback);
+        sendMessageToParent('meeting.getAuthenticationTokenForAnonymousUser', callback);
     }
     meeting.getAuthenticationTokenForAnonymousUser = getAuthenticationTokenForAnonymousUser;
-    function getAuthenticationTokenForAnonymousUserHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.getAuthenticationTokenForAnonymousUser'));
-        });
-    }
-    function isSupported() {
-        return runtime.supports.meeting ? true : false;
-    }
-    meeting.isSupported = isSupported;
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Allows an app to get the state of the live stream in the current meeting
+     *
+     * @param callback - Callback contains 2 parameters: error and liveStreamState.
+     * error can either contain an error of type SdkError, in case of an error, or null when get is successful
+     * liveStreamState can either contain a LiveStreamState value, or null when operation fails
+     */
     function getLiveStreamState(callback) {
-        ensureInitialized();
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(getLiveStreamStateHelper, callback);
+        if (!callback) {
+            throw new Error('[get live stream state] Callback cannot be null');
+        }
+        ensureInitialized(FrameContexts.sidePanel);
+        sendMessageToParent('meeting.getLiveStreamState', callback);
     }
     meeting.getLiveStreamState = getLiveStreamState;
-    function getLiveStreamStateHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.getLiveStreamState'));
-        });
-    }
     /**
-     * @hidden
-     * This function is the overloaded implementation of requestStartLiveStreaming.
-     * Since the method signatures of the v1 callback and v2 promise differ in the type of the first parameter,
-     * we need to do an extra check to know the typeof the @param1 to set the proper arguments of the utility function.
-     * @param param1
-     * @param param2
-     * @param param3
-     * @returns Promise that will be resolved when the operation has completed or rejected with SdkError value
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Allows an app to request the live streaming be started at the given streaming url
+     *
+     * @remarks
+     * Use getLiveStreamState or registerLiveStreamChangedHandler to get updates on the live stream state
+     *
+     * @param streamUrl - the url to the stream resource
+     * @param streamKey - the key to the stream resource
+     * @param callback - Callback contains error parameter which can be of type SdkError in case of an error, or null when operation is successful
      */
-    function requestStartLiveStreaming(param1, param2, param3) {
-        var _a, _b;
-        ensureInitialized(FrameContexts.sidePanel);
-        var streamUrl;
-        var streamKey;
-        var callback;
-        if (typeof param1 === 'function') {
-            // Legacy code, with callbacks.
-            _a = [param1, param2, param3], callback = _a[0], streamUrl = _a[1], streamKey = _a[2];
-        }
-        else if (typeof param1 === 'string') {
-            _b = [param1, param2], streamUrl = _b[0], streamKey = _b[1];
+    function requestStartLiveStreaming(callback, streamUrl, streamKey) {
+        if (!callback) {
+            throw new Error('[request start live streaming] Callback cannot be null');
         }
-        return callCallbackWithSdkErrorFromPromiseAndReturnPromise(requestStartLiveStreamingHelper, callback, streamUrl, streamKey);
+        ensureInitialized(FrameContexts.sidePanel);
+        sendMessageToParent('meeting.requestStartLiveStreaming', [streamUrl, streamKey], callback);
     }
     meeting.requestStartLiveStreaming = requestStartLiveStreaming;
-    function requestStartLiveStreamingHelper(streamUrl, streamKey) {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.requestStartLiveStreaming', streamUrl, streamKey));
-        });
-    }
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Allows an app to request the live streaming be stopped at the given streaming url
+     *
+     * @remarks
+     * Use getLiveStreamState or registerLiveStreamChangedHandler to get updates on the live stream state
+     *
+     * @param callback - Callback contains error parameter which can be of type SdkError in case of an error, or null when operation is successful
+     */
     function requestStopLiveStreaming(callback) {
+        if (!callback) {
+            throw new Error('[request stop live streaming] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel);
-        return callCallbackWithSdkErrorFromPromiseAndReturnPromise(requestStopLiveStreamingHelper, callback);
+        sendMessageToParent('meeting.requestStopLiveStreaming', callback);
     }
     meeting.requestStopLiveStreaming = requestStopLiveStreaming;
-    function requestStopLiveStreamingHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.requestStopLiveStreaming'));
-        });
-    }
     /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
      * Registers a handler for changes to the live stream.
      *
      * @remarks
@@ -5567,81 +5697,90 @@ var meeting;
     }
     meeting.registerLiveStreamChangedHandler = registerLiveStreamChangedHandler;
     /**
-     * This function is the overloaded implementation of shareAppContentToStage.
-     * Since the method signatures of the v1 callback and v2 promise differ in the type of the first parameter,
-     * we need to do an extra check to know the typeof the @param1 to set the proper arguments of the utility function.
-     * @param param1
-     * @param param2
-     * @returns Promise resolved indicating whether or not the share was successful or rejected with SdkError value
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Allows an app to share contents in the meeting
+     *
+     * @param callback - Callback contains 2 parameters, error and result.
+     * error can either contain an error of type SdkError, incase of an error, or null when share is successful
+     * result can either contain a true value, incase of a successful share or null when the share fails
+     * @param appContentUrl - is the input URL which needs to be shared on to the stage
      */
-    function shareAppContentToStage(param1, param2) {
-        var _a;
-        ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
-        var appContentUrl;
-        var callback;
-        if (typeof param1 === 'function') {
-            // Legacy callback
-            _a = [param1, param2], callback = _a[0], appContentUrl = _a[1];
-        }
-        else {
-            appContentUrl = param1;
+    function shareAppContentToStage(callback, appContentUrl) {
+        if (!callback) {
+            throw new Error('[share app content to stage] Callback cannot be null');
         }
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(shareAppContentToStageHelper, callback, appContentUrl);
+        ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
+        sendMessageToParent('meeting.shareAppContentToStage', [appContentUrl], callback);
     }
     meeting.shareAppContentToStage = shareAppContentToStage;
     /**
-     * @hidden
-     * Helper method to generate and return a promise for shareAppContentToStage
-     * @param appContentUrl
-     * @returns
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Provides information related app's in-meeting sharing capabilities
+     *
+     * @param callback - Callback contains 2 parameters, error and result.
+     * error can either contain an error of type SdkError (error indication), or null (non-error indication)
+     * appContentStageSharingCapabilities can either contain an IAppContentStageSharingCapabilities object
+     * (indication of successful retrieval), or null (indication of failed retrieval)
      */
-    function shareAppContentToStageHelper(appContentUrl) {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.shareAppContentToStage', appContentUrl));
-        });
-    }
     function getAppContentStageSharingCapabilities(callback) {
+        if (!callback) {
+            throw new Error('[get app content stage sharing capabilities] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(getAppContentStageSharingCapabilitiesHelper, callback);
+        sendMessageToParent('meeting.getAppContentStageSharingCapabilities', callback);
     }
     meeting.getAppContentStageSharingCapabilities = getAppContentStageSharingCapabilities;
     /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
      * @hidden
-     * @returns
+     * Hide from docs.
+     * Terminates current stage sharing session in meeting
+     *
+     * @param callback - Callback contains 2 parameters, error and result.
+     * error can either contain an error of type SdkError (error indication), or null (non-error indication)
+     * result can either contain a true boolean value (successful termination), or null (unsuccessful fetch)
      */
-    function getAppContentStageSharingCapabilitiesHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.getAppContentStageSharingCapabilities'));
-        });
-    }
     function stopSharingAppContentToStage(callback) {
+        if (!callback) {
+            throw new Error('[stop sharing app content to stage] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(stopSharingAppContentToStageHelper, callback);
+        sendMessageToParent('meeting.stopSharingAppContentToStage', callback);
     }
     meeting.stopSharingAppContentToStage = stopSharingAppContentToStage;
     /**
-     * @hidden
-     * @returns
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Provides information related to current stage sharing state for app
+     *
+     * @param callback - Callback contains 2 parameters, error and result.
+     * error can either contain an error of type SdkError (error indication), or null (non-error indication)
+     * appContentStageSharingState can either contain an IAppContentStageSharingState object
+     * (indication of successful retrieval), or null (indication of failed retrieval)
      */
-    function stopSharingAppContentToStageHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.stopSharingAppContentToStage'));
-        });
-    }
     function getAppContentStageSharingState(callback) {
+        if (!callback) {
+            throw new Error('[get app content stage sharing state] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.sidePanel, FrameContexts.meetingStage);
-        return callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise(getAppContentStageSharingStateHelper, callback);
+        sendMessageToParent('meeting.getAppContentStageSharingState', callback);
     }
     meeting.getAppContentStageSharingState = getAppContentStageSharingState;
-    function getAppContentStageSharingStateHelper() {
-        return new Promise(function (resolve) {
-            resolve(sendAndHandleSdkError('meeting.getAppContentStageSharingState'));
-        });
-    }
     /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
      * Registers a handler for changes to paticipant speaking states. If any participant is speaking, isSpeakingDetected
      * will be true. If no participants are speaking, isSpeakingDetected will be false. Only one handler can be registered
      * at a time. A subsequent registration replaces an existing registration.
+     *
      * @param handler The handler to invoke when the speaking state of any participant changes (start/stop speaking).
      */
     function registerSpeakingStateChangeHandler(handler) {