@microsoft/teamsfx 0.6.2-alpha.67e38d838.0 → 0.6.2-alpha.6de687a73.0

package/dist/index.node.cjs.js

@@ -11,10 +11,32 @@ var identity = require('@azure/identity');
 var botbuilder = require('botbuilder');
 var botbuilderDialogs = require('botbuilder-dialogs');
 var uuid = require('uuid');
+var path = require('path');
+var fs = require('fs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 var jwt_decode__default = /*#__PURE__*/_interopDefaultLegacy(jwt_decode);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -1602,16 +1624,873 @@ class TeamsFx {
     }
 }
 
+// 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, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+            const conversation = yield this.newConversation(context);
+            yield this.parent.adapter.continueConversation(conversation, (ctx) => tslib.__awaiter(this, void 0, void 0, function* () {
+                yield ctx.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 tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.parent.adapter.continueConversation(this.parent.conversationReference, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+                const conversation = yield this.newConversation(context);
+                yield this.parent.adapter.continueConversation(conversation, (ctx) => tslib.__awaiter(this, void 0, void 0, function* () {
+                    yield ctx.sendActivity({
+                        attachments: [botbuilder.CardFactory.adaptiveCard(card)],
+                    });
+                }));
+            }));
+        });
+    }
+    /**
+     * @internal
+     */
+    newConversation(context) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const reference = botbuilder.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, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+            const conversation = yield this.newConversation(context);
+            yield this.parent.adapter.continueConversation(conversation, (ctx) => tslib.__awaiter(this, void 0, void 0, function* () {
+                yield ctx.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 tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.parent.adapter.continueConversation(this.parent.conversationReference, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+                const conversation = yield this.newConversation(context);
+                yield this.parent.adapter.continueConversation(conversation, (ctx) => tslib.__awaiter(this, void 0, void 0, function* () {
+                    yield ctx.sendActivity({
+                        attachments: [botbuilder.CardFactory.adaptiveCard(card)],
+                    });
+                }));
+            }));
+        });
+    }
+    /**
+     * @internal
+     */
+    newConversation(context) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const reference = botbuilder.TurnContext.getConversationReference(context.activity);
+            const personalConversation = cloneConversation(reference);
+            const connectorClient = context.turnState.get(this.parent.adapter.ConnectorClientKey);
+            const conversation = yield 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, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+            yield 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, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+            yield context.sendActivity({
+                attachments: [botbuilder.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
+     */
+    channels() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            let teamsChannels = [];
+            yield this.adapter.continueConversation(this.conversationReference, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+                const teamId = getTeamsBotInstallationId(context);
+                if (teamId !== undefined) {
+                    teamsChannels = yield botbuilder.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
+     */
+    members() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            let teamsMembers = [];
+            yield this.adapter.continueConversation(this.conversationReference, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+                teamsMembers = yield botbuilder.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;
+    }
+    onTurn(context, next) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const type = this.classifyActivity(context.activity);
+            switch (type) {
+                case ActivityType.CurrentBotInstalled:
+                case ActivityType.TeamRestored: {
+                    const reference = botbuilder.TurnContext.getConversationReference(context.activity);
+                    yield this.conversationReferenceStore.set(reference);
+                    break;
+                }
+                case ActivityType.CurrentBotMessaged: {
+                    const reference = botbuilder.TurnContext.getConversationReference(context.activity);
+                    if (!(yield this.conversationReferenceStore.check(reference))) {
+                        yield this.conversationReferenceStore.set(reference);
+                    }
+                    break;
+                }
+                case ActivityType.CurrentBotUninstalled:
+                case ActivityType.TeamDeleted: {
+                    const reference = botbuilder.TurnContext.getConversationReference(context.activity);
+                    yield this.conversationReferenceStore.delete(reference);
+                    break;
+                }
+            }
+            yield 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);
+        }
+    }
+    onTurn(context, next) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            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 = yield handlers[0].handleCommandReceived(context, commandText);
+                        yield context.sendActivity(response);
+                    }
+                    break;
+            }
+            yield 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 = botbuilder.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__namespace.resolve(fileDir, this.localFileName);
+    }
+    read(key) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.storeFileExists())) {
+                return undefined;
+            }
+            const data = yield this.readFromFile();
+            return data[key];
+        });
+    }
+    list() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.storeFileExists())) {
+                return [];
+            }
+            const data = yield this.readFromFile();
+            return Object.entries(data).map((entry) => entry[1]);
+        });
+    }
+    write(key, object) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.storeFileExists())) {
+                yield this.writeToFile({ [key]: object });
+                return;
+            }
+            const data = yield this.readFromFile();
+            yield this.writeToFile(Object.assign(data, { [key]: object }));
+        });
+    }
+    delete(key) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (yield this.storeFileExists()) {
+                const data = yield this.readFromFile();
+                if (data[key] !== undefined) {
+                    delete data[key];
+                    yield this.writeToFile(data);
+                }
+            }
+        });
+    }
+    storeFileExists() {
+        return new Promise((resolve) => {
+            try {
+                fs__namespace.access(this.filePath, (err) => {
+                    if (err) {
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            }
+            catch (error) {
+                resolve(false);
+            }
+        });
+    }
+    readFromFile() {
+        return new Promise((resolve, reject) => {
+            try {
+                fs__namespace.readFile(this.filePath, { encoding: "utf-8" }, (err, rawData) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(JSON.parse(rawData));
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    writeToFile(data) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    const rawData = JSON.stringify(data, undefined, 2);
+                    fs__namespace.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;
+    }
+    check(reference) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const ref = yield 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__namespace.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 installations() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (ConversationBot.conversationReferenceStore === undefined ||
+                ConversationBot.adapter === undefined) {
+                throw new Error("ConversationBot has not been initialized.");
+            }
+            const references = (yield ConversationBot.conversationReferenceStore.getAll()).values();
+            const targets = [];
+            for (const reference of references) {
+                // validate connection
+                let valid = true;
+                ConversationBot.adapter.continueConversation(reference, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+                    try {
+                        // try get member to see if the installation is still valid
+                        yield botbuilder.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: [botbuilder.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: [botbuilder.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(botbuilder.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(botbuilder.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(botbuilder.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(botbuilder.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(botbuilder.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],
+        };
+    }
+}
+
 exports.AppCredential = AppCredential;
+exports.Channel = Channel;
+exports.ConversationBot = ConversationBot;
 exports.ErrorWithCode = ErrorWithCode;
+exports.Member = Member;
+exports.MessageBuilder = MessageBuilder;
 exports.MsGraphAuthProvider = MsGraphAuthProvider;
 exports.OnBehalfOfUserCredential = OnBehalfOfUserCredential;
+exports.TeamsBotInstallation = TeamsBotInstallation;
 exports.TeamsBotSsoPrompt = TeamsBotSsoPrompt;
 exports.TeamsFx = TeamsFx;
 exports.TeamsUserCredential = TeamsUserCredential;
 exports.createMicrosoftGraphClient = createMicrosoftGraphClient;
 exports.getLogLevel = getLogLevel;
 exports.getTediousConnectionConfig = getTediousConnectionConfig;
+exports.sendAdaptiveCard = sendAdaptiveCard;
+exports.sendMessage = sendMessage;
 exports.setLogFunction = setLogFunction;
 exports.setLogLevel = setLogLevel;
 exports.setLogger = setLogger;