@jevelin/bridge 2.53.0

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,240 @@
+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 canParentManageNAATrustedOrigins?: boolean;
+    readonly isDeeplyNestedAuthSupported?: boolean;
+    readonly isLegacyTeams?: boolean;
+    readonly supports: {
+        readonly app?: {
+            readonly notifySuccessResponse?: {};
+        };
+        readonly appEntity?: {};
+        readonly appInstallDialog?: {};
+        readonly appPerformanceMetrics?: {};
+        readonly barCode?: {};
+        readonly calendar?: {};
+        readonly call?: {};
+        readonly chat?: {};
+        readonly clipboard?: {};
+        readonly conversations?: {};
+        readonly copilot?: {
+            readonly customTelemetry?: {};
+            readonly eligibility?: {};
+            readonly sidePanel?: {};
+            readonly view?: {};
+        };
+        readonly dialog?: {
+            readonly card?: {
+                readonly bot?: {};
+            };
+            readonly url?: {
+                readonly bot?: {};
+                readonly parentCommunication?: {};
+            };
+            readonly update?: {};
+        };
+        readonly externalAppAuthentication?: {};
+        readonly externalAppAuthenticationForCEA?: {};
+        readonly externalAppCardActions?: {};
+        readonly externalAppCardActionsForCEA?: {};
+        readonly externalAppCardActionsForDA?: {};
+        readonly externalAppCommands?: {};
+        readonly geoLocation?: {
+            readonly map?: {};
+        };
+        readonly hostEntity?: {
+            readonly tab?: {};
+        };
+        readonly interactive?: {};
+        readonly secondaryBrowser?: {};
+        readonly location?: {};
+        readonly logs?: {};
+        readonly mail?: {
+            readonly handoff?: {};
+        };
+        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 plugins?: {};
+        readonly permissions?: {};
+        readonly profile?: {};
+        readonly remoteCamera?: {};
+        readonly search?: {};
+        readonly security?: {};
+        readonly connectivity?: {};
+        readonly haptics?: {};
+        readonly badge?: {};
+        readonly externalApp?: {};
+        readonly sharing?: {
+            readonly history?: {};
+        };
+        readonly shortcutRelay?: {};
+        readonly stageView?: {
+            readonly self?: {};
+        };
+        readonly store?: {};
+        readonly teams?: {
+            readonly fullTrust?: {
+                readonly joinedTeams?: {};
+            };
+        };
+        readonly thirdPartyCloudStorage?: {};
+        readonly teamsCore?: {};
+        readonly video?: {
+            readonly mediaStream?: {};
+            readonly sharedFrame?: {};
+        };
+        readonly visualMedia?: {
+            readonly image?: {};
+        };
+        readonly webStorage?: {};
+        readonly widgetHosting?: {};
+        readonly offlineStorage?: {
+            readonly drafts?: {};
+            readonly inbox?: {};
+            readonly outbox?: {};
+            readonly sent?: {};
+            readonly sync?: {};
+        };
+    };
+}
+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 version is for legacy Teams mobile clients that don’t pass a runtime object during initialization.
+ * It’s the minimum version required to support deeply nested app auth.
+ */
+export declare const legacyTeamsMobileVersionForDeeplyNestedAuth = "2.1.2";
+/**
+ * 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,90 @@
+/**
+ * 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
+ * @module
+ */
+/**
+ * This interface contains information pertaining to the contents of the host M365 application's search box
+ *
+ * @beta
+ */
+export 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
+ */
+export 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
+   */
+export declare 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
+ */
+export declare 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
+ */
+export declare function isSupported(): boolean;
+/**
+ * Clear the host M365 application's search box
+ *
+ * @beta
+ */
+export declare function closeSearch(): Promise<void>;

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

@@ -0,0 +1,31 @@
+/**
+ * Module 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
+ * @module
+ */
+/**
+ * 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
+ */
+export declare 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
+ */
+export declare function isSupported(): boolean;

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

@@ -0,0 +1,83 @@
+/**
+ * Module to interact with the security-specific part of the SDK.
+ *
+ * Provides re-authentication for sensitive actions and biometric availability checks.
+ * The native host handles the biometric/passcode prompt and returns the result.
+ *
+ * @module
+ */
+/**
+ * Parameters for requesting re-authentication.
+ */
+export interface ReauthenticateParameters {
+    /** Reason displayed to the user explaining why authentication is needed. */
+    reason?: string;
+}
+/**
+ * Result returned from a successful re-authentication.
+ */
+export interface ReauthenticateResult {
+    /** Whether the authentication was successful. */
+    success: boolean;
+}
+/**
+ * Information about the device's biometric capabilities.
+ */
+export interface BiometricAvailability {
+    /** Whether biometric authentication is available on the device. */
+    available: boolean;
+    /** The type of biometric available: "faceId", "touchId", "biometric", or "none". */
+    type: string;
+}
+/**
+ * Triggers a native biometric/passcode re-authentication prompt for sensitive operations.
+ *
+ * Use this before performing high-risk actions such as:
+ * - Financial transfers
+ * - Changing security settings
+ * - Viewing sensitive personal data
+ * - Approving important requests
+ *
+ * @param params - Optional parameters including a reason string displayed to the user.
+ * @returns A Promise that resolves with the authentication result if successful.
+ * @throws Error if the user cancels or fails authentication, or if the capability is not supported.
+ *
+ * @example
+ * ```typescript
+ * import { security } from '@anthropic/teams-js';
+ *
+ * try {
+ *   const result = await security.reauthenticate({ reason: 'Confirm transfer of $500' });
+ *   if (result.success) {
+ *     // Proceed with sensitive action
+ *   }
+ * } catch (error) {
+ *   // User cancelled or failed authentication
+ * }
+ * ```
+ */
+export declare function reauthenticate(params?: ReauthenticateParameters): Promise<ReauthenticateResult>;
+/**
+ * Checks whether biometric authentication is available on the current device.
+ *
+ * @returns A Promise that resolves with biometric availability information.
+ * @throws Error if the capability is not supported or app is not initialized.
+ *
+ * @example
+ * ```typescript
+ * import { security } from '@anthropic/teams-js';
+ *
+ * const biometric = await security.isBiometricAvailable();
+ * if (biometric.available) {
+ *   console.log(`Biometric type: ${biometric.type}`); // "faceId", "touchId", etc.
+ * }
+ * ```
+ */
+export declare function isBiometricAvailable(): Promise<BiometricAvailability>;
+/**
+ * Checks if the security capability is supported by the host.
+ *
+ * @returns `true` if the host supports security operations (re-authentication, biometric checks).
+ * @throws Error if {@linkcode app.initialize} has not successfully completed.
+ */
+export declare function isSupported(): boolean;

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

@@ -0,0 +1,17 @@
+/**
+ * Interface for objects that can be serialized and passed to the host
+ */
+export interface ISerializable {
+    /**
+     * @returns A serializable representation of the object, used for passing objects to the host.
+     */
+    serialize(): string | object;
+}
+/**
+ * @hidden
+ * @internal
+ * Used by the communication layer to make sure that an argument being passed to the host is serializable.
+ * @param arg The argument to evaluate
+ * @returns Whether or not the argument is serializable.
+ */
+export declare function isSerializable(arg: unknown): arg is ISerializable;