@microsoft/teams-js 2.26.0 → 2.27.0

package/dist/MicrosoftTeams.js

@@ -991,6 +991,7 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   ActionObjectType: () => (/* reexport */ ActionObjectType),
+  AppId: () => (/* reexport */ AppId),
   ChannelType: () => (/* reexport */ ChannelType),
   ChildAppWindow: () => (/* reexport */ ChildAppWindow),
   DialogDimension: () => (/* reexport */ DialogDimension),
@@ -1019,6 +1020,7 @@ __webpack_require__.d(__webpack_exports__, {
   chat: () => (/* reexport */ chat),
   clipboard: () => (/* reexport */ clipboard),
   conversations: () => (/* reexport */ conversations),
+  copilot: () => (/* reexport */ copilot),
   dialog: () => (/* reexport */ dialog),
   enablePrintCapability: () => (/* reexport */ enablePrintCapability),
   executeDeepLink: () => (/* reexport */ executeDeepLink),
@@ -1031,6 +1033,7 @@ __webpack_require__.d(__webpack_exports__, {
   getContext: () => (/* reexport */ getContext),
   getMruTabInstances: () => (/* reexport */ getMruTabInstances),
   getTabInstances: () => (/* reexport */ getTabInstances),
+  hostEntity: () => (/* reexport */ hostEntity),
   initialize: () => (/* reexport */ initialize),
   initializeWithFrameContext: () => (/* reexport */ initializeWithFrameContext),
   liveShare: () => (/* reexport */ liveShare),
@@ -1130,7 +1133,7 @@ function isFollowingApiVersionTagFormat(apiVersionTag) {
 }
 
 ;// CONCATENATED MODULE: ./src/artifactsForCDN/validDomains.json
-const validDomains_namespaceObject = /*#__PURE__*/JSON.parse('{"validOrigins":["teams.microsoft.com","teams.microsoft.us","gov.teams.microsoft.us","dod.teams.microsoft.us","int.teams.microsoft.com","outlook.office.com","outlook-sdf.office.com","outlook.office365.com","outlook-sdf.office365.com","outlook.live.com","outlook-sdf.live.com","teams.live.com","local.teams.live.com","local.teams.live.com:8080","local.teams.office.com","local.teams.office.com:8080","devspaces.skype.com","*.www.office.com","www.office.com","word.office.com","excel.office.com","powerpoint.office.com","www.officeppe.com","*.www.microsoft365.com","www.microsoft365.com","bing.com","edgeservices.bing.com","www.bing.com","www.staging-bing-int.com","*.cloud.microsoft","copilot.microsoft.com","windows.msn.com","fa000000125.resources.office.net","fa000000129.resources.office.net","fa000000124.resources.office.net","fa000000128.resources.office.net","fa000000136.resources.office.net"]}');
+const validDomains_namespaceObject = /*#__PURE__*/JSON.parse('{"validOrigins":["teams.microsoft.com","teams.microsoft.us","gov.teams.microsoft.us","dod.teams.microsoft.us","int.teams.microsoft.com","outlook.office.com","outlook-sdf.office.com","outlook.office365.com","outlook-sdf.office365.com","outlook.live.com","outlook-sdf.live.com","teams.live.com","local.teams.live.com","local.teams.live.com:8080","local.teams.office.com","local.teams.office.com:8080","devspaces.skype.com","*.www.office.com","www.office.com","word.office.com","excel.office.com","powerpoint.office.com","www.officeppe.com","*.www.microsoft365.com","www.microsoft365.com","bing.com","edgeservices.bing.com","www.bing.com","www.staging-bing-int.com","*.cloud.microsoft","*.m365.cloud.microsoft","copilot.microsoft.com","windows.msn.com","fa000000125.resources.office.net","fa000000129.resources.office.net","fa000000124.resources.office.net","fa000000128.resources.office.net","fa000000136.resources.office.net"]}');
 var artifactsForCDN_validDomains_namespaceObject = /*#__PURE__*/__webpack_require__.t(validDomains_namespaceObject, 2);
 ;// CONCATENATED MODULE: ./src/internal/constants.ts
 
@@ -2376,6 +2379,89 @@ var DevicePermission;
     DevicePermission["GeoLocation"] = "geolocation";
     DevicePermission["Media"] = "media";
 })(DevicePermission || (DevicePermission = {}));
+/**
+ * @hidden
+ *
+ * @beta
+ */
+var Cohort;
+(function (Cohort) {
+    Cohort["BCAIS"] = "bcais";
+    Cohort["BCWAF"] = "bcwaf";
+    Cohort["BCWBF"] = "bcwbf";
+})(Cohort || (Cohort = {}));
+/**
+ * @hidden
+ *
+ * @beta
+ */
+var Persona;
+(function (Persona) {
+    /**
+     * User has a faculty license
+     */
+    Persona["Faculty"] = "faculty";
+    /**
+     * User has a student license
+     */
+    Persona["Student"] = "student";
+    /**
+     * When user is not a faculty or student
+     */
+    Persona["Other"] = "other";
+})(Persona || (Persona = {}));
+/**
+ * @hidden
+ *
+ * @beta
+ */
+// https://learn.microsoft.com/en-us/graph/api/resources/user?view=graph-rest-1.0#legalagegroupclassification-values
+var LegalAgeGroupClassification;
+(function (LegalAgeGroupClassification) {
+    /**
+     * The user is considered an adult based on the age-related regulations of their country or region.
+     */
+    LegalAgeGroupClassification["Adult"] = "adult";
+    /**
+     * The user is a minor but is from a country or region that has no age-related regulations.
+     */
+    LegalAgeGroupClassification["MinorNoParentalConsentRequired"] = "minorNoParentalConsentRequired";
+    /**
+     * Reserved for future use
+     */
+    LegalAgeGroupClassification["MinorWithoutParentalConsent"] = "minorWithoutParentalConsent";
+    /**
+     * The user is considered a minor based on the age-related regulations of their country or region, and the administrator
+     * of the account obtained appropriate consent from a parent or guardian.
+     */
+    LegalAgeGroupClassification["MinorWithParentalConsent"] = "minorWithParentalConsent";
+    /**
+     * The user is from a country or region that has additional age-related regulations, such as the United States,
+     * United Kingdom, European Union, or South Korea, and the user's age is between a minor and an adult age
+     * (as stipulated based on country or region). Generally, this means that teenagers are considered as notAdult in regulated countries.
+     */
+    LegalAgeGroupClassification["NonAdult"] = "nonAdult";
+})(LegalAgeGroupClassification || (LegalAgeGroupClassification = {}));
+/**
+ * @hidden
+ *
+ * @beta
+ */
+var EduType;
+(function (EduType) {
+    /**
+     * User is from a tenant labeled as “HigherEd”
+     */
+    EduType["HigherEducation"] = "higherEducation";
+    /**
+     * User is from a tenant labeled as “K12”
+     */
+    EduType["K12"] = "k12";
+    /**
+     * User is from a tenant labeled as “Others” (e.g. research institutions)
+     */
+    EduType["Other"] = "other";
+})(EduType || (EduType = {}));
 /**
  * Currently supported Mime type
  */
@@ -3087,6 +3173,26 @@ function isRuntimeInitialized(runtime) {
     }
 }
 let runtime = _uninitializedRuntime;
+/**
+ * This object is used as the default runtime for versions of Teams which don't pass a runtime object during
+ * initialization. If the host DOES pass a runtime object during init, then this object is not used.
+ *
+ * In practice, this is used in Teams V1 and ALL versions of Teams mobile since they are the only hosts
+ * that don't pass a runtime object during initialization (since they don't use the host SDK).
+ *
+ * If there are certain versions of Teams V1 or Teams mobile which support a capability but not ALL
+ * versions, then you should modify the mapTeamsVersionToSupportedCapabilities structure for that purpose. That
+ * structure allows you to specify particular versions on particular platforms that support certain capabilities.
+ * This structure is version agnostic.
+ *
+ * In practice, if you are adding a new capability, you are likely only to need to update mapTeamsVersionToSupportedCapabilities
+ * and NOT this structure, as this structure is effectively only used for capabilities that have existed "forever."
+ *
+ * Remember that everything here all still ONLY applies to versions of Teams that don't pass a runtime object during
+ * initialization -- if they do, then neither this object nor the mapTeamsVersionToSupportedCapabilities structure is
+ * used -- all runtime capabilities are dynamically discovered at runtime in the case where the runtime object is passed
+ * during initialization.
+ */
 const versionAndPlatformAgnosticTeamsRuntimeConfig = {
     apiVersion: 4,
     isNAAChannelRecommended: false,
@@ -3225,6 +3331,11 @@ const upgradeChain = [
         },
     },
 ];
