@microsoft/teamsfx 0.6.2-alpha.3bbacb98c.0 → 0.6.2-alpha.6399c5efb.0

package/dist/index.esm2017.mjs

@@ -3,9 +3,11 @@ import { ConfidentialClientApplication } from '@azure/msal-node';
 import { createHash } from 'crypto';
 import { Client } from '@microsoft/microsoft-graph-client';
 import { ManagedIdentityCredential } from '@azure/identity';
-import { ActivityTypes, Channels, TeamsInfo, CardFactory, ActionTypes, MessageFactory, StatusCodes, verifyStateOperationName, tokenExchangeOperationName } from 'botbuilder';
+import { ActivityTypes, Channels, TeamsInfo, CardFactory, ActionTypes, MessageFactory, StatusCodes, verifyStateOperationName, tokenExchangeOperationName, TurnContext } from 'botbuilder';
 import { Dialog } from 'botbuilder-dialogs';
 import { v4 } from 'uuid';
+import * as path from 'path';
+import * as fs from 'fs';
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -1567,5 +1569,825 @@ class TeamsFx {
     }
 }
 
-export { AppCredential, ErrorCode, ErrorWithCode, IdentityType, LogLevel, MsGraphAuthProvider, OnBehalfOfUserCredential, TeamsBotSsoPrompt, TeamsFx, TeamsUserCredential, createMicrosoftGraphClient, getLogLevel, getTediousConnectionConfig, setLogFunction, setLogLevel, setLogger };
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * @internal
+ */
+function cloneConversation(conversation) {
+    return Object.assign({}, conversation);
+}
+/**
+ * @internal
+ */
+function getTargetType(conversationReference) {
+    var _a;
+    const conversationType = (_a = conversationReference.conversation) === null || _a === void 0 ? void 0 : _a.conversationType;
+    if (conversationType === "personal") {
+        return "Person";
+    }
+    else if (conversationType === "groupChat") {
+        return "Group";
+    }
+    else if (conversationType === "channel") {
+        return "Channel";
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * @internal
+ */
+function getTeamsBotInstallationId(context) {
+    var _a, _b, _c, _d;
+    return (_d = (_c = (_b = (_a = context.activity) === null || _a === void 0 ? void 0 : _a.channelData) === null || _b === void 0 ? void 0 : _b.team) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : context.activity.conversation.id;
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Send a plain text message to a notification target.
+ *
+ * @param target - the notification target.
+ * @param text - the plain text message.
+ * @returns A `Promise` representing the asynchronous operation.
+ *
+ * @beta
+ */
+function sendMessage(target, text) {
+    return target.sendMessage(text);
+}
+/**
+ * Send an adaptive card message to a notification target.
+ *
+ * @param target - the notification target.
+ * @param card - the adaptive card raw JSON.
+ * @returns A `Promise` representing the asynchronous operation.
+ *
+ * @beta
+ */
+function sendAdaptiveCard(target, card) {
+    return target.sendAdaptiveCard(card);
+}
+/**
+ * A {@link NotificationTarget} that represents a team channel.
+ *
+ * @remarks
+ * It's recommended to get channels from {@link TeamsBotInstallation.channels()}.
+ *
+ * @beta
+ */
+class Channel {
+    /**
+     * Constuctor.
+     *
+     * @remarks
+     * It's recommended to get channels from {@link TeamsBotInstallation.channels()}, instead of using this constructor.
+     *
+     * @param parent - The parent {@link TeamsBotInstallation} where this channel is created from.
+     * @param info - Detailed channel information.
+     *
+     * @beta
+     */
+    constructor(parent, info) {
+        /**
+         * Notification target type. For channel it's always "Channel".
+         *
+         * @beta
+         */
+        this.type = "Channel";
+        this.parent = parent;
+        this.info = info;
+    }
+    /**
+     * Send a plain text message.
+     *
+     * @param text - the plain text message.
+     * @returns A `Promise` representing the asynchronous operation.
+     *
+     * @beta
+     */
+    sendMessage(text) {
+        return this.parent.adapter.continueConversation(this.parent.conversationReference, async (context) => {
+            const conversation = await this.newConversation(context);
+            await this.parent.adapter.continueConversation(conversation, async (ctx) => {
+                await ctx.sendActivity(text);
+            });
+        });
+    }
+    /**
+     * Send an adaptive card message.
+     *
+     * @param card - the adaptive card raw JSON.
+     * @returns A `Promise` representing the asynchronous operation.
+     *
+     * @beta
+     */
+    async sendAdaptiveCard(card) {
+        return this.parent.adapter.continueConversation(this.parent.conversationReference, async (context) => {
+            const conversation = await this.newConversation(context);
+            await this.parent.adapter.continueConversation(conversation, async (ctx) => {
+                await ctx.sendActivity({
+                    attachments: [CardFactory.adaptiveCard(card)],
+                });
+            });
+        });
+    }
+    /**
+     * @internal
+     */
+    async newConversation(context) {
+        const reference = TurnContext.getConversationReference(context.activity);
+        const channelConversation = cloneConversation(reference);
+        channelConversation.conversation.id = this.info.id || "";
+        return channelConversation;
+    }
+}
+/**
+ * A {@link NotificationTarget} that represents a team member.
+ *
+ * @remarks
+ * It's recommended to get members from {@link TeamsBotInstallation.members()}.
+ *
+ * @beta
+ */
+class Member {
+    /**
+     * Constuctor.
+     *
+     * @remarks
+     * It's recommended to get members from {@link TeamsBotInstallation.members()}, instead of using this constructor.
+     *
+     * @param parent - The parent {@link TeamsBotInstallation} where this member is created from.
+     * @param account - Detailed member account information.
+     *
+     * @beta
+     */
+    constructor(parent, account) {
+        /**
+         * Notification target type. For member it's always "Person".
+         *
+         * @beta
+         */
+        this.type = "Person";
+        this.parent = parent;
+        this.account = account;
+    }
+    /**
+     * Send a plain text message.
+     *
+     * @param text - the plain text message.
+     * @returns A `Promise` representing the asynchronous operation.
+     *
+     * @beta
+     */
+    sendMessage(text) {
+        return this.parent.adapter.continueConversation(this.parent.conversationReference, async (context) => {
+            const conversation = await this.newConversation(context);
+            await this.parent.adapter.continueConversation(conversation, async (ctx) => {
+                await ctx.sendActivity(text);
+            });
+        });
+    }
+    /**
+     * Send an adaptive card message.
+     *
+     * @param card - the adaptive card raw JSON.
+     * @returns A `Promise` representing the asynchronous operation.
+     *
+     * @beta
+     */
+    async sendAdaptiveCard(card) {
+        return this.parent.adapter.continueConversation(this.parent.conversationReference, async (context) => {
+            const conversation = await this.newConversation(context);
+            await this.parent.adapter.continueConversation(conversation, async (ctx) => {
+                await ctx.sendActivity({
+                    attachments: [CardFactory.adaptiveCard(card)],
+                });
+            });
+        });
+    }
+    /**
+     * @internal
+     */
+    async newConversation(context) {
+        const reference = TurnContext.getConversationReference(context.activity);
+        const personalConversation = cloneConversation(reference);
+        const connectorClient = context.turnState.get(this.parent.adapter.ConnectorClientKey);
+        const conversation = await connectorClient.conversations.createConversation({
+            isGroup: false,
+            tenantId: context.activity.conversation.tenantId,
+            bot: context.activity.recipient,
+            members: [this.account],
+            channelData: {},
+        });
+        personalConversation.conversation.id = conversation.id;
+        return personalConversation;
+    }
+}
+/**
+ * A {@link NotificationTarget} that represents a bot installation. Teams Bot could be installed into
+ * - Personal chat
+ * - Group chat
+ * - Team (by default the `General` channel)
+ *
+ * @remarks
+ * It's recommended to get bot installations from {@link ConversationBot.installations()}.
+ *
+ * @beta
+ */
+class TeamsBotInstallation {
+    /**
+     * Constructor
+     *
+     * @remarks
+     * It's recommended to get bot installations from {@link ConversationBot.installations()}, instead of using this constructor.
+     *
+     * @param adapter - the bound `BotFrameworkAdapter`.
+     * @param conversationReference - the bound `ConversationReference`.
+     *
+     * @beta
+     */
+    constructor(adapter, conversationReference) {
+        this.adapter = adapter;
+        this.conversationReference = conversationReference;
+        this.type = getTargetType(conversationReference);
+    }
+    /**
+     * Send a plain text message.
+     *
+     * @param text - the plain text message.
+     * @returns A `Promise` representing the asynchronous operation.
+     *
+     * @beta
+     */
+    sendMessage(text) {
+        return this.adapter.continueConversation(this.conversationReference, async (context) => {
+            await context.sendActivity(text);
+        });
+    }
+    /**
+     * Send an adaptive card message.
+     *
+     * @param card - the adaptive card raw JSON.
+     * @returns A `Promise` representing the asynchronous operation.
+     *
+     * @beta
+     */
+    sendAdaptiveCard(card) {
+        return this.adapter.continueConversation(this.conversationReference, async (context) => {
+            await context.sendActivity({
+                attachments: [CardFactory.adaptiveCard(card)],
+            });
+        });
+    }
+    /**
+     * Get channels from this bot installation.
+     *
+     * @returns an array of channels if bot is installed into a team, otherwise returns an empty array.
+     *
+     * @beta
+     */
+    async channels() {
+        let teamsChannels = [];
+        await this.adapter.continueConversation(this.conversationReference, async (context) => {
+            const teamId = getTeamsBotInstallationId(context);
+            if (teamId !== undefined) {
+                teamsChannels = await TeamsInfo.getTeamChannels(context, teamId);
+            }
+        });
+        const channels = [];
+        for (const channel of teamsChannels) {
+            channels.push(new Channel(this, channel));
+        }
+        return channels;
+    }
+    /**
+     * Get members from this bot installation.
+     *
+     * @returns an array of members from where the bot is installed.
+     *
+     * @beta
+     */
+    async members() {
+        let teamsMembers = [];
+        await this.adapter.continueConversation(this.conversationReference, async (context) => {
+            teamsMembers = await TeamsInfo.getMembers(context);
+        });
+        const members = [];
+        for (const member of teamsMembers) {
+            members.push(new Member(this, member));
+        }
+        return members;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * @internal
+ */
+var ActivityType;
+(function (ActivityType) {
+    ActivityType[ActivityType["CurrentBotInstalled"] = 0] = "CurrentBotInstalled";
+    ActivityType[ActivityType["CurrentBotMessaged"] = 1] = "CurrentBotMessaged";
+    ActivityType[ActivityType["CurrentBotUninstalled"] = 2] = "CurrentBotUninstalled";
+    ActivityType[ActivityType["TeamDeleted"] = 3] = "TeamDeleted";
+    ActivityType[ActivityType["TeamRestored"] = 4] = "TeamRestored";
+    ActivityType[ActivityType["CommandReceived"] = 5] = "CommandReceived";
+    ActivityType[ActivityType["Unknown"] = 6] = "Unknown";
+})(ActivityType || (ActivityType = {}));
+/**
+ * @internal
+ */
+class NotificationMiddleware {
+    constructor(options) {
+        this.conversationReferenceStore = options.conversationReferenceStore;
+    }
+    async onTurn(context, next) {
+        const type = this.classifyActivity(context.activity);
+        switch (type) {
+            case ActivityType.CurrentBotInstalled:
+            case ActivityType.TeamRestored: {
+                const reference = TurnContext.getConversationReference(context.activity);
+                await this.conversationReferenceStore.set(reference);
+                break;
+            }
+            case ActivityType.CurrentBotMessaged: {
+                const reference = TurnContext.getConversationReference(context.activity);
+                if (!(await this.conversationReferenceStore.check(reference))) {
+                    await this.conversationReferenceStore.set(reference);
+                }
+                break;
+            }
+            case ActivityType.CurrentBotUninstalled:
+            case ActivityType.TeamDeleted: {
+                const reference = TurnContext.getConversationReference(context.activity);
+                await this.conversationReferenceStore.delete(reference);
+                break;
+            }
+        }
+        await next();
+    }
+    classifyActivity(activity) {
+        var _a, _b;
+        const activityType = activity.type;
+        if (activityType === "installationUpdate") {
+            const action = (_a = activity.action) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (action === "add") {
+                return ActivityType.CurrentBotInstalled;
+            }
+            else {
+                return ActivityType.CurrentBotUninstalled;
+            }
+        }
+        else if (activityType === "message") {
+            return ActivityType.CurrentBotMessaged;
+        }
+        else if (activityType === "conversationUpdate") {
+            const eventType = (_b = activity.channelData) === null || _b === void 0 ? void 0 : _b.eventType;
+            if (eventType === "teamDeleted") {
+                return ActivityType.TeamDeleted;
+            }
+            else if (eventType === "teamRestored") {
+                return ActivityType.TeamRestored;
+            }
+        }
+        return ActivityType.Unknown;
+    }
+}
+class CommandResponseMiddleware {
+    constructor(handlers) {
+        this.commandHandlers = [];
+        if (handlers && handlers.length > 0) {
+            this.commandHandlers.push(...handlers);
+        }
+    }
+    async onTurn(context, next) {
+        const type = this.classifyActivity(context.activity);
+        let handlers = [];
+        switch (type) {
+            case ActivityType.CommandReceived:
+                // Invoke corresponding command handler for the command response
+                const commandText = this.getActivityText(context.activity);
+                handlers = this.filterCommandHandler(commandText, this.commandHandlers);
+                if (handlers.length > 0) {
+                    const response = await handlers[0].handleCommandReceived(context, commandText);
+                    await context.sendActivity(response);
+                }
+                break;
+        }
+        await next();
+    }
+    classifyActivity(activity) {
+        if (this.isCommandReceived(activity)) {
+            return ActivityType.CommandReceived;
+        }
+        return ActivityType.Unknown;
+    }
+    isCommandReceived(activity) {
+        if (this.commandHandlers) {
+            const commandText = this.getActivityText(activity);
+            const handlers = this.filterCommandHandler(commandText, this.commandHandlers);
+            return handlers.length > 0;
+        }
+        else {
+            return false;
+        }
+    }
+    filterCommandHandler(commandText, commandHandlers) {
+        const handlers = commandHandlers.filter((handler) => {
+            var _a;
+            if (typeof handler.commandNameOrPattern === "string") {
+                return handler.commandNameOrPattern.toLocaleLowerCase() === commandText;
+            }
+            else {
+                return (_a = handler.commandNameOrPattern) === null || _a === void 0 ? void 0 : _a.test(commandText);
+            }
+        });
+        return handlers;
+    }
+    getActivityText(activity) {
+        let text = activity.text;
+        const removedMentionText = TurnContext.removeRecipientMention(activity);
+        if (removedMentionText) {
+            text = removedMentionText
+                .toLowerCase()
+                .replace(/\n|\r\n/g, "")
+                .trim();
+        }
+        return text;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * @internal
+ */
+class LocalFileStorage {
+    constructor(fileDir) {
+        this.localFileName = ".notification.localstore.json";
+        this.filePath = path.resolve(fileDir, this.localFileName);
+    }
+    async read(key) {
+        if (!(await this.storeFileExists())) {
+            return undefined;
+        }
+        const data = await this.readFromFile();
+        return data[key];
+    }
+    async list() {
+        if (!(await this.storeFileExists())) {
+            return [];
+        }
+        const data = await this.readFromFile();
+        return Object.entries(data).map((entry) => entry[1]);
+    }
+    async write(key, object) {
+        if (!(await this.storeFileExists())) {
+            await this.writeToFile({ [key]: object });
+            return;
+        }
+        const data = await this.readFromFile();
+        await this.writeToFile(Object.assign(data, { [key]: object }));
+    }
+    async delete(key) {
+        if (await this.storeFileExists()) {
+            const data = await this.readFromFile();
+            if (data[key] !== undefined) {
+                delete data[key];
+                await this.writeToFile(data);
+            }
+        }
+    }
+    storeFileExists() {
+        return new Promise((resolve) => {
+            try {
+                fs.access(this.filePath, (err) => {
+                    if (err) {
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            }
+            catch (error) {
+                resolve(false);
+            }
+        });
+    }
+    readFromFile() {
+        return new Promise((resolve, reject) => {
+            try {
+                fs.readFile(this.filePath, { encoding: "utf-8" }, (err, rawData) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(JSON.parse(rawData));
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async writeToFile(data) {
+        return new Promise((resolve, reject) => {
+            try {
+                const rawData = JSON.stringify(data, undefined, 2);
+                fs.writeFile(this.filePath, rawData, { encoding: "utf-8" }, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+/**
+ * @internal
+ */
+class ConversationReferenceStore {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async check(reference) {
+        const ref = await this.storage.read(this.getKey(reference));
+        return ref !== undefined;
+    }
+    getAll() {
+        return this.storage.list();
+    }
+    set(reference) {
+        return this.storage.write(this.getKey(reference), reference);
+    }
+    delete(reference) {
+        return this.storage.delete(this.getKey(reference));
+    }
+    getKey(reference) {
+        var _a, _b;
+        return `_${(_a = reference.conversation) === null || _a === void 0 ? void 0 : _a.tenantId}_${(_b = reference.conversation) === null || _b === void 0 ? void 0 : _b.id}`;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Provide static utilities for bot conversation, including
+ * - send notification to varies targets (e.g., member, channel, incoming wehbook)
+ * - handle command and response.
+ *
+ * @example
+ * Here's an example on how to send notification via Teams Bot.
+ * ```typescript
+ * // initialize (it's recommended to be called before handling any bot message)
+ * ConversationBot.initialize(adapter, {
+ *    enableNotification: true
+ * });
+ *
+ * // get all bot installations and send message
+ * for (const target of await ConversationBot.installations()) {
+ *   await target.sendMessage("Hello Notification");
+ * }
+ *
+ * // alternative - send message to all members
+ * for (const target of await ConversationBot.installations()) {
+ *   for (const member of await target.members()) {
+ *     await member.sendMessage("Hello Notification");
+ *   }
+ * }
+ * ```
+ *
+ * @beta
+ */
+class ConversationBot {
+    /**
+     * Initialize bot notification.
+     *
+     * @remarks
+     * To ensure accuracy, it's recommended to initialize before handling any message.
+     *
+     * @param adapter - the bound `BotFrameworkAdapter`
+     * @param options - initialize options
+     *
+     * @beta
+     */
+    static initialize(adapter, options) {
+        var _a, _b;
+        const storage = (_a = options === null || options === void 0 ? void 0 : options.storage) !== null && _a !== void 0 ? _a : new LocalFileStorage(path.resolve(process.env.RUNNING_ON_AZURE === "1" ? (_b = process.env.TEMP) !== null && _b !== void 0 ? _b : "./" : "./"));
+        ConversationBot.adapter = adapter;
+        if (options === null || options === void 0 ? void 0 : options.enableNotification) {
+            ConversationBot.conversationReferenceStore = new ConversationReferenceStore(storage);
+            ConversationBot.adapter = adapter.use(new NotificationMiddleware({
+                conversationReferenceStore: ConversationBot.conversationReferenceStore,
+            }));
+        }
+        if (options === null || options === void 0 ? void 0 : options.commandHandlers) {
+            ConversationBot.adapter = adapter.use(new CommandResponseMiddleware(options.commandHandlers));
+        }
+    }
+    /**
+     * Get all targets where the bot is installed.
+     *
+     * @remarks
+     * The result is retrieving from the persisted storage.
+     *
+     * @returns - an array of {@link TeamsBotInstallation}.
+     *
+     * @beta
+     */
+    static async installations() {
+        if (ConversationBot.conversationReferenceStore === undefined ||
+            ConversationBot.adapter === undefined) {
+            throw new Error("ConversationBot has not been initialized.");
+        }
+        const references = (await ConversationBot.conversationReferenceStore.getAll()).values();
+        const targets = [];
+        for (const reference of references) {
+            // validate connection
+            let valid = true;
+            ConversationBot.adapter.continueConversation(reference, async (context) => {
+                try {
+                    // try get member to see if the installation is still valid
+                    await TeamsInfo.getPagedMembers(context, 1);
+                }
+                catch (error) {
+                    if (error.code === "BotNotInConversationRoster") {
+                        valid = false;
+                    }
+                }
+            });
+            if (valid) {
+                targets.push(new TeamsBotInstallation(ConversationBot.adapter, reference));
+            }
+            else {
+                ConversationBot.conversationReferenceStore.delete(reference);
+            }
+        }
+        return targets;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+const { AdaptiveCards } = require("@microsoft/adaptivecards-tools");
+/**
+ * Provides utility method to build bot message with cards that supported in Teams.
+ */
+class MessageBuilder {
+    /**
+     * Build a bot message activity attached with adaptive card.
+     *
+     * @param getCardData Function to prepare your card data.
+     * @param cardTemplate The adaptive card template.
+     * @returns A bot message activity attached with an adaptive card.
+     *
+     * @example
+     * ```javascript
+     * const cardTemplate = {
+     *   type: "AdaptiveCard",
+     *   body: [
+     *     {
+     *       "type": "TextBlock",
+     *       "text": "${title}",
+     *       "size": "Large"
+     *     },
+     *     {
+     *       "type": "TextBlock",
+     *       "text": "${description}"
+     *     }],
+     *     $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+     *     version: "1.4"
+     *  };
+     *
+     * type CardData = {
+     *   title: string,
+     *   description: string
+     * };
+     * const card = MessageBuilder.attachAdaptiveCard<CardData>(() => {
+     *     return {
+     *       title: "sample card title",
+     *       description: "sample card description"
+     *     }}, cardTemplate);
+     * ```
+     *
+     * @beta
+     */
+    static attachAdaptiveCard(getCardData, cardTemplate) {
+        const cardData = getCardData();
+        return {
+            attachments: [CardFactory.adaptiveCard(AdaptiveCards.declare(cardTemplate).render(cardData))],
+        };
+    }
+    /**
+     * Build a bot message activity attached with an adaptive card.
+     *
+     * @param card The adaptive card content.
+     * @returns A bot message activity attached with an adaptive card.
+     *
+     * @beta
+     */
+    static attachAdaptiveCardWithoutData(card) {
+        return {
+            attachments: [CardFactory.adaptiveCard(AdaptiveCards.declareWithoutData(card).render())],
+        };
+    }
+    /**
+     * Build a bot message activity attached with an hero card.
+     *
+     * @param title The card title.
+     * @param images Optional. The array of images to include on the card.
+     * @param buttons Optional. The array of buttons to include on the card. Each `string` in the array
+     *      is converted to an `imBack` button with a title and value set to the value of the string.
+     * @param other Optional. Any additional properties to include on the card.
+     *
+     * @returns A bot message activity attached with a hero card.
+     *
+     * @example
+     * ```javascript
+     * const message = MessageBuilder.attachHeroCard(
+     *      'sample title',
+     *      ['https://example.com/sample.jpg'],
+     *      ['action']
+     * );
+     * ```
+     *
+     * @beta
+     */
+    static attachHeroCard(title, images, buttons, other) {
+        return MessageBuilder.attachContent(CardFactory.heroCard(title, images, buttons, other));
+    }
+    /**
+     * Returns an attachment for a sign-in card.
+     *
+     * @param title The title for the card's sign-in button.
+     * @param url The URL of the sign-in page to use.
+     * @param text Optional. Additional text to include on the card.
+     *
+     * @returns A bot message activity attached with a sign-in card.
+     *
+     * @remarks
+     * For channels that don't natively support sign-in cards, an alternative message is rendered.
+     *
+     * @beta
+     */
+    static attachSigninCard(title, url, text) {
+        return MessageBuilder.attachContent(CardFactory.signinCard(title, url, text));
+    }
+    /**
+     * Build a bot message activity attached with an Office 365 connector card.
+     *
+     * @param card A description of the Office 365 connector card.
+     * @returns A bot message activity attached with an Office 365 connector card.
+     *
+     * @beta
+     */
+    static attachO365ConnectorCard(card) {
+        return MessageBuilder.attachContent(CardFactory.o365ConnectorCard(card));
+    }
+    /**
+     * Build a message activity attached with a receipt card.
+     * @param card A description of the receipt card.
+     * @returns A message activity attached with a receipt card.
+     *
+     * @beta
+     */
+    static AttachReceiptCard(card) {
+        return MessageBuilder.attachContent(CardFactory.receiptCard(card));
+    }
+    /**
+     *
+     * @param title The card title.
+     * @param images Optional. The array of images to include on the card.
+     * @param buttons Optional. The array of buttons to include on the card. Each `string` in the array
+     *      is converted to an `imBack` button with a title and value set to the value of the string.
+     * @param other Optional. Any additional properties to include on the card.
+     * @returns A message activity attached with a thumbnail card
+     *
+     * @beta
+     */
+    static attachThumbnailCard(title, images, buttons, other) {
+        return MessageBuilder.attachContent(CardFactory.thumbnailCard(title, images, buttons, other));
+    }
+    /**
+     * Add an attachement to a bot activity.
+     * @param attachement The attachment object to attach.
+     * @returns A message activity with an attachment.
+     *
+     * @beta
+     */
+    static attachContent(attachement) {
+        return {
+            attachments: [attachement],
+        };
+    }
+}
+
+export { AppCredential, Channel, ConversationBot, ErrorCode, ErrorWithCode, IdentityType, LogLevel, Member, MessageBuilder, MsGraphAuthProvider, OnBehalfOfUserCredential, TeamsBotInstallation, TeamsBotSsoPrompt, TeamsFx, TeamsUserCredential, createMicrosoftGraphClient, getLogLevel, getTediousConnectionConfig, sendAdaptiveCard, sendMessage, setLogFunction, setLogLevel, setLogger };
 //# sourceMappingURL=index.esm2017.mjs.map