@jevelin/bridge 2.53.0

package/dist/esm/packages/teams-js/dts/internal/utils.d.ts

@@ -0,0 +1,226 @@
+import { AdaptiveCardVersion, SdkError } from '../public/interfaces';
+import * as pages from '../public/pages/pages';
+import { IBaseRuntime } from '../public/runtime';
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function getGenericOnCompleteHandler(errorMessage?: string): (success: boolean, reason?: string) => void;
+/**
+ * @hidden
+ * Compares SDK versions.
+ *
+ * @param v1 - first version
+ * @param v2 - second version
+ * @returns NaN in case inputs are not in right format
+ *         -1 if v1 < v2
+ *          1 if v1 > v2
+ *          0 otherwise
+ * @example
+ *    compareSDKVersions('1.2', '1.2.0') returns 0
+ *    compareSDKVersions('1.2a', '1.2b') returns NaN
+ *    compareSDKVersions('1.2', '1.3') returns -1
+ *    compareSDKVersions('2.0', '1.3.2') returns 1
+ *    compareSDKVersions('2.0', 2.0) returns NaN
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function compareSDKVersions(v1: string, v2: string): number;
+/**
+ * @hidden
+ * Generates a GUID
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function generateGUID(): string;
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function deepFreeze<T extends object>(obj: T): T;
+/**
+ * @hidden
+ * The following type definitions will be used in the
+ * utility functions below, which help in transforming the
+ * promises to support callbacks for backward compatibility
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export type ErrorResultCallback<T> = (err?: SdkError, result?: T) => void;
+export type ErrorResultNullCallback<T> = (err: SdkError | null, result: T | null) => void;
+export type ErrorBooleanResultCallback = (err?: SdkError, result?: boolean) => void;
+export type InputFunction<T> = (...args: any[]) => Promise<T>;
+export type ResultCallback<T> = (result?: T) => void;
+export type SdkErrorCallback = ResultCallback<SdkError | null>;
+/**
+ * This utility function is used when the result of the promise is same as the result in the callback.
+ * @param funcHelper
+ * @param callback
+ * @param args
+ * @returns
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function callCallbackWithErrorOrResultFromPromiseAndReturnPromise<T>(funcHelper: InputFunction<T>, callback?: ErrorResultCallback<T>, ...args: any[]): Promise<T>;
+/**
+ * This utility function is used when the return type of the promise is usually void and
+ * the result in the callback is a boolean type (true for success and false for error)
+ * @param funcHelper
+ * @param callback
+ * @param args
+ * @returns
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function callCallbackWithErrorOrBooleanFromPromiseAndReturnPromise<T>(funcHelper: InputFunction<T>, callback?: ErrorBooleanResultCallback, ...args: any[]): Promise<T>;
+/**
+ * This utility function is called when the callback has only Error/SdkError as the primary argument.
+ * @param funcHelper
+ * @param callback
+ * @param args
+ * @returns
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function callCallbackWithSdkErrorFromPromiseAndReturnPromise<T>(funcHelper: InputFunction<T>, callback?: SdkErrorCallback, ...args: any[]): Promise<T>;
+/**
+ * This utility function is used when the result of the promise is same as the result in the callback.
+ * @param funcHelper
+ * @param callback
+ * @param args
+ * @returns
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function callCallbackWithErrorOrResultOrNullFromPromiseAndReturnPromise<T>(funcHelper: InputFunction<T>, callback?: ErrorResultNullCallback<T>, ...args: any[]): Promise<T>;
+/**
+ * A helper function to add a timeout to an asynchronous operation.
+ *
+ * @param action Action to wrap the timeout around
+ * @param timeoutInMs Timeout period in milliseconds
+ * @param timeoutError Error to reject the promise with if timeout elapses before the action completed
+ * @returns A promise which resolves to the result of provided action or rejects with a provided timeout error
+ * if the initial action didn't complete within provided timeout.
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function runWithTimeout<TResult, TError>(action: () => Promise<TResult>, timeoutInMs: number, timeoutError: TError): Promise<TResult>;
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function createTeamsAppLink(params: pages.AppNavigationParameters): string;
+/**
+ * @hidden
+ * Checks if the Adaptive Card schema version is supported by the host.
+ * @param hostAdaptiveCardSchemaVersion Host's supported Adaptive Card version in the runtime.
+ *
+ * @returns true if the Adaptive Card Version is not supported and false if it is supported.
+ */
+export declare function isHostAdaptiveCardSchemaVersionUnsupported(hostAdaptiveCardSchemaVersion: AdaptiveCardVersion): boolean;
+/**
+ * @hidden
+ * Checks if a URL is a HTTPS protocol based URL.
+ * @param url URL to be validated.
+ *
+ * @returns true if the URL is an https URL.
+ */
+export declare function isValidHttpsURL(url: URL): boolean;
+/**
+ * Convert base64 string to blob
+ * @param base64Data string respresenting the content
+ * @param contentType Mimetype
+ * @returns Promise
+ */
+export declare function base64ToBlob(mimeType: string, base64String: string): Promise<Blob>;
+/**
+ * Converts blob to base64 string.
+ * @param blob Blob to convert to base64 string.
+ */
+export declare function getBase64StringFromBlob(blob: Blob): Promise<string>;
+/**
+ *  Returns an SSR safe reference to the window object
+ * @returns Window object reference
+ */
+export declare function ssrSafeWindow(): Window;
+/**
+ * Checks if running in a Server Side Environment
+ * @returns True if running in a Server Side Environment
+ */
+export declare function inServerSideRenderingEnvironment(): boolean;
+/**
+ * @param id The id to validate
+ * @param errorToThrow Customized error to throw if the id is not valid
+ *
+ * @throws Error if id is not valid
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function validateId(id: string, errorToThrow?: Error): void;
+export declare function validateUrl(url: URL, errorToThrow?: Error): void;
+/**
+ * This function takes in a string that represents a full or relative path and returns a
+ * fully qualified URL object.
+ *
+ * Currently this is accomplished by assigning the input string to an a tag and then retrieving
+ * the a tag's href value. A side effect of doing this is that the string becomes a fully qualified
+ * URL. This is probably not how I would choose to do this, but in order to not unintentionally
+ * break something I've preseved the functionality here and just isolated the code to make it
+ * easier to mock.
+ *
+ * @example
+ *    `fullyQualifyUrlString('https://example.com')` returns `new URL('https://example.com')`
+ *    `fullyQualifyUrlString('helloWorld')` returns `new URL('https://example.com/helloWorld')`
+ *    `fullyQualifyUrlString('hello%20World')` returns `new URL('https://example.com/hello%20World')`
+ *
+ * @param fullOrRelativePath A string representing a full or relative URL.
+ * @returns A fully qualified URL representing the input string.
+ */
+export declare function fullyQualifyUrlString(fullOrRelativePath: string): URL;
+/**
+ * Detects if there are any script tags in a given string, even if they are Uri encoded or encoded as HTML entities.
+ * @param input string to test for script tags
+ * @returns true if the input string contains a script tag, false otherwise
+ */
+export declare function hasScriptTags(input: string): boolean;
+/**
+ * @param id The ID to validate against the UUID format
+ * @throws Error if ID is not a valid UUID
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function validateUuid(id: string | undefined | null): void;
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ * @returns current timestamp in milliseconds
+ */
+export declare function getCurrentTimestamp(): number | undefined;
+/**
+ * @hidden
+ * @internal
+ * Limited to Microsoft-internal use
+ *
+ * Function to check whether the data is a primitive type or a plain object.
+ * Recursion is limited to a maximum depth of 1000 to prevent excessive nesting and potential stack overflow.
+ *
+ * @param value The value to check
+ * @returns true if the value is a primitive type or a plain object, false otherwise
+ *
+ */
+export declare function isPrimitiveOrPlainObject(value: unknown, depth?: number): boolean;
+/**
+ * Normalizes legacy ageGroup values for backward compatibility
+ * @param runtimeConfig - The runtime configuration object to normalize
+ * @returns A new IBaseRuntime object with normalized ageGroup values
+ */
+export declare function normalizeAgeGroupValue(runtimeConfig: IBaseRuntime): IBaseRuntime;