+/**
+ * This structure is used for versions of Teams that don't pass a runtime object during initialization.
+ * Please see the extensive comments in versionAndPlatformAgnosticTeamsRuntimeConfig for more information
+ * on when and how to use this structure.
+ */
 const mapTeamsVersionToSupportedCapabilities = {
     // 1.0.0 just signifies "these capabilities have practically always been supported." For some of these
     // we don't know what the real first version that supported them was -- but it was long enough ago that
@@ -3395,7 +3506,7 @@ const _minRuntimeConfigToUninitialize = {
  * @hidden
  *  Package version.
  */
-const version = "2.26.0";
+const version = "2.27.0";
 
 ;// CONCATENATED MODULE: ./src/internal/internalAPIs.ts
 
@@ -5457,6 +5568,9 @@ function tabsNavigateToTabHelper(apiVersionTag, tabInstance) {
         resolve(sendAndHandleStatusAndReasonWithDefaultError(apiVersionTag, 'navigateToTab', errorMessage, tabInstance));
     });
 }
+/**
+ * @hidden
+ */
 function returnFocusHelper(apiVersionTag, navigateForward) {
     ensureInitialized(runtime);
     if (!pages.isSupported()) {
@@ -5533,14 +5647,77 @@ function configSetConfigHelper(apiVersionTag, instanceConfig) {
 var pages;
 (function (pages) {
     /**
-     * Return focus to the host. Will move focus forward or backward based on where the application container falls in
-     * the F6/tab order in the host.
-     * On mobile hosts or hosts where there is no keyboard interaction or UI notion of "focus" this function has no
-     * effect and will be a no-op when called.
-     * @param navigateForward - Determines the direction to focus in host.
+     * @hidden
+     * List of enter focus action items
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    let EnterFocusType;
+    (function (EnterFocusType) {
+        /**
+         * Determines the previous direction to focus in app when hot keys entered.
+         */
+        EnterFocusType[EnterFocusType["PreviousLandmark"] = 0] = "PreviousLandmark";
+        /**
+         * Determines the next direction to focus in app when hot keys entered.
+         */
+        EnterFocusType[EnterFocusType["NextLandmark"] = 1] = "NextLandmark";
+        /**
+         * Determines if the focus should go to the particular content of the app.
+         * Read - Focus should go to the content of the app.
+         */
+        EnterFocusType[EnterFocusType["Read"] = 2] = "Read";
+        /**
+         * Determines if the focus should go to the particular content of the app.
+         * Compose - Focus should go to the compose area (such as textbox) of the app.
+         */
+        EnterFocusType[EnterFocusType["Compose"] = 3] = "Compose";
+    })(EnterFocusType = pages.EnterFocusType || (pages.EnterFocusType = {}));
+    /**
+     * Return focus action items
      */
-    function returnFocus(navigateForward) {
-        returnFocusHelper(getApiVersionTag(pagesTelemetryVersionNumber, "pages.returnFocus" /* ApiName.Pages_ReturnFocus */), navigateForward);
+    let ReturnFocusType;
+    (function (ReturnFocusType) {
+        /**
+         * Determines the direction to focus in host for previous landmark.
+         */
+        ReturnFocusType[ReturnFocusType["PreviousLandmark"] = 0] = "PreviousLandmark";
+        /**
+         * Determines the direction to focus in host for next landmark.
+         */
+        ReturnFocusType[ReturnFocusType["NextLandmark"] = 1] = "NextLandmark";
+        /**
+         * Determines if the focus should go to the host's activity feed
+         */
+        ReturnFocusType[ReturnFocusType["GoToActivityFeed"] = 2] = "GoToActivityFeed";
+    })(ReturnFocusType = pages.ReturnFocusType || (pages.ReturnFocusType = {}));
+    /**
+     * @hidden
+     */
+    function returnFocus(arg1) {
+        const apiVersionTag = getApiVersionTag(pagesTelemetryVersionNumber, "pages.returnFocus" /* ApiName.Pages_ReturnFocus */);
+        ensureInitialized(runtime);
+        if (!pages.isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        if (arg1 === undefined) {
+            sendMessageToParent(apiVersionTag, 'returnFocus', [false]);
+        }
+        if (typeof arg1 === 'boolean') {
+            sendMessageToParent(apiVersionTag, 'returnFocus', [arg1]);
+        }
+        else {
+            switch (arg1) {
+                case pages.ReturnFocusType.PreviousLandmark:
+                case pages.ReturnFocusType.GoToActivityFeed:
+                    sendMessageToParent(apiVersionTag, 'returnFocus', [false, arg1]);
+                    break;
+                case pages.ReturnFocusType.NextLandmark:
+                    sendMessageToParent(apiVersionTag, 'returnFocus', [true, arg1]);
+                    break;
+            }
+        }
     }
     pages.returnFocus = returnFocus;
     /**
@@ -7818,6 +7995,62 @@ var conversations;
     conversations.isSupported = isSupported;
 })(conversations || (conversations = {}));
 
+;// CONCATENATED MODULE: ./src/private/copilot.ts
+
+
+
+/**
+ * @beta
+ * @hidden
+ * Namespace to delegate copilot app specific APIs
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+var copilot;
+(function (copilot) {
+    /**
+     * @beta
+     * @hidden
+     * User information required by specific apps
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    let eligibility;
+    (function (eligibility) {
+        /**
+         * @hidden
+         * @internal
+         * Limited to Microsoft-internal use
+         * @beta
+         * @returns boolean to represent whether copilot.eligibility capability is supported
+         *
+         * @throws Error if {@linkcode app.initialize} has not successfully completed
+         */
+        function isSupported() {
+            var _a;
+            return ensureInitialized(runtime) && !!((_a = runtime.hostVersionsInfo) === null || _a === void 0 ? void 0 : _a.appEligibilityInformation);
+        }
+        eligibility.isSupported = isSupported;
+        /**
+         * @hidden
+         * @internal
+         * Limited to Microsoft-internal use
+         * @beta
+         * @returns the copilot eligibility information about the user
+         *
+         * @throws Error if {@linkcode app.initialize} has not successfully completed
+         */
+        function getEligibilityInfo() {
+            ensureInitialized(runtime);
+            if (!isSupported()) {
+                throw errorNotSupportedOnPlatform;
+            }
+            return runtime.hostVersionsInfo.appEligibilityInformation;
+        }
+        eligibility.getEligibilityInfo = getEligibilityInfo;
+    })(eligibility = copilot.eligibility || (copilot.eligibility = {}));
+})(copilot || (copilot = {}));
+
 ;// CONCATENATED MODULE: ./src/private/externalAppAuthentication.ts
 
 
@@ -10795,23 +11028,75 @@ var videoEffectsEx;
     videoEffectsEx.notifyFatalError = notifyFatalError;
 })(videoEffectsEx || (videoEffectsEx = {}));
 
