@microsoft/teamsfx 0.6.2-rc.0 → 0.6.3-alpha.633d9d21e.0

package/dist/index.node.cjs.js

@@ -11,10 +11,35 @@ var identity = require('@azure/identity');
 var botbuilder = require('botbuilder');
 var botbuilderDialogs = require('botbuilder-dialogs');
 var uuid = require('uuid');
+var axios = require('axios');
+var https = require('https');
+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 axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -97,6 +122,9 @@ ErrorMessage.FailToAcquireTokenOnBehalfOfUser = "Failed to acquire access token
 ErrorMessage.OnlyMSTeamsChannelSupported = "{0} is only supported in MS Teams Channel";
 // IdentityTypeNotSupported Error
 ErrorMessage.IdentityTypeNotSupported = "{0} identity is not supported in {1}";
+// InvalidParameter Error
+ErrorMessage.EmptyParameter = "Parameter {0} is empty";
+ErrorMessage.DuplicateHttpsOptionProperty = "Axios HTTPS agent already defined value for property {0}";
 /**
  * Error class with code and message thrown by the SDK.
  *
@@ -1416,6 +1444,171 @@ class TeamsBotSsoPrompt extends botbuilderDialogs.Dialog {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+/**
+ * Initializes new Axios instance with specific auth provider
+ *
+ * @param apiEndpoint - Base url of the API
+ * @param authProvider - Auth provider that injects authentication info to each request
+ * @returns axios instance configured with specfic auth provider
+ *
+ * @example
+ * ```typescript
+ * const client = createApiClient("https://my-api-endpoint-base-url", new BasicAuthProvider("xxx","xxx"));
+ * ```
+ *
+ * @beta
+ */
+function createApiClient(apiEndpoint, authProvider) {
+    // Add a request interceptor
+    const instance = axios__default["default"].create({
+        baseURL: apiEndpoint,
+    });
+    instance.interceptors.request.use(function (config) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            return yield authProvider.AddAuthenticationInfo(config);
+        });
+    });
+    return instance;
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Provider that handles Bearer Token authentication
+ *
+ * @beta
+ */
+class BearerTokenAuthProvider {
+    /**
+     * @param getToken Function that returns the content of bearer token used in http request
+     *
+     * @beta
+     */
+    constructor(getToken) {
+        this.getToken = getToken;
+    }
+    /**
+     * Adds authentication info to http requests
+     *
+     * @param config - Contains all the request information and can be updated to include extra authentication info.
+     * Refer https://axios-http.com/docs/req_config for detailed document.
+     *
+     * @beta
+     */
+    AddAuthenticationInfo(config) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const token = yield this.getToken();
+            if (!config.headers) {
+                config.headers = {};
+            }
+            if (config.headers["Authorization"]) {
+                throw new Error("Authorization header already exists!");
+            }
+            config.headers["Authorization"] = `Bearer ${token}`;
+            return config;
+        });
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Provider that handles Certificate authentication
+ *
+ * @beta
+ */
+class CertificateAuthProvider {
+    /**
+     *
+     * @param { SecureContextOptions } certOption - information about the cert used in http requests
+     *
+     * @beta
+     */
+    constructor(certOption) {
+        if (certOption && Object.keys(certOption).length !== 0) {
+            this.certOption = certOption;
+        }
+        else {
+            throw new ErrorWithCode(formatString(ErrorMessage.EmptyParameter, "certOption"), exports.ErrorCode.InvalidParameter);
+        }
+    }
+    /**
+     * Adds authentication info to http requests.
+     *
+     * @param { AxiosRequestConfig } config - Contains all the request information and can be updated to include extra authentication info.
+     * Refer https://axios-http.com/docs/req_config for detailed document.
+     *
+     * @returns Updated axios request config.
+     *
+     * @throws {@link ErrorCode|InvalidParameter} - when custom httpsAgent in the request has duplicate properties with certOption provided in constructor.
+     *
+     * @beta
+     */
+    AddAuthenticationInfo(config) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!config.httpsAgent) {
+                config.httpsAgent = new https.Agent(this.certOption);
+            }
+            else {
+                const existingProperties = new Set(Object.keys(config.httpsAgent.options));
+                for (const property of Object.keys(this.certOption)) {
+                    if (existingProperties.has(property)) {
+                        throw new ErrorWithCode(formatString(ErrorMessage.DuplicateHttpsOptionProperty, property), exports.ErrorCode.InvalidParameter);
+                    }
+                }
+                Object.assign(config.httpsAgent.options, this.certOption);
+            }
+            return config;
+        });
+    }
+}
+/**
+ * Helper to create SecureContextOptions from PEM format cert
+ *
+ * @param { string | Buffer } cert - The cert chain in PEM format
+ * @param { string | Buffer } key - The private key for the cert chain
+ * @param { string? } passphrase - The passphrase for private key
+ * @param { string? | Buffer? } ca - Overrides the trusted CA certificates
+ *
+ * @returns Instance of SecureContextOptions
+ *
+ * @throws {@link ErrorCode|InvalidParameter} - when any parameter is empty
+ *
+ */
+function createPemCertOption(cert, key, passphrase, ca) {
+    if (cert.length === 0) {
+        throw new ErrorWithCode(formatString(ErrorMessage.EmptyParameter, "cert"), exports.ErrorCode.InvalidParameter);
+    }
+    if (key.length === 0) {
+        throw new ErrorWithCode(formatString(ErrorMessage.EmptyParameter, "key"), exports.ErrorCode.InvalidParameter);
+    }
+    return {
+        cert,
+        key,
+        passphrase,
+        ca,
+    };
+}
+/**
+ * Helper to create SecureContextOptions from PFX format cert
+ *
+ * @param { string | Buffer } pfx - The content of .pfx file
+ * @param { string? } passphrase - Optional. The passphrase of .pfx file
+ *
+ * @returns Instance of SecureContextOptions
+ *
+ * @throws {@link ErrorCode|InvalidParameter} - when any parameter is empty
+ *
+ */
+function createPfxCertOption(pfx, passphrase) {
+    if (pfx.length === 0) {
+        throw new ErrorWithCode(formatString(ErrorMessage.EmptyParameter, "pfx"), exports.ErrorCode.InvalidParameter);
+    }
+    return {
+        pfx,
+        passphrase,
+    };
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * A class providing credential and configuration.
@@ -1602,16 +1795,1039 @@ class TeamsFx {
     }
 }
 