package/dist/esm/packages/teams-js/dts/internal/validOrigins.d.ts

@@ -0,0 +1,13 @@
+export declare function prefetchOriginsFromCDN(): Promise<void>;
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function validateOrigin(messageOrigin: URL, disableCache?: boolean): Promise<boolean>;
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ *
+ * This function is only used for testing to reset the valid origins cache and ignore prefetched values.
+ */
+export declare function resetValidOriginsCache(): void;

package/dist/esm/packages/teams-js/dts/internal/videoEffectsUtils.d.ts

@@ -0,0 +1,31 @@
+import * as videoEffectsEx from '../private/videoEffectsEx';
+import * as videoEffects from '../public/videoEffects';
+import { VideoPerformanceMonitor } from './videoPerformanceMonitor';
+/**
+ * @hidden
+ * Create a MediaStreamTrack from the media stream with the given streamId and processed by videoFrameHandler.
+ */
+export declare function processMediaStream(streamId: string, videoFrameHandler: videoEffects.VideoFrameHandler, notifyError: (string: any) => void, videoPerformanceMonitor?: VideoPerformanceMonitor): Promise<void>;
+/**
+ * @hidden
+ * Create a MediaStreamTrack from the media stream with the given streamId and processed by videoFrameHandler.
+ * The videoFrameHandler will receive metadata of the video frame.
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function processMediaStreamWithMetadata(streamId: string, videoFrameHandler: videoEffectsEx.VideoFrameHandler, notifyError: (string: any) => void, videoPerformanceMonitor?: VideoPerformanceMonitor): Promise<void>;
+/**
+ * @hidden
+ * Video effect change call back function definition
+ * @beta
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+type VideoEffectCallBack = (effectId: string | undefined, effectParam?: string) => Promise<void>;
+/**
+ * @hidden
+ */
+export declare function createEffectParameterChangeCallback(callback: VideoEffectCallBack, videoPerformanceMonitor?: VideoPerformanceMonitor): (effectId: string | undefined, effectParam?: string) => void;
+export { VideoEffectCallBack as DefaultVideoEffectCallBack };