-;// CONCATENATED MODULE: ./src/private/index.ts
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+;// CONCATENATED MODULE: ./src/internal/appIdValidation.ts
+/**
+ * This function can be used to validate if a string is a "valid" app id.
+ * Valid is a relative term, in this case. Truly valid app ids are UUIDs as documented in the schema:
+ * https://learn.microsoft.com/en-us/microsoftteams/platform/resources/schema/manifest-schema#id
+ * However, there are some older internal/hard-coded apps which violate this schema and use names like com.microsoft.teamspace.tab.youtube.
+ * For compatibility with these legacy apps, we unfortunately cannot securely and completely validate app ids as UUIDs. Based
+ * on this, the validation is limited to checking for script tags, length, and non-printable characters.
+ *
+ * @param potentialAppId A string to check if it's a "valid" app id
+ * @throws Error with a message describing the exact validation violation
+ */
+function validateStringAsAppId(potentialAppId) {
+    if (doesStringContainScriptTags(potentialAppId)) {
+        throw new Error(`Potential app id (${potentialAppId}) is invalid; it contains script tags.`);
+    }
+    if (!isStringWithinAppIdLengthLimits(potentialAppId)) {
+        throw new Error(`Potential app id (${potentialAppId}) is invalid; its length ${potentialAppId.length} is not within the length limits (${minimumValidAppIdLength}-${maximumValidAppIdLength}).`);
+    }
+    if (doesStringContainNonPrintableCharacters(potentialAppId)) {
+        throw new Error(`Potential app id (${potentialAppId}) is invalid; it contains non-printable characters.`);
+    }
+}
+function doesStringContainScriptTags(str) {
+    const scriptRegex = /<script[^>]*>[\s\S]*?<\/script[^>]*>/gi;
+    return scriptRegex.test(str);
+}
+const minimumValidAppIdLength = 4;
+const maximumValidAppIdLength = 256;
+function isStringWithinAppIdLengthLimits(potentialAppId) {
+    return potentialAppId.length < maximumValidAppIdLength && potentialAppId.length > minimumValidAppIdLength;
+}
+function doesStringContainNonPrintableCharacters(str) {
+    return [...str].some((char) => {
+        const charCode = char.charCodeAt(0);
+        return charCode < 32 || charCode > 126;
+    });
+}
+
+;// CONCATENATED MODULE: ./src/public/appId.ts
 
