@microsoft/teams-js 2.30.0 → 2.31.0-beta.0

package/dist/esm/packages/teams-js/dts/public/profile.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Namespace for profile related APIs.
+ *
+ * @beta
+ */
+export declare namespace profile {
+    /**
+     * Opens a profile card at a specified position to show profile information about a persona.
+     * @param showProfileRequest The parameters to position the card and identify the target user.
+     * @returns Promise that will be fulfilled when the operation has completed
+     *
+     * @beta
+     */
+    function showProfile(showProfileRequest: ShowProfileRequest): Promise<void>;
+    /**
+     * The type of modalities that are supported when showing a profile.
+     * Can be provided as an optional hint with the request and will be
+     * respected if the hosting M365 application supports it.
+     *
+     * @beta
+     */
+    type Modality = 'Card' | 'Expanded';
+    /**
+     * The type of the profile trigger.
+     *  - MouseHover: The user hovered a target.
+     *  - Press: The target was pressed with either a mouse click or keyboard key press.
+     *  - AppRequest: The show profile request is happening programmatically, without direct user interaction.
+     *
+     * @beta
+     */
+    type TriggerType = 'MouseHover' | 'Press' | 'AppRequest';
+    /**
+     * The set of identifiers that are supported for resolving the persona.
+     *
+     * At least one is required, and if multiple are provided then only the highest
+     * priority one will be used (AadObjectId > Upn > Smtp). AAD is now known as "Microsoft Entra ID"
+     *
+     * @beta
+     */
+    type PersonaIdentifiers = {
+        /**
+         * The object id in Microsoft Entra.
+         *
+         * This id is guaranteed to be unique for an object within a tenant,
+         * and so if provided will lead to a more performant lookup. It can
+         * be resolved via MS Graph (see https://learn.microsoft.com/graph/api/resources/users
+         * for examples).
+         */
+        readonly AadObjectId?: string;
+        /**
+         * The primary SMTP address.
+         */
+        readonly Smtp?: string;
+        /**
+         * The user principle name.
+         */
+        readonly Upn?: string;
+    };
+    /**
+     * The persona to show the profile for.
+     *
+     * @beta
+     */
+    interface Persona {
+        /**
+         * The set of identifiers that are supported for resolving the persona.
+         */
+        identifiers: PersonaIdentifiers;
+        /**
+         * Optional display name override. If not specified the user's display name will be resolved normally.
+         */
+        displayName?: string;
+    }
+    /**
+     * Input parameters provided to the showProfile API.
+     *
+     * @beta
+     */
+    interface ShowProfileRequest {
+        /**
+         * An optional hint to the hosting M365 application about which modality of the profile you want to show.
+         */
+        modality?: Modality;
+        /**
+         * The information about the persona to show the profile for.
+         */
+        persona: Persona;
+        /**
+         * The bounding rectangle of the target.
+         */
+        targetElementBoundingRect: DOMRect;
+        /**
+         * Specifies which user interaction was used to trigger the API call.
+         */
+        triggerType: TriggerType;
+    }
+    /**
+     * Checks if the profile capability is supported by the host
+     * @returns boolean to represent whether the profile capability is supported
+     *
+     * @throws Error if {@linkcode app.initialize} has not successfully completed
+     *
+     * @beta
+     */
+    function isSupported(): boolean;
+}
+/**
+ * Internal representation of a DOMRect suitable for sending via postMessage.
+ */
+export type Rectangle = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * @beta
+ * @hidden
+ * An internal representation of the showProfile parameters suitable for sending via postMessage.
+ * The hub expects to receive an object of this type.
+ */
+export interface ShowProfileRequestInternal {
+    modality?: profile.Modality;
+    persona: profile.Persona;
+    targetRectangle: Rectangle;
+    triggerType: profile.TriggerType;
+}

package/dist/esm/packages/teams-js/dts/public/publicAPIs.d.ts