package/dist/esm/packages/teams-js/dts/internal/videoFrameTick.d.ts

@@ -0,0 +1,10 @@
+export declare class VideoFrameTick {
+    private static readonly setTimeoutCallbacks;
+    static setTimeout(callback: () => void, timeoutInMs: number): string;
+    static clearTimeout(id: string): void;
+    static setInterval(callback: () => void, intervalInMs: number): void;
+    /**
+     * Call this function whenever a frame comes in, it will check if any timeout is due and call the callback
+     */
+    static tick(): void;
+}

package/dist/esm/packages/teams-js/dts/internal/videoPerformanceMonitor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * This class is used to monitor the performance of video processing, and report performance events.
+ */
+export declare class VideoPerformanceMonitor {
+    private reportPerformanceEvent;
+    private static readonly distributionBinSize;
+    private static readonly calculateFPSInterval;
+    private isFirstFrameProcessed;
+    private applyingEffect?;
+    private appliedEffect?;
+    private frameProcessTimeLimit;
+    private gettingTextureStreamStartedAt;
+    private currentStreamId;
+    private frameProcessingStartedAt;
+    private frameProcessingTimeCost;
+    private processedFrameCount;
+    private performanceStatistics;
+    constructor(reportPerformanceEvent: (apiVersionTag: string, actionName: string, args: unknown[]) => void);
+    /**
+     * Start to check frame processing time intervally
+     * and report performance event if the average frame processing time is too long.
+     */
+    startMonitorSlowFrameProcessing(): void;
+    /**
+     * Define the time limit of frame processing.
+     * When the average frame processing time is longer than the time limit, a "video.performance.frameProcessingSlow" event will be reported.
+     * @param timeLimit
+     */
+    setFrameProcessTimeLimit(timeLimit: number): void;
+    /**
+     * Call this function when the app starts to switch to the new video effect
+     */
+    reportApplyingVideoEffect(effectId: string, effectParam?: string): void;
+    /**
+     * Call this function when the new video effect is ready
+     */
+    reportVideoEffectChanged(effectId: string, effectParam?: string): void;
+    /**
+     * Call this function when the app starts to process a video frame
+     */
+    reportStartFrameProcessing(frameWidth: number, frameHeight: number): void;
+    /**
+     * Call this function when the app finishes successfully processing a video frame
+     */
+    reportFrameProcessed(): void;
+    /**
+     * Call this function when the app starts to get the texture stream
+     */
+    reportGettingTextureStream(streamId: string): void;
+    /**
+     * Call this function when the app finishes successfully getting the texture stream
+     */
+    reportTextureStreamAcquired(): void;
+}