+/**
+ * A strongly-typed class used to represent a "valid" app id.
+ *
+ * Valid is a relative term, in this case. Truly valid app ids are UUIDs as documented in the schema:
+ * https://learn.microsoft.com/en-us/microsoftteams/platform/resources/schema/manifest-schema#id
+ * However, there are some older internal/hard-coded apps which violate this schema and use names like
+ * com.microsoft.teamspace.tab.youtube. For compatibility with these legacy apps, we unfortunately cannot
+ * securely and completely validate app ids as UUIDs. Based on this, the validation is limited to checking
+ * for script tags, length, and non-printable characters.
+ */
+class AppId {
+    /**
+     * Creates a strongly-typed AppId from a string
+     *
+     * @param appIdAsString An app id represented as a string
+     * @throws Error with a message describing the exact validation violation
+     */
+    constructor(appIdAsString) {
+        this.appIdAsString = appIdAsString;
+        validateStringAsAppId(appIdAsString);
+    }
+    /**
+     * Returns the app id as a string
+     */
+    toString() {
+        return this.appIdAsString;
+    }
+}
 
 ;// CONCATENATED MODULE: ./src/internal/deepLinkConstants.ts
 /**
@@ -14251,6 +14536,8 @@ var webStorage_awaiter = (undefined && undefined.__awaiter) || function (thisArg
 
 
 
+
+
 /**
  * Contains functionality enabling apps to query properties about how the host manages web storage (`Window.LocalStorage`)
  *
@@ -14273,10 +14560,33 @@ var webStorage;
             if (!isSupported()) {
                 throw errorNotSupportedOnPlatform;
             }
+            if (runtime.isLegacyTeams &&
+                (GlobalVars.hostClientType === HostClientType.android ||
+                    GlobalVars.hostClientType === HostClientType.ios ||
+                    GlobalVars.hostClientType === HostClientType.ipados) &&
+                (yield getHostName()) === HostName.teams) {
+                // On Teams Mobile, they haven't yet implemented this capability. However, for compatibility reasons, we need
+                // to act as if they do. If they did implement it, they would return true, so that's what we do here.
+                // Getting Teams Mobile to implement this is a work-in-progress. Once they do implement it, we can remove this
+                // whole if-block. Until then, we cannot send the message to them because they will not understand it.
+                // Once they do implement it, this if-block will automatically not apply because runtime.isLegacyTeams will no
+                // longer be true. So, we don't need to worry about removing this if block "at the right time". We can
+                // just keep it here until Teams Mobile implements this capability and uses the host SDK everywhere, at which
+                // point we can remove this whole if-block at our leisure.
+                return true;
+            }
             return yield sendAndUnwrap(getApiVersionTag("v2" /* ApiVersionNumber.V_2 */, "webStorage.isWebStorageClearedOnUserLogOut" /* ApiName.WebStorage_IsWebStorageClearedOnUserLogOut */), "webStorage.isWebStorageClearedOnUserLogOut" /* ApiName.WebStorage_IsWebStorageClearedOnUserLogOut */);
         });
     }
     webStorage.isWebStorageClearedOnUserLogOut = isWebStorageClearedOnUserLogOut;