@@ -0,0 +1,218 @@
+import { Context, DeepLinkParameters, FrameContext, LoadContext, TabInformation, TabInstanceParameters } from './interfaces';
+/** Type of callback used to indicate when {@link executeDeepLink} completes */
+export type executeDeepLinkOnCompleteFunctionType = (status: boolean, reason?: string) => void;
+/** Callback function type */
+export type callbackFunctionType = () => void;
+/** Get context callback function type */
+export type getContextCallbackFunctionType = (context: Context) => void;
+/** Get tab instances callback function type */
+export type getTabInstancesCallbackFunctionType = (tabInfo: TabInformation) => void;
+/** Register back button handler function type */
+export type registerBackButtonHandlerFunctionType = () => boolean;
+/** Register full screen handler function type */
+export type registerFullScreenHandlerFunctionType = (isFullScreen: boolean) => void;
+/** Register on theme change handler function type */
+export type registerOnThemeChangeHandlerFunctionType = (theme: string) => void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link app.initialize app.initialize(validMessageOrigins?: string[]): Promise\<void\>} instead.
+ *
+ * Initializes the library. This must be called before any other SDK calls
+ * but after the frame is loaded successfully.
+ * @param callback - Optionally specify a callback to invoke when Teams SDK has successfully initialized
+ * @param validMessageOrigins - Optionally specify a list of cross-frame message origins. This parameter is used if you know that your app
+ * will be hosted on a custom domain (i.e., not a standard Microsoft 365 host like Teams, Outlook, etc.) Most apps will never need
+ * to pass a value for this parameter.
+ * Any domains passed in the array must have the https: protocol on the string otherwise they will be ignored. Example: https://www.example.com
+ */
+export declare function initialize(callback?: callbackFunctionType, validMessageOrigins?: string[]): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link teamsCore.enablePrintCapability teamsCore.enablePrintCapability(): void} instead.
+ *
+ * Enable print capability to support printing page using Ctrl+P and cmd+P
+ */
+export declare function enablePrintCapability(): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link teamsCore.print teamsCore.print(): void} instead.
+ *
+ * Default print handler
+ */
+export declare function print(): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link app.getContext app.getContext(): Promise\<app.Context\>} instead.
+ *
+ * Retrieves the current context the frame is running in.
+ *
+ * @param callback - The callback to invoke when the {@link Context} object is retrieved.
+ */
+export declare function getContext(callback: getContextCallbackFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link app.registerOnThemeChangeHandler app.registerOnThemeChangeHandler(handler: registerOnThemeChangeHandlerFunctionType): void} instead.
+ *
+ * Registers a handler for theme changes.
+ * Only one handler can be registered at a time. A subsequent registration replaces an existing registration.
+ *
+ * @param handler - The handler to invoke when the user changes their theme.
+ */
+export declare function registerOnThemeChangeHandler(handler: registerOnThemeChangeHandlerFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.registerFullScreenHandler pages.registerFullScreenHandler(handler: registerFullScreenHandlerFunctionType): void} instead.
+ *
+ * Registers a handler for changes from or to full-screen view for a tab.
+ * Only one handler can be registered at a time. A subsequent registration replaces an existing registration.
+ *
+ * @param handler - The handler to invoke when the user toggles full-screen view for a tab.
+ */
+export declare function registerFullScreenHandler(handler: registerFullScreenHandlerFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.appButton.onClick pages.appButton.onClick(handler: callbackFunctionType): void} instead.
+ *
+ * Registers a handler for clicking the app button.
+ * Only one handler can be registered at a time. A subsequent registration replaces an existing registration.
+ *
+ * @param handler - The handler to invoke when the personal app button is clicked in the app bar.
+ */
+export declare function registerAppButtonClickHandler(handler: callbackFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.appButton.onHoverEnter pages.appButton.onHoverEnter(handler: callbackFunctionType): void} instead.
+ *
+ * Registers a handler for entering hover of the app button.
+ * Only one handler can be registered at a time. A subsequent registration replaces an existing registration.
+ *
+ * @param handler - The handler to invoke when entering hover of the personal app button in the app bar.
+ */
+export declare function registerAppButtonHoverEnterHandler(handler: callbackFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.appButton.onHoverLeave pages.appButton.onHoverLeave(handler: callbackFunctionType): void} instead.
+ *
+ * Registers a handler for exiting hover of the app button.
+ * Only one handler can be registered at a time. A subsequent registration replaces an existing registration.
+ * @param handler - The handler to invoke when exiting hover of the personal app button in the app bar.
+ *
+ */
+export declare function registerAppButtonHoverLeaveHandler(handler: callbackFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.backStack.registerBackButtonHandler pages.backStack.registerBackButtonHandler(handler: registerBackButtonHandlerFunctionType): void} instead.
+ *
+ * Registers a handler for user presses of the Team client's back button. Experiences that maintain an internal
+ * navigation stack should use this handler to navigate the user back within their frame. If an app finds
+ * that after running its back button handler it cannot handle the event it should call the navigateBack
+ * method to ask the Teams client to handle it instead.
+ *
+ * @param handler - The handler to invoke when the user presses their Team client's back button.
+ */
+export declare function registerBackButtonHandler(handler: registerBackButtonHandlerFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link teamsCore.registerOnLoadHandler teamsCore.registerOnLoadHandler(handler: (context: LoadContext) => void): void} instead.
+ *
+ * @hidden
+ * Registers a handler to be called when the page has been requested to load.
+ *
+ * @param handler - The handler to invoke when the page is loaded.
+ */
+export declare function registerOnLoadHandler(handler: (context: LoadContext) => void): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link teamsCore.registerBeforeUnloadHandler teamsCore.registerBeforeUnloadHandler(handler: (readyToUnload: callbackFunctionType) => boolean): void} instead.
+ *
+ * @hidden
+ * Registers a handler to be called before the page is unloaded.
+ *
+ * @param handler - The handler to invoke before the page is unloaded. If this handler returns true the page should
+ * invoke the readyToUnload function provided to it once it's ready to be unloaded.
+ */
+export declare function registerBeforeUnloadHandler(handler: (readyToUnload: callbackFunctionType) => boolean): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.registerFocusEnterHandler pages.registerFocusEnterHandler(handler: (navigateForward: boolean) => void): void} instead.
+ *
+ * @hidden
+ * Registers a handler when focus needs to be passed from teams to the place of choice on app.
+ *
+ * @param handler - The handler to invoked by the app when they want the focus to be in the place of their choice.
+ */
+export declare function registerFocusEnterHandler(handler: (navigateForward: boolean) => boolean): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.config.registerChangeConfigHandler pages.config.registerChangeConfigHandler(handler: callbackFunctionType): void} instead.
+ *
+ * Registers a handler for when the user reconfigurated tab.
+ *
+ * @param handler - The handler to invoke when the user click on Settings.
+ */
+export declare function registerChangeSettingsHandler(handler: callbackFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.tabs.getTabInstances pages.tabs.getTabInstances(tabInstanceParameters?: TabInstanceParameters): Promise\<TabInformation\>} instead.
+ *
+ * Allows an app to retrieve for this user tabs that are owned by this app.
+ * If no TabInstanceParameters are passed, the app defaults to favorite teams and favorite channels.
+ *
+ * @param callback - The callback to invoke when the {@link TabInstanceParameters} object is retrieved.
+ * @param tabInstanceParameters - OPTIONAL Flags that specify whether to scope call to favorite teams or channels.
+ */
+export declare function getTabInstances(callback: getTabInstancesCallbackFunctionType, tabInstanceParameters?: TabInstanceParameters): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.tabs.getMruTabInstances pages.tabs.getMruTabInstances(tabInstanceParameters?: TabInstanceParameters): Promise\<TabInformation\>} instead.
+ *
+ * Allows an app to retrieve the most recently used tabs for this user.
+ *
+ * @param callback - The callback to invoke when the {@link TabInformation} object is retrieved.
+ * @param tabInstanceParameters - OPTIONAL Ignored, kept for future use
+ */
+export declare function getMruTabInstances(callback: getTabInstancesCallbackFunctionType, tabInstanceParameters?: TabInstanceParameters): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.shareDeepLink pages.shareDeepLink(deepLinkParameters: DeepLinkParameters): void} instead.
+ *
+ * Shares a deep link that a user can use to navigate back to a specific state in this page.
+ *
+ * @param deepLinkParameters - ID and label for the link and fallback URL.
+ */
+export declare function shareDeepLink(deepLinkParameters: DeepLinkParameters): void;
+/**
+ * @deprecated
+ * This function was previously used for opening various types of links. As of TeamsJS v2.0.0, it has been replaced with multiple different
+ * functions depending on the type of link:
+ *
+ * - Use {@link pages.currentApp.navigateToDefaultPage} to navigate to the default page of your own app
+ * - Use {@link pages.currentApp.navigateTo} to navigate to a section of your own app
+ * - Use {@link pages.navigateToApp} to navigate to other apps besides your own
+ * - Use {@link app.openLink} for opening deep links to other parts of the host (e.g., to chats or channels) or
+ * general-purpose links (e.g., to external websites).
+ *
+ * @param deepLink deep link.
+ */
+export declare function executeDeepLink(deepLink: string, onComplete?: executeDeepLinkOnCompleteFunctionType): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.setCurrentFrame pages.setCurrentFrame(frameInfo: FrameInfo): void} instead.
+ *
+ * Set the current Frame Context
+ *
+ * @param frameContext - FrameContext information to be set
+ */
+export declare function setFrameContext(frameContext: FrameContext): void;
+/**
+ * @deprecated
+ * As of TeamsJS v2.0.0, please use {@link pages.initializeWithFrameContext pages.initializeWithFrameContext(frameInfo: FrameInfo, callback?: callbackFunctionType, validMessageOrigins?: string[],): void} instead.
+ *
+ * Initialize with FrameContext
+ *
+ * @param frameContext - FrameContext information to be set
+ * @param callback - The optional callback to be invoked be invoked after initilizing the frame context
+ * @param validMessageOrigins -  Optionally specify a list of cross frame message origins.
+ * They must have https: protocol otherwise they will be ignored. Example: https:www.example.com
+ */
+export declare function initializeWithFrameContext(frameContext: FrameContext, callback?: callbackFunctionType, validMessageOrigins?: string[]): void;