package/dist/esm/packages/teams-js/dts/internal/videoPerformanceStatistics.d.ts

@@ -0,0 +1,49 @@
+export type VideoPerformanceStatisticsResult = {
+    effectId: string;
+    effectParam?: string;
+    frameWidth: number;
+    frameHeight: number;
+    /**
+     * The duration in milliseconds that the data were collected
+     */
+    duration: number;
+    /**
+     * The number of frames that were processed in the duration
+     */
+    sampleCount: number;
+    /**
+     * An array that presents counts of frames that were finished in n milliseconds:
+     * distributionBins[frameProcessingDurationInMs]=frameCount.
+     * For example, distributionBins[10] = 5 means that 5 frames were processed in 10 milliseconds.
+     */
+    distributionBins: Uint32Array;
+};
+export declare class VideoPerformanceStatistics {
+    /**
+     * Function to report the statistics result
+     */
+    private reportStatisticsResult;
+    private static readonly initialSessionTimeoutInMs;
+    private static readonly maxSessionTimeoutInMs;
+    private currentSession;
+    private frameProcessingStartedAt;
+    private distributionBins;
+    private sampleCount;
+    private timeoutId;
+    constructor(distributionBinSize: number, 
+    /**
+     * Function to report the statistics result
+     */
+    reportStatisticsResult: (result: VideoPerformanceStatisticsResult) => void);
+    /**
+     * Call this function before processing every frame
+     */
+    processStarts(effectId: string, frameWidth: number, frameHeight: number, effectParam?: string): void;
+    processEnds(): void;
+    private getStatistics;
+    private start;
+    private suitableForThisSession;
+    private reportAndResetSession;
+    private resetCurrentSession;
+    private getNextTimeout;
+}

package/dist/esm/packages/teams-js/dts/internal/visualMediaHelpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @hidden
+ * All properties common to Image and Video Props
+ *
+ * @beta
+ */
+export interface VisualMediaProps {
+    /**
+     * @hidden
+     * The maximum number of media items that can be selected at once is limited to values that are less than or equal to the maximum visual media selection limit.
+     */
+    maxVisualMediaCount: number;
+}
+export declare const maxVisualMediaSelectionLimit = 10;

package/dist/esm/packages/teams-js/dts/internal/webStorageHelpers.d.ts

@@ -0,0 +1,4 @@
+import { HostName } from '../public/constants';
+export declare let cachedHostName: HostName | null;
+export declare function getCachedHostName(): Promise<HostName>;
+export declare function clearWebStorageCachedHostNameForTests(): void;

