@microsoft/teamsfx 0.6.2 → 0.6.3-alpha.26aa11b7c.0

package/dist/index.esm2017.mjs

@@ -3,9 +3,13 @@ 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, BotFrameworkAdapter } from 'botbuilder';
 import { Dialog } from 'botbuilder-dialogs';
 import { v4 } from 'uuid';
+import axios from 'axios';
+import { Agent } from 'https';
+import * as path from 'path';
+import * as fs from 'fs';
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -88,6 +92,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.
  *
@@ -1385,6 +1392,166 @@ class TeamsBotSsoPrompt extends 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.create({
+        baseURL: apiEndpoint,
+    });
+    instance.interceptors.request.use(async function (config) {
+        return await authProvider.AddAuthenticationInfo(config);
+    });
+    return instance;
+}
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * 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
+     */
+    async AddAuthenticationInfo(config) {
+        const token = await 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"), 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
+     */
+    async AddAuthenticationInfo(config) {
+        if (!config.httpsAgent) {
+            config.httpsAgent = new 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), 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"), ErrorCode.InvalidParameter);
+    }
+    if (key.length === 0) {
+        throw new ErrorWithCode(formatString(ErrorMessage.EmptyParameter, "key"), 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"), ErrorCode.InvalidParameter);
+    }
+    return {
+        pfx,
+        passphrase,
+    };
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * A class providing credential and configuration.
@@ -1567,5 +1734,982 @@ class TeamsFx {
     }
 }
 
-export { AppCredential, ErrorCode, ErrorWithCode, IdentityType, LogLevel, MsGraphAuthProvider, OnBehalfOfUserCredential, TeamsBotSsoPrompt, TeamsFx, TeamsUserCredential, createMicrosoftGraphClient, getLogLevel, getTediousConnectionConfig, setLogFunction, setLogLevel, setLogger };
+// 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;
+    }
+    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);
+        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 = await handler.handleCommandReceived(context, message);
+                        await context.sendActivity(response);
+                        break;
+                    }
+                }
+                break;
+        }
+        await next();
+    }
+    classifyActivity(activity) {
+        if (activity.type === 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 = 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.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.
+// 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() {
+        const members = [];
+        await this.adapter.continueConversation(this.conversationReference, async (context) => {
+            let continuationToken;
+            do {
+                const pagedMembers = await 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.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
+     */
+    async installations() {
+        if (this.conversationReferenceStore === undefined || this.adapter === undefined) {
+            throw new Error("NotificationBot has not been initialized.");
+        }
+        const references = (await this.conversationReferenceStore.getAll()).values();
+        const targets = [];
+        for (const reference of references) {
+            // validate connection
+            let valid = true;
+            this.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(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 BotFrameworkAdapter({
+                appId: process.env.BOT_ID,
+                appPassword: process.env.BOT_PASSWORD,
+            })
+            : new BotFrameworkAdapter(adapterConfig);
+        // the default error handler
+        adapter.onTurnError = async (context, error) => {
+            // 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
+            await context.sendTraceActivity("OnTurnError Trace", `${error}`, "https://www.botframework.com/schemas/error", "TurnError");
+            // Send a message to the user
+            await context.sendActivity(`The bot encountered unhandled error: ${error.message}`);
+            await 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
+     */
+    async requestHandler(req, res, logic) {
+        if (logic === undefined) {
+            // create empty logic
+            logic = async () => { };
+        }
+        await 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: [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, BearerTokenAuthProvider, CertificateAuthProvider, Channel, CommandBot, ConversationBot, ErrorCode, ErrorWithCode, IdentityType, LogLevel, Member, MessageBuilder, MsGraphAuthProvider, NotificationBot, OnBehalfOfUserCredential, TeamsBotInstallation, TeamsBotSsoPrompt, TeamsFx, TeamsUserCredential, createApiClient, createMicrosoftGraphClient, createPemCertOption, createPfxCertOption, getLogLevel, getTediousConnectionConfig, sendAdaptiveCard, sendMessage, setLogFunction, setLogLevel, setLogger };
 //# sourceMappingURL=index.esm2017.mjs.map