package/dist/esm/packages/teams-js/dts/public/runtime.d.ts

@@ -0,0 +1,207 @@
+import { HostClientType } from './constants';
+import { HostVersionsInfo } from './interfaces';
+export interface IBaseRuntime {
+    readonly apiVersion: number;
+    readonly hostVersionsInfo?: HostVersionsInfo;
+    readonly isLegacyTeams?: boolean;
+    readonly supports?: {};
+}
+/**
+ * Latest runtime interface version
+ */
+export type Runtime = IRuntimeV4;
+export declare const latestRuntimeApiVersion = 4;
+interface IRuntimeV4 extends IBaseRuntime {
+    readonly apiVersion: 4;
+    readonly hostVersionsInfo?: HostVersionsInfo;
+    readonly isNAAChannelRecommended?: boolean;
+    readonly isLegacyTeams?: boolean;
+    readonly supports: {
+        readonly appEntity?: {};
+        readonly appInstallDialog?: {};
+        readonly barCode?: {};
+        readonly calendar?: {};
+        readonly call?: {};
+        readonly chat?: {};
+        readonly clipboard?: {};
+        readonly conversations?: {};
+        readonly copilot?: {
+            readonly eligibility?: {};
+        };
+        readonly dialog?: {
+            readonly card?: {
+                readonly bot?: {};
+            };
+            readonly url?: {
+                readonly bot?: {};
+                readonly parentCommunication?: {};
+            };
+            readonly update?: {};
+        };
+        readonly externalAppAuthentication?: {};
+        readonly externalAppAuthenticationForCEA?: {};
+        readonly externalAppCardActions?: {};
+        readonly externalAppCardActionsForCEA?: {};
+        readonly externalAppCommands?: {};
+        readonly geoLocation?: {
+            readonly map?: {};
+        };
+        readonly hostEntity?: {
+            readonly tab?: {};
+        };
+        readonly interactive?: {};
+        readonly secondaryBrowser?: {};
+        readonly location?: {};
+        readonly logs?: {};
+        readonly mail?: {};
+        readonly marketplace?: {};
+        readonly meetingRoom?: {};
+        readonly menus?: {};
+        readonly messageChannels?: {
+            readonly telemetry?: {};
+            readonly dataLayer?: {};
+        };
+        readonly monetization?: {};
+        readonly nestedAppAuth?: {};
+        readonly notifications?: {};
+        readonly otherAppStateChange?: {};
+        readonly pages?: {
+            readonly appButton?: {};
+            readonly backStack?: {};
+            readonly config?: {};
+            readonly currentApp?: {};
+            readonly fullTrust?: {};
+            readonly tabs?: {};
+        };
+        readonly people?: {};
+        readonly permissions?: {};
+        readonly profile?: {};
+        readonly remoteCamera?: {};
+        readonly search?: {};
+        readonly sharing?: {
+            readonly history?: {};
+        };
+        readonly stageView?: {
+            readonly self?: {};
+        };
+        readonly teams?: {
+            readonly fullTrust?: {
+                readonly joinedTeams?: {};
+            };
+        };
+        readonly thirdPartyCloudStorage?: {};
+        readonly teamsCore?: {};
+        readonly video?: {
+            readonly mediaStream?: {};
+            readonly sharedFrame?: {};
+        };
+        readonly visualMedia?: {
+            readonly image?: {};
+        };
+        readonly webStorage?: {};
+    };
+}
+interface UninitializedRuntime extends IBaseRuntime {
+    readonly apiVersion: -1;
+    readonly supports: {};
+}
+/**
+ * @hidden
+ * Ensures that the runtime has been initialized
+
+ * @returns True if the runtime has been initialized
+ * @throws Error if the runtime has not been initialized
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function isRuntimeInitialized(runtime: IBaseRuntime): runtime is Runtime;
+export declare let runtime: 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.
+ */
+export declare const versionAndPlatformAgnosticTeamsRuntimeConfig: Runtime;
+export interface ICapabilityReqs {
+    readonly capability: object;
+    readonly hostClientTypes: Array<string>;
+}
+export declare const v1MobileHostClientTypes: HostClientType[];
+export declare const v1HostClientTypes: HostClientType[];
+/**
+ * @hidden
+ * `upgradeToNextVersion` transforms runtime of version `versionToUpgradeFrom` to the next higher version
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+interface IRuntimeUpgrade {
+    versionToUpgradeFrom: number;
+    upgradeToNextVersion: (previousVersionRuntime: IBaseRuntime) => IBaseRuntime;
+}
+/**
+ * @hidden
+ * Uses upgradeChain to transform an outdated runtime object to the latest format.
+ * @param outdatedRuntime - The runtime object to be upgraded
+ * @returns The upgraded runtime object
+ * @throws Error if the runtime object could not be upgraded to the latest version
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function fastForwardRuntime(outdatedRuntime: IBaseRuntime): Runtime;
+/**
+ * @hidden
+ * List of transformations required to upgrade a runtime object from a previous version to the next higher version.
+ * This list must be ordered from lowest version to highest version
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare const upgradeChain: IRuntimeUpgrade[];
+/**
+ * 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.
+ */
+export declare const mapTeamsVersionToSupportedCapabilities: Record<string, Array<ICapabilityReqs>>;
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ *
+ * Generates and returns a runtime configuration for host clients which are not on the latest host SDK version
+ * and do not provide their own runtime config (this is just older versions of Teams on some platforms).
+ * Their supported capabilities are based on the highest client SDK version that they can support.
+ *
+ * @param highestSupportedVersion - The highest client SDK version that the host client can support.
+ * @returns runtime which describes the APIs supported by the legacy host client.
+ */
+export declare function generateVersionBasedTeamsRuntimeConfig(highestSupportedVersion: string, versionAgnosticRuntimeConfig: Runtime, mapVersionToSupportedCapabilities: Record<string, Array<ICapabilityReqs>>): Runtime;
+export declare function applyRuntimeConfig(runtimeConfig: IBaseRuntime): void;
+export declare function setUnitializedRuntime(): void;
+/**
+ * @hidden
+ * Constant used to set minimum runtime configuration
+ * while un-initializing an app in unit test case.
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare const _minRuntimeConfigToUninitialize: Runtime;
+export {};

package/dist/esm/packages/teams-js/dts/public/search.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Allows your application to interact with the host M365 application's search box.
+ * By integrating your application with the host's search box, users can search
+ * your app using the same search box they use elsewhere in Teams, Outlook, or Office.
+ *
+ * This functionality is in Beta.
+ * @beta
+ */
+export declare namespace search {
+    /**
+     * This interface contains information pertaining to the contents of the host M365 application's search box
+     *
+     * @beta
+     */
+    interface SearchQuery {
+        /** The current search term in the host search experience */
+        searchTerm: string;
+        /** Timestamp sequence value to ensure messages are processed in correct order / combine them. */
+        timestamp: number;
+    }
+    /**
+     * This type will store the SearchQuery and allow other logic to be made inside the handler.
+     *
+     * @beta
+     */
+    type SearchQueryHandler = (query: SearchQuery) => void;
+    /**
+     * Allows the caller to register for various events fired by the host search experience.
+     * Calling this function indicates that your application intends to plug into the host's search box and handle search events,
+     * when the user is actively using your page/tab.
+     *
+     * The host may visually update its search box, e.g. with the name or icon of your application.
+     *
+     * Your application should *not* re-render inside of these callbacks, there may be a large number
+     * of onChangeHandler calls if the user is typing rapidly in the search box.
+     *
+     * @param onClosedHandler - This handler will be called when the user exits or cancels their search.
+     * Should be used to return your application to its most recent, non-search state. The value of {@link SearchQuery.searchTerm}
+     * will be whatever the last query was before ending search.
+     *
+     * @param onExecuteHandler - The handler will be called when the user executes their
+     * search (by pressing Enter for example). Should be used to display the full list of search results.
+     * The value of {@link SearchQuery.searchTerm} is the complete query the user entered in the search box.
+     *
+     * @param onChangeHandler - This optional handler will be called when the user first starts using the
+     * host's search box and as the user types their query. Can be used to put your application into a
+     * word-wheeling state or to display suggestions as the user is typing.
+     *
+     * This handler will be called with an empty {@link SearchQuery.searchTerm} when search is beginning, and subsequently,
+     * with the current contents of the search box.
+     * @example
+     * ``` ts
+     * search.registerHandlers(
+        query => {
+          console.log('Update your application to handle the search experience being closed. Last query: ${query.searchTerm}');
+        },
+        query => {
+          console.log(`Update your application to handle an executed search result: ${query.searchTerm}`);
+        },
+        query => {
+          console.log(`Update your application with the changed search query: ${query.searchTerm}`);
+        },
+       );
+     * ```
+     *
+     * @beta
+     */
+    function registerHandlers(onClosedHandler: SearchQueryHandler, onExecuteHandler: SearchQueryHandler, onChangeHandler?: SearchQueryHandler): void;
+    /**
+     * Allows the caller to unregister for all events fired by the host search experience. Calling
+     * this function will cause your app to stop appearing in the set of search scopes in the hosts
+     *
+     * @beta
+     */
+    function unregisterHandlers(): void;
+    /**
+     * Checks if search capability is supported by the host
+     * @returns boolean to represent whether the search capability is supported
+     *
+     * @throws Error if {@link app.initialize} has not successfully completed
+     *
+     * @beta
+     */
+    function isSupported(): boolean;
+    /**
+     * Clear the host M365 application's search box
+     *
+     * @beta
+     */
+    function closeSearch(): Promise<void>;
+}

package/dist/esm/packages/teams-js/dts/public/secondaryBrowser.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Namespace to power up the in-app browser experiences in the host app.
+ * For e.g., opening a URL in the host app inside a browser
+ *
+ * @beta
+ */
+export declare namespace secondaryBrowser {
+    /**
+     * Open a URL in the secondary browser.
+     *
+     * On mobile, this is the in-app browser.
+     *
+     * On web and desktop, please use the `window.open()` method or other native external browser methods.
+     *
+     * @param url Url to open in the browser
+     * @returns Promise that successfully resolves if the URL  opens in the secondaryBrowser
+     * or throws an error {@link SdkError} incase of failure before starting navigation
+     *
+     * @remarks Any error that happens after navigation begins is handled by the platform browser component and not returned from this function.
+     * @beta
+     */
+    function open(url: URL): Promise<void>;
+    /**
+     * Checks if secondaryBrowser capability is supported by the host
+     * @returns boolean to represent whether secondaryBrowser is supported
+     *
+     * @throws Error if {@linkcode app.initialize} has not successfully completed
+     *
+     * @beta
+     */
+    function isSupported(): boolean;
+}