+    function getHostName() {
+        return webStorage_awaiter(this, void 0, void 0, function* () {
+            if (cachedHostName === null) {
+                cachedHostName = (yield app.getContext()).app.host.name;
+            }
+            return cachedHostName;
+        });
+    }
     /**
      * Checks if webStorage capability is supported by the host
      * @returns boolean to represent whether the webStorage capability is supported
@@ -14290,6 +14600,12 @@ var webStorage;
     }
     webStorage.isSupported = isSupported;
 })(webStorage || (webStorage = {}));
+// It is safe to cache the host name because the host cannot change at runtime
+let cachedHostName = null;
+// ...except during unit tests, where we will change it at runtime regularly for testing purposes
+function clearWebStorageCachedHostNameForTests() {
+    cachedHostName = null;
+}
 
 ;// CONCATENATED MODULE: ./src/public/call.ts
 
@@ -14477,7 +14793,8 @@ var thirdPartyCloudStorage;
     /**
      * Get drag-and-drop files using a callback.
      *
-     * @param {string} dragAndDropInput - Teams thread id or Teams conversation id from a Teams chat/channel
+     * @param {string} dragAndDropInput - unique id which is a combination of replyToId + threadId of teams chat and channel.
+     *   Both replyToId and threadId can be fetched from application context.
      * @param {DragAndDropFileCallback} dragAndDropFileCallback - callback
      *   A callback function to handle the result of the operation
      * @beta
@@ -15850,6 +16167,289 @@ var marketplace;
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: ./src/private/hostEntity.ts
+
+
+
+
+
+
+/**
+ * v2 APIs telemetry file: All of APIs in this capability file should send out API version v2 ONLY
+ */
+const hostEntityTelemetryVersionNumber = "v2" /* ApiVersionNumber.V_2 */;
+/**
+ * @hidden
+ * @internal
+ * @beta
+ * Limited to Microsoft-internal use
+ *
+ * This capability allows an app to associate apps with a host entity, such as a Teams channel or chat, and configure them as needed.
+ */
+var hostEntity;
+(function (hostEntity) {
+    let AppTypes;
+    (function (AppTypes) {
+        AppTypes["edu"] = "EDU";
+    })(AppTypes = hostEntity.AppTypes || (hostEntity.AppTypes = {}));
+    /**
+     * @hidden
+     * @internal
+     * @beta
+     * Limited to Microsoft-internal use
+     *
+     * CRUD operations for tabs associated with apps
+     */
+    let tab;
+    (function (tab_1) {
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Launches host-owned UI that lets a user select an app, installs it if required,
+         * runs through app configuration if required, and then associates the app with the threadId provided
+         *
+         * @param hostEntityIds Ids of the host entity like channel, chat or meeting
+         *
+         * @param appTypes What type of applications to show the user. If EDU is passed as appType, only apps supported by EDU tenant are shown.
+         * If no value is passed, all apps are shown.
+         *
+         * @returns The HostEntityTabInstance of the newly associated app
+         *
+         * @throws Error if host does not support this capability, library as not been initialized successfully, input parameters are invalid, user cancels operation or installing
+         * or configuring or adding tab fails
+         */
+        function addAndConfigure(hostEntityIds, appTypes) {
+            ensureInitialized(runtime);
+            if (!isSupported()) {
+                throw new Error(`Error code: ${ErrorCode.NOT_SUPPORTED_ON_PLATFORM}, message: Not supported on platform`);
+            }
+            validateThreadId(hostEntityIds.threadId);
+            if (appTypes && appTypes.length === 0) {
+                throw new Error(`Error code: ${ErrorCode.INVALID_ARGUMENTS}, message: App types cannot be an empty array`);
+            }
+            return sendMessageToParentAsync(getApiVersionTag(hostEntityTelemetryVersionNumber, "hostEntity.tab.addAndConfigure" /* ApiName.HostEntity_Tab_addAndConfigureApp */), 'hostEntity.tab.addAndConfigure', [hostEntityIds, appTypes]).then(([response]) => {
+                var _a;
+                if (isSdkError(response)) {
+                    throw new Error(`Error code: ${response.errorCode}, message: ${(_a = response.message) !== null && _a !== void 0 ? _a : 'None'}`);
+                }
+                return response;
+            });
+        }
+        tab_1.addAndConfigure = addAndConfigure;
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Returns all tab instances associated with a host entity
+         *
+         * @param hostEntityIds Ids of the host entity like channel, chat or meeting
+         *
+         * @returns Object with array of HostEntityTabInstance's associated with a host entity
+         *
+         * @throws Error if host does not support this capability, library as not been initialized successfully, input parameters are invalid or fetching tabs fails
+         */
+        function getAll(hostEntityIds) {
+            ensureInitialized(runtime);
+            if (!isSupported()) {
+                throw new Error(`Error code: ${ErrorCode.NOT_SUPPORTED_ON_PLATFORM}, message: Not supported on platform`);
+            }
+            validateThreadId(hostEntityIds.threadId);
+            return sendMessageToParentAsync(getApiVersionTag(hostEntityTelemetryVersionNumber, "hostEntity.tab.getAll" /* ApiName.HostEntity_Tab_getAll */), 'hostEntity.tab.getAll', [hostEntityIds]).then(([response]) => {
+                var _a;
+                if (isSdkError(response)) {
+                    throw new Error(`Error code: ${response.errorCode}, message: ${(_a = response.message) !== null && _a !== void 0 ? _a : 'None'}`);
+                }
+                return response;
+            });
+        }
+        tab_1.getAll = getAll;
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Launches host-owned UI that lets a user re-configure the contentUrl of the tab
+         *
+         * @param tab Configurable tab instance that needs to be updated
+         *
+         * @param hostEntityIds Ids of the host entity like channel, chat or meeting
+         *
+         * @returns The HostEntityTabInstance of the updated tab
+         *
+         * @throws Error if host does not support this capability, library as not been initialized successfully, input parameters are invalid, user cancels operation,
+         * re-configuring tab fails or if tab is a static tab
+         */
+        function reconfigure(tab, hostEntityIds) {
+            ensureInitialized(runtime);
+            if (!isSupported()) {
+                throw new Error(`Error code: ${ErrorCode.NOT_SUPPORTED_ON_PLATFORM}, message: Not supported on platform`);
+            }
+            validateTab(tab);
+            validateThreadId(hostEntityIds.threadId);
+            return sendMessageToParentAsync(getApiVersionTag(hostEntityTelemetryVersionNumber, "hostEntity.tab.reconfigure" /* ApiName.HostEntity_Tab_reconfigure */), 'hostEntity.tab.reconfigure', [tab, hostEntityIds]).then(([response]) => {
+                var _a;
+                if (isSdkError(response)) {
+                    throw new Error(`Error code: ${response.errorCode}, message: ${(_a = response.message) !== null && _a !== void 0 ? _a : 'None'}`);
+                }
+                return response;
+            });
+        }
+        tab_1.reconfigure = reconfigure;
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Launches host-owned UI that lets a user rename the tab
+         *
+         * @param tab Configurable tab instance that needs to be updated
+         *
+         * @param hostEntityIds Ids of the host entity like channel, chat or meeting
+         *
+         * @returns The HostEntityTabInstance of the updated tab
+         *
+         * @throws Error if host does not support this capability, library as not been initialized successfully, input parameters are invalid, user cancels operation,
+         * re-naming tab fails or if tab is a static tab
+         */
+        function rename(tab, hostEntityIds) {
+            ensureInitialized(runtime);
+            if (!isSupported()) {
+                throw new Error(`Error code: ${ErrorCode.NOT_SUPPORTED_ON_PLATFORM}, message: Not supported on platform`);
+            }
+            validateTab(tab);
+            validateThreadId(hostEntityIds.threadId);
+            return sendMessageToParentAsync(getApiVersionTag(hostEntityTelemetryVersionNumber, "hostEntity.tab.rename" /* ApiName.HostEntity_Tab_rename */), 'hostEntity.tab.rename', [tab, hostEntityIds]).then(([response]) => {
+                var _a;
+                if (isSdkError(response)) {
+                    throw new Error(`Error code: ${response.errorCode}, message: ${(_a = response.message) !== null && _a !== void 0 ? _a : 'None'}`);
+                }
+                return response;
+            });
+        }
+        tab_1.rename = rename;
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Launches host-owned UI that lets a user remove the tab
+         *
+         * @param tab tab instance that needs to be updated. Can be static tab or configurable tab.
+         *
+         * @param hostEntityIds Ids of the host entity like channel, chat or meeting
+         *
+         * @returns Boolean. Returns true if removing tab was successful
+         *
+         * @throws Error if host does not support this capability, library as not been initialized successfully, input parameters are invalid, user cancels operation or
+         * removing tab fails
+         */
+        function remove(tab, hostEntityIds) {
+            ensureInitialized(runtime);
+            if (!isSupported()) {
+                throw new Error(`Error code: ${ErrorCode.NOT_SUPPORTED_ON_PLATFORM}, message: Not supported on platform`);
+            }
+            validateThreadId(hostEntityIds.threadId);
+            validateTab(tab);
+            return sendMessageToParentAsync(getApiVersionTag(hostEntityTelemetryVersionNumber, "hostEntity.tab.remove" /* ApiName.HostEntity_Tab_remove */), 'hostEntity.tab.remove', [tab, hostEntityIds]).then(([response]) => {
+                var _a;
+                if (isSdkError(response)) {
+                    throw new Error(`Error code: ${response.errorCode}, message: ${(_a = response.message) !== null && _a !== void 0 ? _a : 'None'}`);
+                }
+                return true;
+            });
+        }
+        tab_1.remove = remove;
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Checks if the hostEntity.tab capability is supported by the host
+         * @returns boolean to represent whether the histEntity and hostEntity.tab capability is supported
+         *
+         * @throws Error if {@linkcode app.initialize} has not successfully completed
+         */
+        function isSupported() {
+            var _a;
+            return ensureInitialized(runtime) && hostEntity.isSupported() && ((_a = runtime.supports.hostEntity) === null || _a === void 0 ? void 0 : _a.tab) ? true : false;
+        }
+        tab_1.isSupported = isSupported;
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Checks if the threadId is defined
+         * @throws Error if threadId is null, undefined or empty
+         */
+        function validateThreadId(threadId) {
+            if (!threadId || threadId.length == 0) {
+                throw new Error(`Error code: ${ErrorCode.INVALID_ARGUMENTS}, message: ThreadId cannot be null or empty`);
+            }
+        }
+        /**
+         * @hidden
+         * @internal
+         * @beta
+         * Limited to Microsoft-internal use
+         *
+         * Checks if the tabId is defined
+         * @throws Error if tabId is null, undefined or empty
+         */
+        function validateTab(tab) {
+            if (!(tab === null || tab === void 0 ? void 0 : tab.internalTabInstanceId) || tab.internalTabInstanceId.length === 0) {
+                throw new Error(`Error code: ${ErrorCode.INVALID_ARGUMENTS}, message: TabId cannot be null or empty`);
+            }
+        }
+    })(tab = hostEntity.tab || (hostEntity.tab = {}));
+    /**
+     * @hidden
+     * @internal
+     * @beta
+     * Limited to Microsoft-internal use
+     *
+     * Checks if the hostEntity capability is supported by the host
+     * @returns boolean to represent whether the hostEntity capability is supported
+     *
+     * @throws Error if {@linkcode app.initialize} has not successfully completed
+     */
+    function isSupported() {
+        return ensureInitialized(runtime) && runtime.supports.hostEntity ? true : false;
+    }
+    hostEntity.isSupported = isSupported;
+})(hostEntity || (hostEntity = {}));
+
+;// CONCATENATED MODULE: ./src/private/index.ts