package/dist/esm/packages/teams-js/dts/private/appEntity.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @hidden
+ * Module to interact with the application entities specific part of the SDK.
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ *
+ * @module
+ */
+import { SdkError } from '../public/interfaces';
+/**
+ * @hidden
+ *
+ * Information on an app entity
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export interface AppEntity {
+    /**
+     * @hidden
+     * ID of the application
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    appId: string;
+    /**
+     * @hidden
+     * URL for the application's icon
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    appIconUrl: string;
+    /**
+     * @hidden
+     * Content URL for the app entity
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    contentUrl: string;
+    /**
+     * @hidden
+     * The display name for the app entity
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    displayName: string;
+    /**
+     * @hidden
+     * Website URL for the app entity. It is meant to be opened by the user in a browser.
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    websiteUrl: string;
+}
+/**
+ * @hidden
+ * Hide from docs
+ * --------
+ * Open the Tab Gallery and retrieve the app entity
+ * @param threadId ID of the thread where the app entity will be created
+ * @param categories A list of application categories that will be displayed in the opened tab gallery
+ * @param subEntityId An object that will be made available to the application being configured
+ *                      through the Context's subEntityId field.
+ * @param callback Callback that will be triggered once the app entity information is available.
+ *                 The callback takes two arguments: an SdkError in case something happened (i.e.
+ *                 no permissions to execute the API) and the app entity configuration, if available
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function selectAppEntity(threadId: string, categories: string[], subEntityId: string, callback: (sdkError?: SdkError, appEntity?: AppEntity) => void): void;
+/**
+ * @hidden
+ *
+ * Checks if the appEntity capability is supported by the host
+ * @returns boolean to represent whether the appEntity capability is supported
+ *
+ * @throws Error if {@linkcode app.initialize} has not successfully completed
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function isSupported(): boolean;

package/dist/esm/packages/teams-js/dts/private/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @hidden
+ * Error codes that can be thrown from externalAppCommands and externalAppCardCommands Action Submit specifically
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare enum ExternalAppErrorCode {
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+}

package/dist/esm/packages/teams-js/dts/private/conversations.d.ts

@@ -0,0 +1,152 @@
+/**
+ * @hidden
+ * Module to interact with the conversational subEntities inside the tab
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ *
+ * @module
+ */
+import { ChatMembersInformation } from './interfaces';
+export interface OpenConversationRequest {
+    /**
+     * @hidden
+     * The Id of the subEntity where the conversation is taking place
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    subEntityId: string;
+    /**
+     * @hidden
+     * The title of the conversation
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    title: string;
+    /**
+     * @hidden
+     * The Id of the conversation. This is optional and should be specified whenever a previous conversation about a specific sub-entity has already been started before
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    conversationId?: string;
+    /**
+     * @hidden
+     * The Id of the channel. This is optional and should be specified whenever a conversation is started or opened in a personal app scope
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    channelId?: string;
+    /**
+     * @hidden
+     * The entity Id of the tab
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    entityId: string;
+    /**
+     * @hidden
+     * A function that is called once the conversation Id has been created
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    onStartConversation?: (conversationResponse: ConversationResponse) => void;
+    /**
+     * @hidden
+     * A function that is called if the pane is closed
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    onCloseConversation?: (conversationResponse: ConversationResponse) => void;
+}
+/**
+ * @hidden
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export interface ConversationResponse {
+    /**
+     * @hidden
+     *
+     * Limited to Microsoft-internal use
+     * The Id of the subEntity where the conversation is taking place
+     */
+    subEntityId: string;
+    /**
+     * @hidden
+     * The Id of the conversation. This is optional and should be specified whenever a previous conversation about a specific sub-entity has already been started before
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    conversationId?: string;
+    /**
+     * @hidden
+     * The Id of the channel. This is optional and should be specified whenever a conversation is started or opened in a personal app scope
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    channelId?: string;
+    /**
+     * @hidden
+     * The entity Id of the tab
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    entityId?: string;
+}
+/**
+ * @hidden
+ * Hide from docs
+ * --------------
+ * Allows the user to start or continue a conversation with each subentity inside the tab
+ *
+ * @returns Promise resolved upon completion
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function openConversation(openConversationRequest: OpenConversationRequest): Promise<void>;
+/**
+ * @hidden
+ *
+ * Allows the user to close the conversation in the right pane
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function closeConversation(): void;
+/**
+ * @hidden
+ * Hide from docs
+ * ------
+ * Allows retrieval of information for all chat members.
+ * NOTE: This value should be used only as a hint as to who the members are
+ * and never as proof of membership in case your app is being hosted by a malicious party.
+ *
+ * @returns Promise resolved with information on all chat members
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function getChatMembers(): Promise<ChatMembersInformation>;
+/**
+ * Checks if the conversations capability is supported by the host
+ * @returns boolean to represent whether conversations capability is supported
+ *
+ * @throws Error if {@linkcode app.initialize} has not successfully completed
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+export declare function isSupported(): boolean;

package/dist/esm/packages/teams-js/dts/private/copilot/copilot.d.ts

@@ -0,0 +1,5 @@
+import * as customTelemetry from './customTelemetry';
+import * as eligibility from './eligibility';
+import * as sidePanel from './sidePanel';
+import * as view from './view';
+export { customTelemetry, eligibility, sidePanel, view };