+// 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["Unknown"] = 5] = "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);
+            switch (type) {
+                case ActivityType.CurrentBotMessaged:
+                    // Invoke corresponding command handler for the command response
+                    const commandText = this.getActivityText(context.activity);
+                    const message = {
+                        text: commandText,
+                    };
+                    for (const handler of this.commandHandlers) {
+                        const matchResult = this.shouldTrigger(handler.triggerPatterns, commandText);
+                        // It is important to note that the command bot will stop processing handlers
+                        // when the first command handler is matched.
+                        if (!!matchResult) {
+                            message.matches = Array.isArray(matchResult) ? matchResult : void 0;
+                            const response = yield handler.handleCommandReceived(context, message);
+                            yield context.sendActivity(response);
+                            break;
+                        }
+                    }
+                    break;
+            }
+            yield next();
+        });
+    }
+    classifyActivity(activity) {
+        if (activity.type === botbuilder.ActivityTypes.Message) {
+            return ActivityType.CurrentBotMessaged;
+        }
+        return ActivityType.Unknown;
+    }
+    matchPattern(pattern, text) {
+        if (text) {
+            if (typeof pattern === "string") {
+                const regExp = new RegExp(pattern, "i");
+                return regExp.test(text);
+            }
+            if (pattern instanceof RegExp) {
+                const matches = text.match(pattern);
+                return matches !== null && matches !== void 0 ? matches : false;
+            }
+        }
+        return false;
+    }
+    shouldTrigger(patterns, text) {
+        const expressions = Array.isArray(patterns) ? patterns : [patterns];
+        for (const ex of expressions) {
+            const arg = this.matchPattern(ex, text);
+            if (arg)
+                return arg;
+        }
+        return false;
+    }
+    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.
+/**
+ * A command bot for receiving commands and sending responses in Teams.
+ *
+ * @remarks
+ * Ensure each command should ONLY be registered with the command once, otherwise it'll cause unexpected behavior if you register the same command more than once.
+ *
+ * @beta
+ */
+class CommandBot {
+    /**
+     * Creates a new instance of the `CommandBot`.
+     *
+     * @param adapter The bound `BotFrameworkAdapter`.
+     * @param options - initialize options
+     *
+     * @beta
+     */
+    constructor(adapter, options) {
+        this.middleware = new CommandResponseMiddleware(options === null || options === void 0 ? void 0 : options.commands);
+        this.adapter = adapter.use(this.middleware);
+    }
+    /**
+     * Registers a command into the command bot.
+     *
+     * @param command The command to registered.
+     *
+     * @beta
+     */
+    registerCommand(command) {
+        if (command) {
+            this.middleware.commandHandlers.push(command);
+        }
+    }
+    /**
+     * Registers commands into the command bot.
+     *
+     * @param commands The command to registered.
+     *
+     * @beta
+     */
+    registerCommands(commands) {
+        if (commands) {
+            this.middleware.commandHandlers.push(...commands);
+        }
+    }
+}
+
+// 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.
+// 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* () {
+            const members = [];
+            yield this.adapter.continueConversation(this.conversationReference, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+                let continuationToken;
+                do {
+                    const pagedMembers = yield botbuilder.TeamsInfo.getPagedMembers(context, undefined, continuationToken);
+                    continuationToken = pagedMembers.continuationToken;
+                    for (const member of pagedMembers.members) {
+                        members.push(new Member(this, member));
+                    }
+                } while (continuationToken !== undefined);
+            }));
+            return members;
+        });
+    }
+}
+/**
+ * Provide utilities to send notification to varies targets (e.g., member, group, channel).
+ *
+ * @beta
+ */
+class NotificationBot {
+    /**
+     * constructor of the notification bot.
+     *
+     * @remarks
+     * To ensure accuracy, it's recommended to initialize before handling any message.
+     *
+     * @param adapter - the bound `BotFrameworkAdapter`
+     * @param options - initialize options
+     *
+     * @beta
+     */
+    constructor(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 : "./" : "./"));
+        this.conversationReferenceStore = new ConversationReferenceStore(storage);
+        this.adapter = adapter.use(new NotificationMiddleware({
+            conversationReferenceStore: this.conversationReferenceStore,
+        }));
+    }
+    /**
+     * Get all targets where the bot is installed.
+     *
+     * @remarks
+     * The result is retrieving from the persisted storage.
+     *
+     * @returns - an array of {@link TeamsBotInstallation}.
+     *
+     * @beta
+     */
+    installations() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.conversationReferenceStore === undefined || this.adapter === undefined) {
+                throw new Error("NotificationBot has not been initialized.");
+            }
+            const references = (yield this.conversationReferenceStore.getAll()).values();
+            const targets = [];
+            for (const reference of references) {
+                // validate connection
+                let valid = true;
+                this.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(this.adapter, reference));
+                }
+                else {
+                    this.conversationReferenceStore.delete(reference);
+                }
+            }
+            return targets;
+        });
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Provide utilities for bot conversation, including:
+ *   - handle command and response.
+ *   - send notification to varies targets (e.g., member, group, channel).
+ *
+ * @example
+ * For command and response, you can register your commands through the constructor, or use the `registerCommand` and `registerCommands` API to add commands later.
+ *
+ * ```typescript
+ * // register through constructor
+ * const conversationBot = new ConversationBot({
+ *   command: {
+ *     enabled: true,
+ *     commands: [ new HelloWorldCommandHandler() ],
+ *   },
+ * });
+ *
+ * // register through `register*` API
+ * conversationBot.command.registerCommand(new HelpCommandHandler());
+ * ```
+ *
+ * For notification, you can enable notification at initialization, then send notifications at any time.
+ *
+ * ```typescript
+ * // enable through constructor
+ * const conversationBot = new ConversationBot({
+ *   notification: {
+ *     enabled: true,
+ *   },
+ * });
+ *
+ * // get all bot installations and send message
+ * for (const target of await conversationBot.notification.installations()) {
+ *   await target.sendMessage("Hello Notification");
+ * }
+ *
+ * // alternative - send message to all members
+ * for (const target of await conversationBot.notification.installations()) {
+ *   for (const member of await target.members()) {
+ *     await member.sendMessage("Hello Notification");
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * Set `adapter` in {@link ConversationOptions} to use your own bot adapter.
+ *
+ * For command and response, ensure each command should ONLY be registered with the command once, otherwise it'll cause unexpected behavior if you register the same command more than once.
+ *
+ * For notification, set `notification.storage` in {@link ConversationOptions} to use your own storage implementation.
+ *
+ * @beta
+ */
+class ConversationBot {
+    /**
+     * Creates new instance of the `ConversationBot`.
+     *
+     * @remarks
+     * It's recommended to create your own adapter and storage for production environment instead of the default one.
+     *
+     * @param options - initialize options
+     *
+     * @beta
+     */
+    constructor(options) {
+        var _a, _b;
+        if (options.adapter) {
+            this.adapter = options.adapter;
+        }
+        else {
+            this.adapter = this.createDefaultAdapter(options.adapterConfig);
+        }
+        if ((_a = options.command) === null || _a === void 0 ? void 0 : _a.enabled) {
+            this.command = new CommandBot(this.adapter, options.command);
+        }
+        if ((_b = options.notification) === null || _b === void 0 ? void 0 : _b.enabled) {
+            this.notification = new NotificationBot(this.adapter, options.notification);
+        }
+    }
+    createDefaultAdapter(adapterConfig) {
+        const adapter = adapterConfig === undefined
+            ? new botbuilder.BotFrameworkAdapter({
+                appId: process.env.BOT_ID,
+                appPassword: process.env.BOT_PASSWORD,
+            })
+            : new botbuilder.BotFrameworkAdapter(adapterConfig);
+        // the default error handler
+        adapter.onTurnError = (context, error) => tslib.__awaiter(this, void 0, void 0, function* () {
+            // This check writes out errors to console.
+            console.error(`[onTurnError] unhandled error: ${error}`);
+            // Send a trace activity, which will be displayed in Bot Framework Emulator
+            yield context.sendTraceActivity("OnTurnError Trace", `${error}`, "https://www.botframework.com/schemas/error", "TurnError");
+            // Send a message to the user
+            yield context.sendActivity(`The bot encountered unhandled error: ${error.message}`);
+            yield context.sendActivity("To continue to run this bot, please fix the bot source code.");
+        });
+        return adapter;
+    }
+    /**
+     * The request handler to integrate with web request.
+     *
+     * @param req - an Express or Restify style request object.
+     * @param res - an Express or Restify style response object.
+     * @param logic - the additional function to handle bot context.
+     *
+     * @example
+     * For example, to use with Restify:
+     * ``` typescript
+     * // The default/empty behavior
+     * server.post("api/messages", conversationBot.requestHandler);
+     *
+     * // Or, add your own logic
+     * server.post("api/messages", async (req, res) => {
+     *   await conversationBot.requestHandler(req, res, async (context) => {
+     *     // your-own-context-logic
+     *   });
+     * });
+     * ```
+     *
+     * @beta
+     */
+    requestHandler(req, res, logic) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (logic === undefined) {
+                // create empty logic
+                logic = () => tslib.__awaiter(this, void 0, void 0, function* () { });
+            }
+            yield this.adapter.processActivity(req, res, logic);
+        });
+    }
+}
+
+// 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.BearerTokenAuthProvider = BearerTokenAuthProvider;
+exports.CertificateAuthProvider = CertificateAuthProvider;
+exports.Channel = Channel;
+exports.CommandBot = CommandBot;
+exports.ConversationBot = ConversationBot;
 exports.ErrorWithCode = ErrorWithCode;
+exports.Member = Member;
+exports.MessageBuilder = MessageBuilder;
 exports.MsGraphAuthProvider = MsGraphAuthProvider;
+exports.NotificationBot = NotificationBot;
 exports.OnBehalfOfUserCredential = OnBehalfOfUserCredential;
+exports.TeamsBotInstallation = TeamsBotInstallation;
 exports.TeamsBotSsoPrompt = TeamsBotSsoPrompt;
 exports.TeamsFx = TeamsFx;
 exports.TeamsUserCredential = TeamsUserCredential;
+exports.createApiClient = createApiClient;
 exports.createMicrosoftGraphClient = createMicrosoftGraphClient;
+exports.createPemCertOption = createPemCertOption;
+exports.createPfxCertOption = createPfxCertOption;
 exports.getLogLevel = getLogLevel;
 exports.getTediousConnectionConfig = getTediousConnectionConfig;
+exports.sendAdaptiveCard = sendAdaptiveCard;
+exports.sendMessage = sendMessage;
 exports.setLogFunction = setLogFunction;
 exports.setLogLevel = setLogLevel;
 exports.setLogger = setLogger;