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

package/dist/MicrosoftTeams.js

@@ -1089,6 +1089,7 @@ __webpack_require__.d(__webpack_exports__, {
   "navigateCrossDomain": () => (/* reexport */ navigateCrossDomain),
   "navigateToTab": () => (/* reexport */ navigateToTab),
   "notifications": () => (/* reexport */ notifications),
+  "openFilePreview": () => (/* reexport */ openFilePreview),
   "pages": () => (/* reexport */ pages),
   "people": () => (/* reexport */ people),
   "print": () => (/* reexport */ print),
@@ -1121,7 +1122,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 ;// CONCATENATED MODULE: ./src/internal/constants.ts
-var version = "2.0.0-beta.6-dev.5";
+var version = "2.0.0-beta.6-dev.8";
 /**
  * @hidden
  * The client version when all SDK APIs started to check platform compatibility for the APIs was 1.6.0.
@@ -1831,6 +1832,7 @@ function processAdditionalValidOrigins(validMessageOrigins) {
 
 
 
+
 /**
  * @internal
  */
@@ -1926,6 +1928,34 @@ function registerUserSettingsChangeHandler(settingTypes, handler) {
     ensureInitialized();
     registerHandler('userSettingsChange', handler, true, [settingTypes]);
 }
+/**
+ * @hidden
+ * Hide from docs.
+ * ------
+ * Opens a client-friendly preview of the specified file.
+ *
+ * @param file - The file to preview.
+ */
+function openFilePreview(filePreviewParameters) {
+    ensureInitialized(FrameContexts.content, FrameContexts.task);
+    var params = [
+        filePreviewParameters.entityId,
+        filePreviewParameters.title,
+        filePreviewParameters.description,
+        filePreviewParameters.type,
+        filePreviewParameters.objectUrl,
+        filePreviewParameters.downloadUrl,
+        filePreviewParameters.webPreviewUrl,
+        filePreviewParameters.webEditUrl,
+        filePreviewParameters.baseUrl,
+        filePreviewParameters.editFile,
+        filePreviewParameters.subEntityId,
+        filePreviewParameters.viewerAction,
+        filePreviewParameters.fileOpenPreference,
+        filePreviewParameters.conversationId,
+    ];
+    sendMessageToParent('openFilePreview', params);
+}
 
 ;// CONCATENATED MODULE: ./src/public/authentication.ts
 
@@ -2336,8 +2366,6 @@ var runtime = {
         location: undefined,
         logs: undefined,
         mail: undefined,
-        media: undefined,
-        meeting: undefined,
         meetingRoom: undefined,
         menus: undefined,
         monetization: undefined,
@@ -2374,10 +2402,7 @@ var teamsRuntimeConfig = {
             bot: {},
             update: {},
         },
-        files: {},
         logs: {},
-        media: {},
-        meeting: {},
         meetingRoom: {},
         menus: {},
         monetization: {},
@@ -4979,9 +5004,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) {
@@ -5002,20 +5027,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;
     /**
@@ -5036,95 +5076,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));
@@ -5139,26 +5189,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;
     }());
@@ -5174,14 +5236,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;
@@ -5242,109 +5306,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
@@ -5410,10 +5493,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) {
@@ -5426,102 +5508,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
@@ -5538,81 +5674,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) {
@@ -6842,16 +6987,11 @@ var tasks;
 
 
 
-
-
-
 /**
  * @hidden
  * Hide from docs
  * ------
  * Namespace to interact with the files specific part of the SDK.
- *
- * @alpha
  */
 var files;
 (function (files_1) {
@@ -6924,22 +7064,20 @@ var files;
     /**
      * @hidden
      * Hide from docs
-     * ------
-     * Gets a list of cloud storage folders added to the channel
      *
+     * Gets a list of cloud storage folders added to the channel
      * @param channelId - ID of the channel whose cloud storage folders should be retrieved
+     * @param callback - Callback that will be triggered post folders load
      */
-    function getCloudStorageFolders(channelId) {
-        return new Promise(function (resolve) {
-            ensureInitialized(FrameContexts.content);
-            if (!isSupported()) {
-                throw errorNotSupportedOnPlatform;
-            }
-            if (!channelId || channelId.length === 0) {
-                throw new Error('[files.getCloudStorageFolders] channelId name cannot be null or empty');
-            }
-            resolve(sendAndHandleSdkError('files.getCloudStorageFolders', channelId));
-        });
+    function getCloudStorageFolders(channelId, callback) {
+        ensureInitialized(FrameContexts.content);
+        if (!channelId || channelId.length === 0) {
+            throw new Error('[files.getCloudStorageFolders] channelId name cannot be null or empty');
+        }
+        if (!callback) {
+            throw new Error('[files.getCloudStorageFolders] Callback cannot be null');
+        }
+        sendMessageToParent('files.getCloudStorageFolders', [channelId], callback);
     }
     files_1.getCloudStorageFolders = getCloudStorageFolders;
     /**
@@ -6947,82 +7085,76 @@ var files;
      * Hide from docs
      * ------
      * Initiates the add cloud storage folder flow
+     *
      * @param channelId - ID of the channel to add cloud storage folder
+     * @param callback - Callback that will be triggered post add folder flow is compelete
      */
-    function addCloudStorageFolder(channelId) {
-        return new Promise(function (resolve) {
-            ensureInitialized(FrameContexts.content);
-            if (!isSupported()) {
-                throw errorNotSupportedOnPlatform;
-            }
-            if (!channelId || channelId.length === 0) {
-                throw new Error('[files.addCloudStorageFolder] channelId name cannot be null or empty');
-            }
-            resolve(sendMessageToParentAsync('files.addCloudStorageFolder', [channelId]));
-        }).then(function (_a) {
-            var error = _a[0], isFolderAdded = _a[1], folders = _a[2];
-            if (error) {
-                throw error;
-            }
-            var result = [isFolderAdded, folders];
-            return result;
-        });
+    function addCloudStorageFolder(channelId, callback) {
+        ensureInitialized(FrameContexts.content);
+        if (!channelId || channelId.length === 0) {
+            throw new Error('[files.addCloudStorageFolder] channelId name cannot be null or empty');
+        }
+        if (!callback) {
+            throw new Error('[files.addCloudStorageFolder] Callback cannot be null');
+        }
+        sendMessageToParent('files.addCloudStorageFolder', [channelId], callback);
     }
     files_1.addCloudStorageFolder = addCloudStorageFolder;
     /**
      * @hidden
      * Hide from docs
      * ------
+     *
      * Deletes a cloud storage folder from channel
      *
      * @param channelId - ID of the channel where folder is to be deleted
      * @param folderToDelete - cloud storage folder to be deleted
+     * @param callback - Callback that will be triggered post delete
      */
-    function deleteCloudStorageFolder(channelId, folderToDelete) {
-        return new Promise(function (resolve) {
-            ensureInitialized(FrameContexts.content);
-            if (!isSupported()) {
-                throw errorNotSupportedOnPlatform;
-            }
-            if (!channelId) {
-                throw new Error('[files.deleteCloudStorageFolder] channelId name cannot be null or empty');
-            }
-            if (!folderToDelete) {
-                throw new Error('[files.deleteCloudStorageFolder] folderToDelete cannot be null or empty');
-            }
-            resolve(sendAndHandleSdkError('files.deleteCloudStorageFolder', channelId, folderToDelete));
-        });
+    function deleteCloudStorageFolder(channelId, folderToDelete, callback) {
+        ensureInitialized(FrameContexts.content);
+        if (!channelId) {
+            throw new Error('[files.deleteCloudStorageFolder] channelId name cannot be null or empty');
+        }
+        if (!folderToDelete) {
+            throw new Error('[files.deleteCloudStorageFolder] folderToDelete cannot be null or empty');
+        }
+        if (!callback) {
+            throw new Error('[files.deleteCloudStorageFolder] Callback cannot be null');
+        }
+        sendMessageToParent('files.deleteCloudStorageFolder', [channelId, folderToDelete], callback);
     }
     files_1.deleteCloudStorageFolder = deleteCloudStorageFolder;
     /**
      * @hidden
      * Hide from docs
      * ------
+     *
      * Fetches the contents of a Cloud storage folder (CloudStorageFolder) / sub directory
      *
      * @param folder - Cloud storage folder (CloudStorageFolder) / sub directory (CloudStorageFolderItem)
      * @param providerCode - Code of the cloud storage folder provider
+     * @param callback - Callback that will be triggered post contents are loaded
      */
-    function getCloudStorageFolderContents(folder, providerCode) {
-        return new Promise(function (resolve) {
-            ensureInitialized(FrameContexts.content);
-            if (!isSupported()) {
-                throw errorNotSupportedOnPlatform;
-            }
-            if (!folder || !providerCode) {
-                throw new Error('[files.getCloudStorageFolderContents] folder/providerCode name cannot be null or empty');
-            }
-            if ('isSubdirectory' in folder && !folder.isSubdirectory) {
-                throw new Error('[files.getCloudStorageFolderContents] provided folder is not a subDirectory');
-            }
-            resolve(sendAndHandleSdkError('files.getCloudStorageFolderContents', folder, providerCode));
-        });
+    function getCloudStorageFolderContents(folder, providerCode, callback) {
+        ensureInitialized(FrameContexts.content);
+        if (!folder || !providerCode) {
+            throw new Error('[files.getCloudStorageFolderContents] folder/providerCode name cannot be null or empty');
+        }
+        if (!callback) {
+            throw new Error('[files.getCloudStorageFolderContents] Callback cannot be null');
+        }
+        if ('isSubdirectory' in folder && !folder.isSubdirectory) {
+            throw new Error('[files.getCloudStorageFolderContents] provided folder is not a subDirectory');
+        }
+        sendMessageToParent('files.getCloudStorageFolderContents', [folder, providerCode], callback);
     }
     files_1.getCloudStorageFolderContents = getCloudStorageFolderContents;
     /**
      * @hidden
      * Hide from docs
      * ------
+     *
      * Open a cloud storage file in teams
      *
      * @param file - cloud storage file that should be opened
@@ -7031,9 +7163,6 @@ var files;
      */
     function openCloudStorageFile(file, providerCode, fileOpenPreference) {
         ensureInitialized(FrameContexts.content);
-        if (!isSupported()) {
-            throw errorNotSupportedOnPlatform;
-        }
         if (!file || !providerCode) {
             throw new Error('[files.openCloudStorageFile] file/providerCode cannot be null or empty');
         }
@@ -7043,38 +7172,6 @@ var files;
         sendMessageToParent('files.openCloudStorageFile', [file, providerCode, fileOpenPreference]);
     }
     files_1.openCloudStorageFile = openCloudStorageFile;
-    /**
-     * @hidden
-     * Hide from docs.
-     * ------
-     * Opens a client-friendly preview of the specified file.
-     *
-     * @param file - The file to preview.
-     */
-    function openFilePreview(filePreviewParameters) {
-        ensureInitialized(FrameContexts.content);
-        if (!isSupported()) {
-            throw errorNotSupportedOnPlatform;
-        }
-        var params = [
-            filePreviewParameters.entityId,
-            filePreviewParameters.title,
-            filePreviewParameters.description,
-            filePreviewParameters.type,
-            filePreviewParameters.objectUrl,
-            filePreviewParameters.downloadUrl,
-            filePreviewParameters.webPreviewUrl,
-            filePreviewParameters.webEditUrl,
-            filePreviewParameters.baseUrl,
-            filePreviewParameters.editFile,
-            filePreviewParameters.subEntityId,
-            filePreviewParameters.viewerAction,
-            filePreviewParameters.fileOpenPreference,
-            filePreviewParameters.conversationId,
-        ];
-        sendMessageToParent('openFilePreview', params);
-    }
-    files_1.openFilePreview = openFilePreview;
     /**
      * @hidden
      * Allow 1st party apps to call this function to get the external
@@ -7082,15 +7179,13 @@ var files;
      * @param excludeAddedProviders: return a list of support third party
      * cloud storages that hasn't been added yet.
      */
-    function getExternalProviders(excludeAddedProviders) {
+    function getExternalProviders(excludeAddedProviders, callback) {
         if (excludeAddedProviders === void 0) { excludeAddedProviders = false; }
-        return new Promise(function (resolve) {
-            ensureInitialized(FrameContexts.content);
-            if (!isSupported()) {
-                throw errorNotSupportedOnPlatform;
-            }
-            resolve(sendAndHandleSdkError('files.getExternalProviders', excludeAddedProviders));
-        });
+        ensureInitialized(FrameContexts.content);
+        if (!callback) {
+            throw new Error('[files.getExternalProviders] Callback cannot be null');
+        }
+        sendMessageToParent('files.getExternalProviders', [excludeAddedProviders], callback);
     }
     files_1.getExternalProviders = getExternalProviders;
     /**
@@ -7098,42 +7193,41 @@ var files;
      * Allow 1st party apps to call this function to move files
      * among SharePoint and third party cloud storages.
      */
-    function copyMoveFiles(selectedFiles, providerCode, destinationFolder, destinationProviderCode, isMove) {
+    function copyMoveFiles(selectedFiles, providerCode, destinationFolder, destinationProviderCode, isMove, callback) {
         if (isMove === void 0) { isMove = false; }
-        return new Promise(function (resolve) {
-            ensureInitialized(FrameContexts.content);
-            if (!isSupported()) {
-                throw errorNotSupportedOnPlatform;
-            }
-            if (!selectedFiles || selectedFiles.length === 0) {
-                throw new Error('[files.copyMoveFiles] selectedFiles cannot be null or empty');
-            }
-            if (!providerCode) {
-                throw new Error('[files.copyMoveFiles] providerCode cannot be null or empty');
-            }
-            if (!destinationFolder) {
-                throw new Error('[files.copyMoveFiles] destinationFolder cannot be null or empty');
-            }
-            if (!destinationProviderCode) {
-                throw new Error('[files.copyMoveFiles] destinationProviderCode cannot be null or empty');
-            }
-            resolve(sendAndHandleSdkError('files.copyMoveFiles', selectedFiles, providerCode, destinationFolder, destinationProviderCode, isMove));
-        });
+        ensureInitialized(FrameContexts.content);
+        if (!selectedFiles || selectedFiles.length === 0) {
+            throw new Error('[files.copyMoveFiles] selectedFiles cannot be null or empty');
+        }
+        if (!providerCode) {
+            throw new Error('[files.copyMoveFiles] providerCode cannot be null or empty');
+        }
+        if (!destinationFolder) {
+            throw new Error('[files.copyMoveFiles] destinationFolder cannot be null or empty');
+        }
+        if (!destinationProviderCode) {
+            throw new Error('[files.copyMoveFiles] destinationProviderCode cannot be null or empty');
+        }
+        if (!callback) {
+            throw new Error('[files.copyMoveFiles] callback cannot be null');
+        }
+        sendMessageToParent('files.copyMoveFiles', [selectedFiles, providerCode, destinationFolder, destinationProviderCode, isMove], callback);
     }
     files_1.copyMoveFiles = copyMoveFiles;
-    function isSupported() {
-        return runtime.supports.files ? true : false;
-    }
-    files_1.isSupported = isSupported;
+    /**
+     * @hidden
+     * Hide from docs
+     *  ------
+     *
+     * Gets list of downloads for current user
+     * @param callback Callback that will be triggered post downloads load
+     */
     function getFileDownloads(callback) {
         ensureInitialized(FrameContexts.content);
-        if (!isSupported()) {
-            throw errorNotSupportedOnPlatform;
+        if (!callback) {
+            throw new Error('[files.getFileDownloads] Callback cannot be null');
         }
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) { return resolve(sendAndHandleSdkError('files.getFileDownloads', [])); });
-        };
-        return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+        sendMessageToParent('files.getFileDownloads', [], callback);
     }
     files_1.getFileDownloads = getFileDownloads;
     /**
@@ -7141,15 +7235,12 @@ var files;
      * Hide from docs
      *
      * Open download preference folder if fileObjectId value is undefined else open folder containing the file with id fileObjectId
-     * @param fileObjectId Id of the file whose containing folder should be opened
+     * @param fileObjectId - Id of the file whose containing folder should be opened
      * @param callback Callback that will be triggered post open download folder/path
      */
     function openDownloadFolder(fileObjectId, callback) {
         if (fileObjectId === void 0) { fileObjectId = undefined; }
         ensureInitialized(FrameContexts.content);
-        if (!isSupported()) {
-            throw errorNotSupportedOnPlatform;
-        }
         if (!callback) {
             throw new Error('[files.openDownloadFolder] Callback cannot be null');
         }