@oneuptime/common 8.0.5237 → 8.0.5283

package/build/dist/Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams.js

@@ -8,15 +8,238 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import HTTPErrorResponse from "../../../../Types/API/HTTPErrorResponse";
+import URL from "../../../../Types/API/URL";
 import API from "../../../../Utils/API";
 import logger from "../../Logger";
 import WorkspaceBase from "../WorkspaceBase";
+import WorkspaceType from "../../../../Types/Workspace/WorkspaceType";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
-export default class MicrosoftTeams extends WorkspaceBase {
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import WorkspaceProjectAuthTokenService from "../../../Services/WorkspaceProjectAuthTokenService";
+import OneUptimeDate from "../../../../Types/Date";
+import { MicrosoftTeamsAppClientId, MicrosoftTeamsAppClientSecret, } from "../../../EnvironmentConfig";
+// Import services for bot commands
+import IncidentService from "../../../Services/IncidentService";
+import AlertService from "../../../Services/AlertService";
+import ScheduledMaintenanceService from "../../../Services/ScheduledMaintenanceService";
+import IncidentStateService from "../../../Services/IncidentStateService";
+import AlertStateService from "../../../Services/AlertStateService";
+// Import database utilities
+import QueryHelper from "../../../Types/Database/QueryHelper";
+import SortOrder from "../../../../Types/BaseDatabase/SortOrder";
+// Microsoft Teams apps should always be single-tenant
+const MICROSOFT_TEAMS_APP_TYPE = "SingleTenant";
+// Bot Framework SDK imports
+import { CloudAdapter, ConfigurationBotFrameworkAuthentication, TeamsActivityHandler, MessageFactory, } from "botbuilder";
+// Teams action handlers and types
+import MicrosoftTeamsAuthAction from "./Actions/Auth";
+import MicrosoftTeamsIncidentActions from "./Actions/Incident";
+import MicrosoftTeamsAlertActions from "./Actions/Alert";
+import MicrosoftTeamsMonitorActions from "./Actions/Monitor";
+import MicrosoftTeamsScheduledMaintenanceActions from "./Actions/ScheduledMaintenance";
+import MicrosoftTeamsOnCallDutyActions from "./Actions/OnCallDutyPolicy";
+export default class MicrosoftTeamsUtil extends WorkspaceBase {
+    // Get or create Bot Framework adapter for a specific tenant
+    static getBotAdapter(microsoftAppTenantId) {
+        if (!MicrosoftTeamsAppClientId || !MicrosoftTeamsAppClientSecret) {
+            throw new BadDataException("Microsoft Teams App credentials not configured");
+        }
+        logger.debug("Creating Bot Framework adapter with authentication configuration");
+        logger.debug(`App ID: ${MicrosoftTeamsAppClientId}`);
+        logger.debug(`App Type: ${MICROSOFT_TEAMS_APP_TYPE}`);
+        logger.debug(`Tenant ID: ${microsoftAppTenantId}`);
+        const authConfig = {
+            MicrosoftAppId: MicrosoftTeamsAppClientId,
+            MicrosoftAppPassword: MicrosoftTeamsAppClientSecret,
+            MicrosoftAppType: MICROSOFT_TEAMS_APP_TYPE,
+            MicrosoftAppTenantId: microsoftAppTenantId,
+        };
+        const botFrameworkAuthentication = new ConfigurationBotFrameworkAuthentication(authConfig);
+        const adapter = new CloudAdapter(botFrameworkAuthentication);
+        logger.debug("Bot Framework adapter created successfully");
+        return adapter;
+    }
+    // Helper method to get a valid access token, refreshing if necessary
+    static async getValidAccessToken(data) {
+        var _a;
+        logger.debug("=== getValidAccessToken called ===");
+        logger.debug(`Project ID: ${data.projectId.toString()}`);
+        logger.debug(`Auth token (first 20 chars): ${(_a = data.authToken) === null || _a === void 0 ? void 0 : _a.substring(0, 20)}...`);
+        // Get project auth and check token expiration
+        const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+            projectId: data.projectId,
+            workspaceType: WorkspaceType.MicrosoftTeams,
+        });
+        logger.debug(`Project auth found: ${Boolean(projectAuth)}`);
+        if (projectAuth) {
+            logger.debug(`Project auth has miscData: ${Boolean(projectAuth.miscData)}`);
+        }
+        if (!projectAuth || !projectAuth.miscData) {
+            logger.error("Microsoft Teams integration not found for this project - no project auth or miscData");
+            throw new BadDataException("Microsoft Teams integration not found for this project");
+        }
+        const miscData = projectAuth.miscData;
+        logger.debug(`MiscData appAccessToken exists: ${Boolean(miscData.appAccessToken)}`);
+        logger.debug(`MiscData appAccessTokenExpiresAt: ${miscData.appAccessTokenExpiresAt}`);
+        // Check if token exists and is valid
+        if (miscData.appAccessToken && miscData.appAccessToken.includes(".")) {
+            logger.debug("Found app access token in miscData");
+            // Check if token is expired
+            if (miscData.appAccessTokenExpiresAt) {
+                const expiryDate = OneUptimeDate.fromString(miscData.appAccessTokenExpiresAt);
+                const now = OneUptimeDate.getCurrentDate();
+                const isExpired = OneUptimeDate.isAfter(now, expiryDate);
+                const secondsToExpiry = OneUptimeDate.getSecondsTo(expiryDate);
+                logger.debug(`Token expires in ${secondsToExpiry} seconds`);
+                logger.debug(`Token is expired: ${isExpired}`);
+                // If token is already expired or expires within the next 5 minutes, refresh it
+                if (isExpired || secondsToExpiry <= 300) {
+                    logger.debug("Access token is expired or expiring soon, attempting to refresh");
+                    const newToken = await this.refreshAccessToken({
+                        projectId: data.projectId,
+                        miscData,
+                    });
+                    if (newToken) {
+                        logger.debug("Successfully refreshed token");
+                        return newToken;
+                    }
+                    logger.warn("Failed to refresh token, falling back to cached token");
+                }
+                else {
+                    logger.debug("Using cached appAccessToken from miscData for Microsoft Graph API call");
+                    return miscData.appAccessToken;
+                }
+            }
+            else {
+                // No expiry information, use the token but it might be expired
+                logger.debug("Using appAccessToken from miscData (no expiry info available)");
+                return miscData.appAccessToken;
+            }
+        }
+        // If we couldn't find a valid token, try to refresh
+        logger.debug("No valid app access token found, attempting to refresh");
+        const newToken = await this.refreshAccessToken({
+            projectId: data.projectId,
+            miscData,
+        });
+        if (newToken) {
+            logger.debug("Successfully refreshed token");
+            return newToken;
+        }
+        // If refresh failed, throw error
+        logger.error("Could not obtain valid access token for Microsoft Teams");
+        throw new BadDataException("Could not obtain valid access token for Microsoft Teams");
+    }
+    // Method to refresh the Microsoft Teams access token
+    static async refreshAccessToken(data) {
+        logger.debug("=== refreshAccessToken called ===");
+        logger.debug(`Project ID: ${data.projectId.toString()}`);
+        logger.debug(`Tenant ID: ${data.miscData.tenantId}`);
+        try {
+            // Check if we have the necessary client credentials
+            if (!MicrosoftTeamsAppClientId || !MicrosoftTeamsAppClientSecret) {
+                logger.error("Microsoft Teams app client credentials are not configured");
+                logger.error("Please set MICROSOFT_TEAMS_APP_CLIENT_ID and MICROSOFT_TEAMS_APP_CLIENT_SECRET environment variables");
+                return null;
+            }
+            logger.debug("Client credentials are configured");
+            if (!data.miscData.tenantId) {
+                logger.error("Tenant ID not found in miscData, cannot refresh token");
+                return null;
+            }
+            logger.debug(`Attempting to refresh Microsoft Teams access token for project ${data.projectId.toString()}`);
+            logger.debug(`Using tenant ID: ${data.miscData.tenantId}`);
+            // Use OAuth 2.0 client credentials flow to get a new app access token
+            const tokenUrl = `https://login.microsoftonline.com/${data.miscData.tenantId}/oauth2/v2.0/token`;
+            logger.debug(`Token URL: ${tokenUrl}`);
+            const tokenRequestBody = {
+                client_id: MicrosoftTeamsAppClientId,
+                client_secret: MicrosoftTeamsAppClientSecret,
+                grant_type: "client_credentials",
+                scope: "https://graph.microsoft.com/.default",
+            };
+            logger.debug("Making token refresh request to Microsoft");
+            const response = await API.post({
+                url: URL.fromString(tokenUrl),
+                data: tokenRequestBody,
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    Accept: "application/json",
+                },
+            });
+            if (response instanceof HTTPErrorResponse) {
+                logger.error("Error refreshing Microsoft Teams access token:");
+                logger.error(response);
+                return null;
+            }
+            logger.debug("Token refresh response received successfully");
+            const tokenData = response.data;
+            const newAccessToken = tokenData["access_token"];
+            const expiresIn = tokenData["expires_in"]; // seconds
+            logger.debug(`New access token received: ${Boolean(newAccessToken)}`);
+            logger.debug(`Token expires in: ${expiresIn} seconds`);
+            if (!newAccessToken) {
+                logger.error("No access token received in token refresh response");
+                return null;
+            }
+            // Calculate expiry time
+            const now = OneUptimeDate.getCurrentDate();
+            const expiryDate = OneUptimeDate.addRemoveSeconds(now, expiresIn - 300); // Subtrutes buffer
+            logger.debug(`Token expiry calculated: ${OneUptimeDate.toString(expiryDate)}`);
+            // Update the miscData with new token and expiry
+            const updatedMiscData = Object.assign(Object.assign({}, data.miscData), { appAccessToken: newAccessToken, appAccessTokenExpiresAt: OneUptimeDate.toString(expiryDate), lastAppTokenIssuedAt: OneUptimeDate.toString(now) });
+            logger.debug("Saving updated token to database");
+            // Save the updated token to the database
+            await WorkspaceProjectAuthTokenService.refreshAuthToken({
+                projectId: data.projectId,
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                authToken: newAccessToken,
+                workspaceProjectId: data.miscData.tenantId,
+                miscData: updatedMiscData,
+            });
+            logger.debug("Microsoft Teams access token refreshed successfully");
+            logger.debug(`New token expires at: ${updatedMiscData.appAccessTokenExpiresAt}`);
+            return newAccessToken;
+        }
+        catch (error) {
+            logger.error("Error refreshing Microsoft Teams access token:");
+            logger.error(error);
+            return null;
+        }
+    }
+    // Extract action type and value from Teams Adaptive Card submit value
+    static extractActionFromValue(value) {
+        /*
+         * Support multiple shapes that Teams may send for Adaptive Card submits
+         * 1) { action: "ack-incident", actionValue: "<id>" }
+         * 2) { data: { action: "ack-incident", actionValue: "<id>" } }
+         * 3) { action: { type: "Action.Submit", data: { action: "ack-incident", actionValue: "<id>" } } }
+         */
+        let actionType = value["action"] || "";
+        let actionValue = value["actionValue"] || "";
+        const valData = value["data"] || undefined;
+        if ((!actionType || !actionValue) && valData) {
+            actionType = valData["action"] || actionType;
+            actionValue = valData["actionValue"] || actionValue;
+        }
+        const actionObj = value["action"];
+        if ((!actionType || !actionValue) &&
+            actionObj &&
+            typeof actionObj === "object") {
+            const embeddedData = actionObj["data"] || undefined;
+            if (embeddedData) {
+                actionType = embeddedData["action"] || actionType;
+                actionValue = embeddedData["actionValue"] || actionValue;
+            }
+        }
+        return { actionType: actionType, actionValue };
+    }
     static buildMessageCardFromMarkdown(markdown) {
         var _a, _b, _c, _d, _e;
-        // Teams MessageCard has limited markdown support. Headings like '##' are not supported
-        // and single newlines can collapse. Convert common patterns to a structured card.
+        /*
+         * Teams MessageCard has limited markdown support. Headings like '##' are not supported
+         * and single newlines can collapse. Convert common patterns to a structured card.
+         */
         const lines = markdown
             .split("\n")
             .map((l) => {
@@ -36,11 +259,29 @@ export default class MicrosoftTeams extends WorkspaceBase {
                 .replace(/^#+\s*/, "") // remove leading markdown headers like ##
                 .replace(/^\*\*|\*\*$/g, "") // remove stray bold markers if any
                 .trim();
+            // Remove markdown link syntax from title for cleaner rendering
+            const titleLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+            title = title.replace(titleLinkRegex, "$1");
+            // Sanitize unmatched bold markers if any remain
+            const boldCountTitle = (title.match(/\*\*/g) || []).length;
+            if (boldCountTitle % 2 !== 0) {
+                title = title.replace(/\*\*/g, "");
+            }
             lines.shift();
         }
         const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g; // [text](url)
+        // Helper to clean up unmatched bold markers that can break rendering
+        const sanitizeMarkdownText = (text) => {
+            const boldCount = (text.match(/\*\*/g) || []).length;
+            // If we have an odd number of **, remove them all to avoid raw markers showing
+            if (boldCount % 2 !== 0) {
+                text = text.replace(/\*\*/g, "");
+            }
+            // Collapse multiple spaces introduced by replacements
+            return text.replace(/\s{2,}/g, " ");
+        };
         for (const line of lines) {
-            // Extract links to actions and strip them from text
+            // Extract links to actions and keep link display text in-place (without markdown)
             let lineWithoutLinks = line;
             let match = null;
             while ((match = linkRegex.exec(line))) {
@@ -56,7 +297,8 @@ export default class MicrosoftTeams extends WorkspaceBase {
                         },
                     ],
                 });
-                lineWithoutLinks = lineWithoutLinks.replace(match[0], "").trim();
+                // Replace markdown link with just the display text to preserve sentence flow
+                lineWithoutLinks = lineWithoutLinks.replace(match[0], name).trim();
             }
             // Parse facts of the form **Label:** value
             const factMatch = new RegExp("\\*\\*(.*?):\\*\\*\\s*(.*)").exec(lineWithoutLinks);
@@ -72,7 +314,7 @@ export default class MicrosoftTeams extends WorkspaceBase {
                 }
             }
             else if (lineWithoutLinks) {
-                bodyTextParts.push(lineWithoutLinks);
+                bodyTextParts.push(sanitizeMarkdownText(lineWithoutLinks));
             }
         }
         const payload = {
@@ -81,15 +323,16 @@ export default class MicrosoftTeams extends WorkspaceBase {
             title: title,
             summary: title,
         };
+        // Build a single section so we can enable markdown explicitly
+        const section = { markdown: true };
         if (bodyTextParts.length > 0) {
-            payload["text"] = bodyTextParts.join("\n\n");
+            section["text"] = bodyTextParts.join("\n\n");
         }
         if (facts.length > 0) {
-            payload["sections"] = [
-                {
-                    facts: facts,
-                },
-            ];
+            section["facts"] = facts;
+        }
+        if (section["text"] || section["facts"]) {
+            payload["sections"] = [section];
         }
         if (actions.length > 0) {
             payload["potentialAction"] = actions;
@@ -124,11 +367,1737 @@ export default class MicrosoftTeams extends WorkspaceBase {
         return (urlString.includes("outlook.office.com") ||
             urlString.includes("office.com"));
     }
+    static async getUsernameFromUserId(data) {
+        logger.debug("Getting username from user ID with data:");
+        logger.debug(data);
+        // Get valid access token
+        const accessToken = await this.getValidAccessToken({
+            authToken: data.authToken,
+            projectId: data.projectId,
+        });
+        const response = await API.get({
+            url: URL.fromString(`https://graph.microsoft.com/v1.0/users/${data.userId}`),
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        logger.debug("Response from Microsoft Graph API for getting user info:");
+        logger.debug(response);
+        if (response instanceof HTTPErrorResponse) {
+            logger.error("Error response from Microsoft Graph API:");
+            logger.error(response);
+            throw response;
+        }
+        const userData = response.data;
+        const username = userData["displayName"] ||
+            userData["userPrincipalName"];
+        logger.debug("Username obtained:");
+        logger.debug(username);
+        return username;
+    }
+    static async sendDirectMessageToUser(data) {
+        // Send direct message to user via Microsoft Graph API
+        const adaptiveCard = this.buildAdaptiveCardFromMessageBlocks({
+            messageBlocks: data.messageBlocks,
+        });
+        const chatMessage = {
+            body: {
+                contentType: "html",
+                content: this.convertAdaptiveCardToHtml(adaptiveCard),
+            },
+            attachments: [
+                {
+                    contentType: "application/vnd.microsoft.card.adaptive",
+                    content: adaptiveCard,
+                },
+            ],
+        };
+        await API.post({
+            url: URL.fromString(`https://graph.microsoft.com/v1.0/chats/${data.workspaceUserId}/messages`),
+            data: chatMessage,
+            headers: {
+                Authorization: `Bearer ${data.authToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+    }
+    static async createChannelsIfDoesNotExist(data) {
+        logger.debug("Creating channels if they do not exist with data:");
+        logger.debug(data);
+        const workspaceChannels = [];
+        for (let channelName of data.channelNames) {
+            // Normalize channel name - Teams has different naming requirements
+            if (channelName && channelName.startsWith("#")) {
+                channelName = channelName.substring(1);
+            }
+            // Teams channels cannot have spaces in the name for some operations
+            const normalizedChannelName = channelName.replace(/\s+/g, "-");
+            // Check if channel exists
+            const existingChannel = await this.getWorkspaceChannelByName({
+                authToken: data.authToken,
+                channelName: normalizedChannelName,
+                projectId: data.projectId,
+                teamId: data.teamId,
+            });
+            if (existingChannel) {
+                logger.debug(`Channel ${channelName} already exists.`);
+                workspaceChannels.push(existingChannel);
+                continue;
+            }
+            logger.debug(`Channel ${channelName} does not exist. Creating channel.`);
+            const createChannelData = {
+                authToken: data.authToken,
+                channelName: normalizedChannelName,
+                projectId: data.projectId,
+                teamId: data.teamId,
+            };
+            const channel = await this.createChannel(createChannelData);
+            if (channel) {
+                logger.debug(`Channel ${channelName} created successfully.`);
+                workspaceChannels.push(channel);
+            }
+        }
+        logger.debug("Channels created or found:");
+        logger.debug(workspaceChannels);
+        return workspaceChannels;
+    }
+    static async createChannel(data) {
+        const teamId = data.teamId;
+        // Get valid access token
+        const accessToken = await this.getValidAccessToken({
+            authToken: data.authToken,
+            projectId: data.projectId,
+        });
+        const channelPayload = {
+            displayName: data.channelName,
+            description: `OneUptime notifications for ${data.channelName}`,
+            membershipType: "standard",
+        };
+        logger.debug("Creating Teams channel with payload:");
+        logger.debug(channelPayload);
+        const response = await API.post({
+            url: URL.fromString(`https://graph.microsoft.com/v1.0/teams/${teamId}/channels`),
+            data: channelPayload,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (response instanceof HTTPErrorResponse) {
+            logger.error("Error response from Microsoft Graph API:");
+            logger.error(response);
+            throw response;
+        }
+        const channelData = response.data;
+        const channel = {
+            id: channelData["id"],
+            name: channelData["displayName"],
+            workspaceType: WorkspaceType.MicrosoftTeams,
+            teamId: data.teamId,
+        };
+        logger.debug("Channel created successfully:");
+        logger.debug(channel);
+        return channel;
+    }
+    static async getWorkspaceChannelFromChannelName(data) {
+        const channel = await this.getWorkspaceChannelByName({
+            authToken: data.authToken,
+            channelName: data.channelName,
+            projectId: data.projectId,
+            teamId: data.teamId,
+        });
+        if (!channel) {
+            throw new BadDataException("Channel not found.");
+        }
+        return channel;
+    }
+    static async getWorkspaceChannelByName(data) {
+        logger.debug(`Getting workspace channel by name: ${data.channelName}`);
+        // Get project auth to get available teams
+        const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+            projectId: data.projectId,
+            workspaceType: WorkspaceType.MicrosoftTeams,
+        });
+        if (!(projectAuth === null || projectAuth === void 0 ? void 0 : projectAuth.miscData)) {
+            logger.error("Microsoft Teams integration not found for this project");
+            throw new BadDataException("Microsoft Teams integration not found for this project");
+        }
+        // Get valid access token
+        const accessToken = await this.getValidAccessToken({
+            authToken: data.authToken,
+            projectId: data.projectId,
+        });
+        // Get channels for this team
+        const response = await API.get({
+            url: URL.fromString(`https://graph.microsoft.com/v1.0/teams/${data.teamId}/channels`),
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (response instanceof HTTPErrorResponse) {
+            logger.error("Error response from Microsoft Graph API:");
+            logger.error(response);
+            throw response;
+        }
+        const channelsData = response.data;
+        const channels = channelsData["value"] || [];
+        logger.debug(`Found ${channels.length} channels from API`);
+        const channelName = data.channelName.toLowerCase();
+        for (const channelData of channels) {
+            const displayName = channelData["displayName"];
+            if (!displayName) {
+                continue;
+            }
+            const apiChannelName = displayName.toLowerCase();
+            logger.debug(`Comparing channel '${apiChannelName}' with requested '${channelName}'`);
+            if (apiChannelName === channelName) {
+                const foundChannel = {
+                    id: `${channelData["id"]}`,
+                    name: displayName,
+                    workspaceType: WorkspaceType.MicrosoftTeams,
+                    teamId: data.teamId,
+                };
+                logger.debug(`Channel match found: ${JSON.stringify(foundChannel)}`);
+                return foundChannel;
+            }
+        }
+        logger.debug(`No channel found with name: ${data.channelName}`);
+        return null;
+    }
+    static async sendMessage(data) {
+        logger.debug("=== MicrosoftTeamsUtil.sendMessage called ===");
+        logger.debug("Sending message to Microsoft Teams with data:");
+        logger.debug(data);
+        const adaptiveCard = this.buildAdaptiveCardFromMessageBlocks({
+            messageBlocks: data.workspaceMessagePayload.messageBlocks,
+        });
+        logger.debug("Adaptive card built successfully:");
+        logger.debug(JSON.stringify(adaptiveCard, null, 2));
+        const workspaceChannelsToPostTo = [];
+        logger.debug(`Processing ${data.workspaceMessagePayload.channelNames.length} channel names`);
+        logger.debug(`Channel names: ${JSON.stringify(data.workspaceMessagePayload.channelNames)}`);
+        // Resolve channel names
+        for (const channelName of data.workspaceMessagePayload.channelNames) {
+            logger.debug(`Attempting to resolve channel name: ${channelName}`);
+            if (!data.workspaceMessagePayload.teamId) {
+                throw new BadDataException("Team ID is required to resolve channel names.");
+            }
+            const channel = await this.getWorkspaceChannelByName({
+                authToken: data.authToken,
+                channelName: channelName,
+                projectId: data.projectId,
+                teamId: data.workspaceMessagePayload.teamId,
+            });
+            if (channel) {
+                logger.debug(`Channel resolved successfully: ${JSON.stringify(channel)}`);
+                workspaceChannelsToPostTo.push(channel);
+            }
+            else {
+                logger.warn(`Channel not found: ${channelName}`);
+            }
+        }
+        logger.debug("=== Starting message sending loop ===");
+        logger.debug(`Total channels to post to: ${workspaceChannelsToPostTo.length}`);
+        logger.debug(`Channels: ${JSON.stringify(workspaceChannelsToPostTo)}`);
+        // Add channels by ID
+        for (const channelId of data.workspaceMessagePayload.channelIds) {
+            if (!data.workspaceMessagePayload.teamId) {
+                throw new BadDataException("Team ID is required to resolve channel IDs.");
+            }
+            try {
+                logger.debug(`Getting channel info for channel ID: ${channelId}`);
+                const channel = await this.getWorkspaceChannelFromChannelId({
+                    authToken: data.authToken,
+                    channelId: channelId,
+                    projectId: data.projectId,
+                    teamId: data.workspaceMessagePayload.teamId,
+                });
+                logger.debug(`Channel info obtained: ${JSON.stringify(channel)}`);
+                workspaceChannelsToPostTo.push(channel);
+            }
+            catch (err) {
+                logger.error(`Error getting channel info for channel ID ${channelId}:`);
+                logger.error(err);
+            }
+        }
+        logger.debug("=== Starting message sending loop ===");
+        logger.debug(`Total channels to post to: ${workspaceChannelsToPostTo.length}`);
+        logger.debug(`Channels: ${JSON.stringify(workspaceChannelsToPostTo)}`);
+        const workspaceMessageResponse = {
+            threads: [],
+            workspaceType: WorkspaceType.MicrosoftTeams,
+            errors: [],
+        };
+        for (const channel of workspaceChannelsToPostTo) {
+            try {
+                logger.debug(`Attempting to send message to channel: ${JSON.stringify(channel)}`);
+                if (!data.workspaceMessagePayload.teamId) {
+                    throw new BadDataException("Team ID is required to send messages to channels.");
+                }
+                const thread = await this.sendAdaptiveCardToChannel({
+                    authToken: data.authToken,
+                    teamId: data.workspaceMessagePayload.teamId,
+                    workspaceChannel: channel,
+                    adaptiveCard: adaptiveCard,
+                    projectId: data.projectId,
+                });
+                logger.debug(`Message sent successfully to channel ${channel.name}, thread: ${JSON.stringify(thread)}`);
+                workspaceMessageResponse.threads.push(thread);
+            }
+            catch (e) {
+                logger.error(`Error sending message to channel ID ${channel.id}:`);
+                logger.error(e);
+                workspaceMessageResponse.errors.push({
+                    channel: channel,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        logger.debug("=== Message sending completed ===");
+        logger.debug(`Final thread count: ${workspaceMessageResponse.threads.length}`);
+        logger.debug(`Final response: ${JSON.stringify(workspaceMessageResponse)}`);
+        return workspaceMessageResponse;
+    }
+    static async sendAdaptiveCardToChannel(data) {
+        logger.debug(`Sending adaptive card to channel via Bot Framework: ${data.workspaceChannel.name} (${data.workspaceChannel.id})`);
+        logger.debug(`Team ID: ${data.teamId}`);
+        logger.debug(`Adaptive card: ${JSON.stringify(data.adaptiveCard)}`);
+        try {
+            // Get project auth to retrieve bot ID
+            const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+                projectId: data.projectId,
+                workspaceType: WorkspaceType.MicrosoftTeams,
+            });
+            if (!projectAuth || !projectAuth.miscData) {
+                throw new BadDataException("Microsoft Teams integration not found for this project");
+            }
+            const miscData = projectAuth.miscData;
+            if (!miscData.botId) {
+                throw new BadDataException("Bot ID not found in Microsoft Teams integration");
+            }
+            // Check if app client ID is configured
+            if (!MicrosoftTeamsAppClientId) {
+                throw new BadDataException("Microsoft Teams App Client ID not configured");
+            }
+            logger.debug(`Using bot ID: ${miscData.botId}`);
+            // Get Bot Framework adapter
+            const adapter = this.getBotAdapter(miscData.tenantId);
+            // Create conversation reference for the channel
+            const conversationReference = {
+                bot: {
+                    id: MicrosoftTeamsAppClientId,
+                    name: "OneUptime Bot",
+                },
+                conversation: {
+                    id: data.workspaceChannel.id,
+                    name: data.workspaceChannel.name,
+                    isGroup: true,
+                    conversationType: "channel",
+                    tenantId: miscData.tenantId,
+                },
+                channelId: "msteams",
+                serviceUrl: "https://smba.trafficmanager.net/teams/",
+            };
+            logger.debug(`Conversation reference: ${JSON.stringify(conversationReference)}`);
+            // Send proactive message using Bot Framework
+            let messageId = "";
+            await adapter.continueConversationAsync(MicrosoftTeamsAppClientId, conversationReference, async (context) => {
+                logger.debug("Sending adaptive card as proactive message");
+                // Create message with adaptive card attachment
+                const message = MessageFactory.attachment({
+                    contentType: "application/vnd.microsoft.card.adaptive",
+                    content: data.adaptiveCard,
+                });
+                const response = await context.sendActivity(message);
+                messageId = (response === null || response === void 0 ? void 0 : response.id) || "";
+                logger.debug(`Message sent with ID: ${messageId}`);
+            });
+            const thread = {
+                channel: data.workspaceChannel,
+                threadId: messageId,
+            };
+            logger.debug(`Created thread via Bot Framework: ${JSON.stringify(thread)}`);
+            return thread;
+        }
+        catch (error) {
+            logger.error("Error sending adaptive card via Bot Framework:");
+            logger.error(error);
+            throw error;
+        }
+    }
+    static async getWorkspaceChannelFromChannelId(data) {
+        logger.debug("=== getWorkspaceChannelFromChannelId called ===");
+        logger.debug(`Channel ID: ${data.channelId}`);
+        logger.debug(`Team ID: ${data.teamId}`);
+        logger.debug(`Project ID: ${data.projectId.toString()}`);
+        try {
+            // Get valid access token
+            const accessToken = await this.getValidAccessToken({
+                authToken: data.authToken,
+                projectId: data.projectId,
+            });
+            logger.debug("Access token obtained for channel info retrieval");
+            // Fetch channel information from Microsoft Graph API
+            const apiUrl = `https://graph.microsoft.com/v1.0/teams/${data.teamId}/channels/${data.channelId}`;
+            logger.debug(`Making API call to: ${apiUrl}`);
+            const response = await API.get({
+                url: URL.fromString(apiUrl),
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (response instanceof HTTPErrorResponse) {
+                logger.error("Error getting channel info from Microsoft Graph API:");
+                logger.error(response);
+                // Fall back to basic channel object
+                logger.debug("Falling back to basic channel object");
+                return {
+                    id: data.channelId,
+                    name: data.channelId,
+                    workspaceType: WorkspaceType.MicrosoftTeams,
+                    teamId: data.teamId,
+                };
+            }
+            logger.debug("Channel info API call successful");
+            const channelData = response.data;
+            const channel = {
+                id: data.channelId,
+                name: channelData["displayName"],
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                teamId: data.teamId,
+            };
+            logger.debug(`Channel info retrieved: ${JSON.stringify(channel)}`);
+            return channel;
+        }
+        catch (error) {
+            logger.error("Error fetching channel information:");
+            logger.error(error);
+            throw error;
+        }
+    }
+    static buildAdaptiveCardFromMessageBlocks(data) {
+        logger.debug("=== buildAdaptiveCardFromMessageBlocks called ===");
+        logger.debug(`Number of message blocks: ${data.messageBlocks.length}`);
+        const card = {
+            type: "AdaptiveCard",
+            $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+            version: "1.5",
+            body: [],
+            actions: [],
+        };
+        const body = [];
+        const actions = [];
+        for (const block of data.messageBlocks) {
+            logger.debug(`Processing message block of type: ${block._type}`);
+            if (block._type === "WorkspacePayloadMarkdown") {
+                const markdownBlock = block;
+                logger.debug(`Markdown text: ${markdownBlock.text}`);
+                const markdownObj = this.getMarkdownBlock({
+                    payloadMarkdownBlock: markdownBlock,
+                });
+                body.push(markdownObj);
+            }
+            else if (block._type === "WorkspacePayloadHeader") {
+                const headerBlock = block;
+                logger.debug(`Header text: ${headerBlock.text}`);
+                const headerObj = this.getHeaderBlock({
+                    payloadHeaderBlock: headerBlock,
+                });
+                body.push(headerObj);
+            }
+            else if (block._type === "WorkspacePayloadButtons") {
+                const buttonsBlock = block;
+                logger.debug(`Processing ${buttonsBlock.buttons.length} buttons`);
+                for (const button of buttonsBlock.buttons) {
+                    logger.debug(`Button: ${button.title} -> ${button.url ? button.url.toString() : "invoke"}`);
+                    const actionObj = this.getButtonBlock({
+                        payloadButtonBlock: button,
+                    });
+                    actions.push(actionObj);
+                }
+            }
+        }
+        card["body"] = body;
+        card["actions"] = actions;
+        logger.debug(`Built adaptive card with ${body.length} body elements and ${actions.length} actions`);
+        return card;
+    }
+    static convertAdaptiveCardToHtml(adaptiveCard) {
+        logger.debug("=== convertAdaptiveCardToHtml called ===");
+        // Convert adaptive card to basic HTML for fallback
+        let html = "";
+        const body = adaptiveCard["body"] || [];
+        logger.debug(`Converting ${body.length} body elements to HTML`);
+        for (const element of body) {
+            if (element["type"] === "TextBlock") {
+                const text = element["text"];
+                const size = element["size"];
+                if (size === "Large") {
+                    html += `<h2>${text}</h2>`;
+                    logger.debug(`Added header: ${text}`);
+                }
+                else {
+                    html += `<p>${text}</p>`;
+                    logger.debug(`Added paragraph: ${text}`);
+                }
+            }
+        }
+        const actions = adaptiveCard["actions"] || [];
+        if (actions.length > 0) {
+            logger.debug(`Converting ${actions.length} actions to HTML`);
+            html += "<div>";
+            for (const action of actions) {
+                if (action["type"] === "Action.OpenUrl") {
+                    const title = action["title"];
+                    const url = action["url"];
+                    html += `<a href="${url}">${title}</a> `;
+                    logger.debug(`Added link: ${title} -> ${url}`);
+                }
+            }
+            html += "</div>";
+        }
+        logger.debug(`Generated HTML length: ${html.length} characters`);
+        return html;
+    }
+    // Placeholder implementations for abstract methods
+    static async showModalToUser(_data) {
+        // Microsoft Teams doesn't support modals in the same way as Slack
+        throw new Error("Modals are not supported in Microsoft Teams integration");
+    }
+    static async archiveChannels(_data) {
+        // Microsoft Teams doesn't support archiving channels via API
+        throw new Error("Channel archiving is not supported in Microsoft Teams integration");
+    }
+    static async joinChannel(_data) {
+        // Bot automatically has access to channels in Teams
+        logger.debug("Bot automatically has access to Teams channels");
+    }
+    static async inviteUserToChannelByChannelId(_data) {
+        // Teams channel membership is managed differently
+        logger.debug("Teams channel membership is managed at the team level");
+    }
+    static async inviteUserToChannelByChannelName(_data) {
+        // Teams channel membership is managed differently
+        logger.debug("Teams channel membership is managed at the team level");
+    }
+    static async getAllWorkspaceChannels(data) {
+        logger.debug("Getting all workspace channels for team ID: " + data.teamId);
+        // Get valid access token
+        const accessToken = await this.getValidAccessToken({
+            authToken: data.authToken,
+            projectId: data.projectId,
+        });
+        const response = await API.get({
+            url: URL.fromString(`https://graph.microsoft.com/v1.0/teams/${data.teamId}/channels`),
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (response instanceof HTTPErrorResponse) {
+            logger.error("Error response from Microsoft Graph API:");
+            logger.error(response);
+            throw response;
+        }
+        const channelsData = response.data;
+        const channelsArray = channelsData["value"] || [];
+        const channelsDict = {};
+        for (const channelData of channelsArray) {
+            const channel = {
+                id: channelData["id"],
+                name: channelData["displayName"],
+                workspaceType: WorkspaceType.MicrosoftTeams,
+            };
+            channelsDict[channel.id] = channel;
+        }
+        logger.debug(`Retrieved ${Object.keys(channelsDict).length} channels from API`);
+        return channelsDict;
+    }
+    static async doesChannelExist(data) {
+        if (!data.teamId) {
+            throw new BadDataException("teamId is required for Microsoft Teams doesChannelExist");
+        }
+        const channel = await this.getWorkspaceChannelByName({
+            authToken: data.authToken,
+            channelName: data.channelName,
+            projectId: data.projectId,
+            teamId: data.teamId,
+        });
+        return channel !== null;
+    }
+    static async isUserInDirectMessageChannel(_data) {
+        return false; // Placeholder
+    }
+    static async isUserInChannel(_data) {
+        return false; // Placeholder
+    }
+    // Block generation methods - these create adaptive card elements
+    static getDividerBlock() {
+        return {
+            type: "Container",
+            separator: true,
+            items: [],
+        };
+    }
+    static getButtonsBlock(_data) {
+        // Return adaptive card actions
+        return {
+            type: "ActionSet",
+            actions: [],
+        };
+    }
+    static getHeaderBlock(data) {
+        return {
+            type: "TextBlock",
+            text: data.payloadHeaderBlock.text,
+            size: "Large",
+            weight: "Bolder",
+        };
+    }
+    static getMarkdownBlock(data) {
+        return {
+            type: "TextBlock",
+            text: data.payloadMarkdownBlock.text,
+            wrap: true,
+            markdown: true,
+        };
+    }
+    static getButtonBlock(data) {
+        // If URL is present, render as link; otherwise use Action.Submit to post back action/value
+        if (data.payloadButtonBlock.url) {
+            return {
+                type: "Action.OpenUrl",
+                title: data.payloadButtonBlock.title,
+                url: data.payloadButtonBlock.url.toString(),
+            };
+        }
+        return {
+            type: "Action.Submit",
+            title: data.payloadButtonBlock.title,
+            data: {
+                action: data.payloadButtonBlock.actionId,
+                actionValue: data.payloadButtonBlock.value,
+            },
+        };
+    }
+    // Other block methods - placeholders for now
+    static getCheckboxBlock(_data) {
+        return { type: "Input.Toggle" };
+    }
+    static getDateTimePickerBlock(_data) {
+        return { type: "Input.Date" };
+    }
+    static getTextAreaBlock(_data) {
+        return { type: "Input.Text", isMultiline: true };
+    }
+    static getTextBoxBlock(_data) {
+        return { type: "Input.Text" };
+    }
+    static getImageBlock(_data) {
+        return { type: "Image" };
+    }
+    static getDropdownBlock(_data) {
+        return { type: "Input.ChoiceSet" };
+    }
+    static getModalBlock(_data) {
+        // Teams doesn't support modals like Slack
+        return {};
+    }
+    static async sendPayloadBlocksToChannel(_data) {
+        // This is handled by sendAdaptiveCardToChannel
+        throw new Error("Use sendAdaptiveCardToChannel instead");
+    }
+    static convertMarkdownToTeamsRichText(markdown) {
+        // Basic markdown to Teams format conversion
+        return markdown
+            .replace(/\*\*(.*?)\*\*/g, "<strong>$1</strong>")
+            .replace(/\*(.*?)\*/g, "<em>$1</em>")
+            .replace(/`(.*?)`/g, "<code>$1</code>");
+    }
+    // Bot Framework specific methods
+    static async handleBotMessageActivity(data) {
+        var _a, _b, _c;
+        // Handle direct messages to bot or @mentions via Bot Framework
+        const messageText = data.activity["text"] || "";
+        const possibleActionValue = data.activity["value"] || {};
+        const from = data.activity["from"] || {};
+        const conversation = data.activity["conversation"] || {};
+        const channelData = data.activity["channelData"] || {};
+        const entities = data.activity["entities"] || [];
+        logger.debug(`Bot message from: ${JSON.stringify(from)}`);
+        logger.debug(`Message text: ${messageText}`);
+        logger.debug(`Conversation: ${JSON.stringify(conversation)}`);
+        logger.debug(`Channel data: ${JSON.stringify(channelData)}`);
+        logger.debug(`Entities: ${JSON.stringify(entities)}`);
+        // If this is actually an Adaptive Card submit wrapped as a message, route to invoke handler
+        if (possibleActionValue["action"] ||
+            ((_a = possibleActionValue["data"]) === null || _a === void 0 ? void 0 : _a["action"])) {
+            logger.debug("Message activity contains action payload; routing to invoke handler");
+            await this.handleBotInvokeActivity({
+                activity: data.activity,
+                turnContext: data.turnContext,
+            });
+            return;
+        }
+        // Check if the bot was mentioned
+        const recipientId = (_b = data.activity["recipient"]) === null || _b === void 0 ? void 0 : _b["id"];
+        const conversationType = conversation["conversationType"] || "";
+        const isDirectMessage = conversationType === "personal";
+        const isMentioned = entities.some((entity) => {
+            var _a;
+            return (entity["type"] === "mention" &&
+                ((_a = entity["mentioned"]) === null || _a === void 0 ? void 0 : _a["id"]) === recipientId);
+        });
+        // Only respond if it's a direct message or the bot was mentioned
+        if (!isDirectMessage && !isMentioned) {
+            logger.debug("Bot not mentioned in channel message, ignoring");
+            return;
+        }
+        // Extract tenant ID to get project ID
+        const tenantId = (_c = channelData["tenant"]) === null || _c === void 0 ? void 0 : _c["id"];
+        if (!tenantId) {
+            logger.error("Tenant ID not found in channelData");
+            await data.turnContext.sendActivity("Sorry, I couldn't identify your organization. Please try again later.");
+            return;
+        }
+        // Get project auth by tenant ID
+        const projectAuth = await WorkspaceProjectAuthTokenService.findOneBy({
+            query: {
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                miscData: {
+                    tenantId: tenantId,
+                },
+            },
+            select: {
+                projectId: true,
+                miscData: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!projectAuth || !projectAuth.projectId) {
+            logger.error("Project auth not found for tenant ID: " + tenantId);
+            await data.turnContext.sendActivity("Sorry, I couldn't find your project configuration. Please try again later.");
+            return;
+        }
+        const projectId = projectAuth.projectId;
+        logger.debug(`Found project ID: ${projectId.toString()} for tenant ID: ${tenantId}`);
+        // Clean the message text by removing bot mentions
+        const cleanText = messageText
+            .replace(/<at[^>]*>.*?<\/at>/g, "")
+            .trim()
+            .toLowerCase();
+        let responseText = "";
+        try {
+            if (cleanText.includes("help") || cleanText === "") {
+                responseText = this.getHelpMessage();
+            }
+            else if (cleanText === "/incident" ||
+                cleanText.startsWith("/incident ")) {
+                // Handle /incident slash command
+                logger.debug("Processing /incident command");
+                const card = await MicrosoftTeamsIncidentActions.buildNewIncidentCard(projectId);
+                await data.turnContext.sendActivity({
+                    attachments: [
+                        {
+                            contentType: "application/vnd.microsoft.card.adaptive",
+                            content: card,
+                        },
+                    ],
+                });
+                logger.debug("New incident card sent successfully");
+                return;
+            }
+            else if (cleanText === "/maintenance" ||
+                cleanText.startsWith("/maintenance ")) {
+                // Handle /maintenance slash command
+                logger.debug("Processing /maintenance command");
+                const card = await MicrosoftTeamsScheduledMaintenanceActions.buildNewScheduledMaintenanceCard(projectId);
+                await data.turnContext.sendActivity({
+                    attachments: [
+                        {
+                            contentType: "application/vnd.microsoft.card.adaptive",
+                            content: card,
+                        },
+                    ],
+                });
+                logger.debug("New scheduled maintenance card sent successfully");
+                return;
+            }
+            else if (cleanText.includes("show active incidents") ||
+                cleanText.includes("active incidents")) {
+                responseText = await this.getActiveIncidentsMessage(projectId);
+            }
+            else if (cleanText.includes("show scheduled maintenance") ||
+                cleanText.includes("scheduled maintenance")) {
+                responseText = await this.getScheduledMaintenanceMessage(projectId);
+            }
+            else if (cleanText.includes("show ongoing maintenance") ||
+                cleanText.includes("ongoing maintenance")) {
+                responseText = await this.getOngoingMaintenanceMessage(projectId);
+            }
+            else if (cleanText.includes("show active alerts") ||
+                cleanText.includes("active alerts")) {
+                responseText = await this.getActiveAlertsMessage(projectId);
+            }
+            else {
+                responseText = `I received your message: "${cleanText}". Type 'help' to see what I can do for you.`;
+            }
+            // Send response directly using TurnContext - this is the recommended Bot Framework pattern
+            await data.turnContext.sendActivity(responseText);
+            logger.debug("Bot message sent successfully using TurnContext");
+        }
+        catch (error) {
+            logger.error("Error sending bot message via TurnContext: " + error);
+            await data.turnContext.sendActivity("Sorry, I encountered an error processing your request. Please try again later.");
+            throw error;
+        }
+    }
+    // Helper methods for bot commands
+    static getHelpMessage() {
+        return `Hello! I'm the OneUptime bot. I can help you with the following commands:
+
+**Available Commands:**
+- **help** — Show this help message
+- **/incident** — Create a new incident
+- **/maintenance** — Create a new scheduled maintenance event
+- **show active incidents** — Display all currently active incidents
+- **show scheduled maintenance** — Show upcoming scheduled maintenance events
+- **show ongoing maintenance** — Display currently ongoing maintenance events
+- **show active alerts** — Display all active alerts
+
+Just type any of these commands to get the information you need!`;
+    }
+    static async getActiveIncidentsMessage(projectId) {
+        var _a, _b;
+        try {
+            logger.debug("Getting active incidents for project: " + projectId.toString());
+            // Get unresolved incident states
+            const unresolvedIncidentStates = await IncidentStateService.getUnresolvedIncidentStates(projectId, {
+                isRoot: true,
+            });
+            const unresolvedIncidentStateIds = unresolvedIncidentStates.map((state) => {
+                return state.id;
+            });
+            // Find active incidents
+            const activeIncidents = await IncidentService.findBy({
+                query: {
+                    projectId: projectId,
+                    currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
+                },
+                select: {
+                    _id: true,
+                    incidentNumber: true,
+                    title: true,
+                    description: true,
+                    currentIncidentState: {
+                        name: true,
+                        color: true,
+                    },
+                    incidentSeverity: {
+                        name: true,
+                        color: true,
+                    },
+                    createdAt: true,
+                    monitors: {
+                        name: true,
+                    },
+                },
+                sort: {
+                    createdAt: SortOrder.Descending,
+                },
+                limit: 10,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (activeIncidents.length === 0) {
+                return `**Active Incidents**
+
+Currently, there are no active incidents in the system. All services are operating normally.
+
+If you need to report an incident or check historical incidents, please visit the OneUptime dashboard.`;
+            }
+            let message = `**Active Incidents** (${activeIncidents.length})
+
+`;
+            for (const incident of activeIncidents) {
+                const severity = ((_a = incident.incidentSeverity) === null || _a === void 0 ? void 0 : _a.name) || "Unknown";
+                const state = ((_b = incident.currentIncidentState) === null || _b === void 0 ? void 0 : _b.name) || "Unknown";
+                const createdAt = incident.createdAt
+                    ? OneUptimeDate.getDateAsFormattedString(incident.createdAt)
+                    : "Unknown";
+                const severityIcon = ["Critical", "Major"].includes(severity)
+                    ? "🔴"
+                    : severity === "Minor"
+                        ? "🟠"
+                        : "🟡";
+                const incidentUrl = await IncidentService.getIncidentLinkInDashboard(projectId, incident.id);
+                message += `${severityIcon} **[Incident #${incident.incidentNumber}: ${incident.title}](${incidentUrl.toString()})**
+• **Severity:** ${severity}
+• **Status:** ${state}
+• **Created:** ${createdAt}
+`;
+                if (incident.monitors && incident.monitors.length > 0) {
+                    message += `• **Affected Services:** ${incident.monitors
+                        .map((m) => {
+                        return m.name;
+                    })
+                        .join(", ")}\n`;
+                }
+                if (incident.description) {
+                    const desc = incident.description.replace(/\s+/g, " ");
+                    message += `• **Description:** ${desc.substring(0, 180)}${desc.length > 180 ? "..." : ""}\n`;
+                }
+                message += `• [Open in Dashboard](${incidentUrl.toString()})\n\n`;
+            }
+            return message;
+        }
+        catch (error) {
+            logger.error("Error getting active incidents: " + error);
+            return "Sorry, I couldn't retrieve active incidents information at the moment. Please try again later.";
+        }
+    }
+    static async getScheduledMaintenanceMessage(projectId) {
+        var _a;
+        try {
+            logger.debug("Getting scheduled maintenance events for project: " +
+                projectId.toString());
+            // Get scheduled maintenance events
+            const scheduledEvents = await ScheduledMaintenanceService.findBy({
+                query: {
+                    projectId: projectId,
+                    currentScheduledMaintenanceState: {
+                        isScheduledState: true,
+                    },
+                    isVisibleOnStatusPage: true, // Only show events visible on status page
+                },
+                select: {
+                    _id: true,
+                    title: true,
+                    description: true,
+                    startsAt: true,
+                    endsAt: true,
+                    currentScheduledMaintenanceState: {
+                        name: true,
+                    },
+                    monitors: {
+                        name: true,
+                    },
+                    scheduledMaintenanceNumber: true,
+                },
+                sort: {
+                    startsAt: SortOrder.Ascending,
+                },
+                limit: 10,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (scheduledEvents.length === 0) {
+                return `**Scheduled Maintenance Events**
+
+There are currently no scheduled maintenance events.
+
+When maintenance is scheduled, you'll see details here including:
+• Event title and description
+• Scheduled start and end times
+• Affected services
+• Status updates
+
+Check back later for upcoming maintenance windows.`;
+            }
+            let message = `**Scheduled Maintenance Events** (${scheduledEvents.length})
+
+`;
+            for (const event of scheduledEvents) {
+                const state = ((_a = event.currentScheduledMaintenanceState) === null || _a === void 0 ? void 0 : _a.name) || "Scheduled";
+                const startTime = event.startsAt
+                    ? OneUptimeDate.getDateAsFormattedString(event.startsAt)
+                    : "TBD";
+                const endTime = event.endsAt
+                    ? OneUptimeDate.getDateAsFormattedString(event.endsAt)
+                    : "TBD";
+                const eventUrl = await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(projectId, event.id);
+                message += `🛠️ **[Scheduled Maintenance #${event.scheduledMaintenanceNumber}: ${event.title}](${eventUrl.toString()})**
+• **Status:** ${state}
+• **Starts:** ${startTime}
+• **Ends:** ${endTime}
+`;
+                if (event.monitors && event.monitors.length > 0) {
+                    message += `• **Affected Services:** ${event.monitors
+                        .map((m) => {
+                        return m.name;
+                    })
+                        .join(", ")}\n`;
+                }
+                if (event.description) {
+                    const desc = event.description.replace(/\s+/g, " ");
+                    message += `• **Description:** ${desc.substring(0, 180)}${desc.length > 180 ? "..." : ""}\n`;
+                }
+                message += `• [View Event](${eventUrl.toString()})\n\n`;
+            }
+            return message;
+        }
+        catch (error) {
+            logger.error("Error getting scheduled maintenance: " + error);
+            return "Sorry, I couldn't retrieve scheduled maintenance information at the moment. Please try again later.";
+        }
+    }
+    static async getOngoingMaintenanceMessage(projectId) {
+        var _a;
+        try {
+            logger.debug("Getting ongoing maintenance events for project: " +
+                projectId.toString());
+            // Get ongoing maintenance events
+            const ongoingEvents = await ScheduledMaintenanceService.findBy({
+                query: {
+                    projectId: projectId,
+                    currentScheduledMaintenanceState: {
+                        isOngoingState: true,
+                    },
+                },
+                select: {
+                    _id: true,
+                    title: true,
+                    description: true,
+                    startsAt: true,
+                    endsAt: true,
+                    currentScheduledMaintenanceState: {
+                        name: true,
+                    },
+                    monitors: {
+                        name: true,
+                    },
+                    scheduledMaintenanceNumber: true,
+                },
+                sort: {
+                    startsAt: SortOrder.Descending,
+                },
+                limit: 10,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (ongoingEvents.length === 0) {
+                return `**Ongoing Maintenance Events**
+
+There are currently no ongoing maintenance events.
+
+When maintenance is in progress, you'll see details here including:
+• Event title and description
+• Current status and progress
+• Affected services
+• Expected completion time
+
+All systems are currently operating normally.`;
+            }
+            let message = `**Ongoing Maintenance Events** (${ongoingEvents.length})
+
+`;
+            for (const event of ongoingEvents) {
+                const state = ((_a = event.currentScheduledMaintenanceState) === null || _a === void 0 ? void 0 : _a.name) || "Ongoing";
+                const startTime = event.startsAt
+                    ? OneUptimeDate.getDateAsFormattedString(event.startsAt)
+                    : "Unknown";
+                const endTime = event.endsAt
+                    ? OneUptimeDate.getDateAsFormattedString(event.endsAt)
+                    : "TBD";
+                const eventUrl = await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(projectId, event.id);
+                message += `🔧 **[Scheduled Maintenance #${event.scheduledMaintenanceNumber}: ${event.title}](${eventUrl.toString()})**
+• **Status:** ${state}
+• **Started:** ${startTime}
+• **Expected End:** ${endTime}
+`;
+                if (event.monitors && event.monitors.length > 0) {
+                    message += `• **Affected Services:** ${event.monitors
+                        .map((m) => {
+                        return m.name;
+                    })
+                        .join(", ")}\n`;
+                }
+                if (event.description) {
+                    const desc = event.description.replace(/\s+/g, " ");
+                    message += `• **Description:** ${desc.substring(0, 180)}${desc.length > 180 ? "..." : ""}\n`;
+                }
+                message += `• [View Event](${eventUrl.toString()})\n\n`;
+            }
+            return message;
+        }
+        catch (error) {
+            logger.error("Error getting ongoing maintenance: " + error);
+            return "Sorry, I couldn't retrieve ongoing maintenance information at the moment. Please try again later.";
+        }
+    }
+    static async getActiveAlertsMessage(projectId) {
+        var _a, _b, _c;
+        try {
+            logger.debug("Getting active alerts for project: " + projectId.toString());
+            // Get unresolved alert states
+            const unresolvedAlertStates = await AlertStateService.getUnresolvedAlertStates(projectId, {
+                isRoot: true,
+            });
+            const unresolvedAlertStateIds = unresolvedAlertStates.map((state) => {
+                return state.id;
+            });
+            // Find active alerts
+            const activeAlerts = await AlertService.findBy({
+                query: {
+                    projectId: projectId,
+                    currentAlertStateId: QueryHelper.any(unresolvedAlertStateIds),
+                },
+                select: {
+                    _id: true,
+                    alertNumber: true,
+                    title: true,
+                    description: true,
+                    currentAlertState: {
+                        name: true,
+                        color: true,
+                    },
+                    alertSeverity: {
+                        name: true,
+                        color: true,
+                    },
+                    createdAt: true,
+                    monitor: {
+                        name: true,
+                    },
+                },
+                sort: {
+                    createdAt: SortOrder.Descending,
+                },
+                limit: 10,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (activeAlerts.length === 0) {
+                return `**Active Alerts**
+
+Currently, there are no active alerts in the system.
+
+When alerts are triggered, you'll see details here including:
+• Alert title and description
+• Severity level
+• Affected services or monitors
+• Time triggered
+• Current status
+
+All monitoring checks are passing normally.`;
+            }
+            let message = `**Active Alerts** (${activeAlerts.length})
+
+`;
+            for (const alert of activeAlerts) {
+                const severity = ((_a = alert.alertSeverity) === null || _a === void 0 ? void 0 : _a.name) || "Unknown";
+                const state = ((_b = alert.currentAlertState) === null || _b === void 0 ? void 0 : _b.name) || "Unknown";
+                const createdAt = alert.createdAt
+                    ? OneUptimeDate.getDateAsFormattedString(alert.createdAt)
+                    : "Unknown";
+                const alertUrl = await AlertService.getAlertLinkInDashboard(projectId, alert.id);
+                message += `⚠️ **[Alert #${alert.alertNumber}: ${alert.title}](${alertUrl.toString()})**
+• **Severity:** ${severity}
+• **Status:** ${state}
+• **Triggered:** ${createdAt}
+`;
+                if ((_c = alert.monitor) === null || _c === void 0 ? void 0 : _c.name) {
+                    message += `• **Monitor:** ${alert.monitor.name}\n`;
+                }
+                if (alert.description) {
+                    const desc = alert.description.replace(/\s+/g, " ");
+                    message += `• **Description:** ${desc.substring(0, 180)}${desc.length > 180 ? "..." : ""}\n`;
+                }
+                message += `• [Open in Dashboard](${alertUrl.toString()})\n\n`;
+            }
+            return message;
+        }
+        catch (error) {
+            logger.error("Error getting active alerts: " + error);
+            return "Sorry, I couldn't retrieve active alerts information at the moment. Please try again later.";
+        }
+    }
+    static async handleBotInvokeActivity(data) {
+        // Handle adaptive card button clicks via Bot Framework
+        const value = data.activity["value"] || {};
+        // Extract action type and value from the value object
+        const { actionType, actionValue } = this.extractActionFromValue(value);
+        logger.debug(`Bot invoke activity - Action type: ${actionType}`);
+        logger.debug(`Bot invoke value: ${JSON.stringify(value)}`);
+        try {
+            // Resolve project and user context from activity
+            const channelData = data.activity["channelData"] || {};
+            const tenantId = (channelData["tenant"] || {})["id"];
+            if (!tenantId) {
+                logger.error("Tenant ID not found in invoke activity");
+                await data.turnContext.sendActivity("Sorry, I couldn't identify your organization. Please try again later.");
+                return;
+            }
+            const projectAuth = await WorkspaceProjectAuthTokenService.findOneBy({
+                query: {
+                    workspaceType: WorkspaceType.MicrosoftTeams,
+                    miscData: { tenantId: tenantId },
+                },
+                select: { projectId: true, authToken: true },
+                props: { isRoot: true },
+            });
+            if (!projectAuth || !projectAuth.projectId) {
+                logger.error("Project auth not found for invoke activity tenant: " + tenantId);
+                await data.turnContext.sendActivity("Sorry, I couldn't find your project configuration.");
+                return;
+            }
+            const projectId = projectAuth.projectId;
+            const fromObj = (data.activity["from"] ||
+                {});
+            const teamsUserId = fromObj["aadObjectId"] || undefined;
+            if (!teamsUserId) {
+                logger.error("AAD Object ID (teamsUserId) not found in invoke activity from object");
+                await data.turnContext.sendActivity("Sorry, I couldn't identify you. Please try again later.");
+                return;
+            }
+            const userLookupParamsRes = {
+                teamsUserId: teamsUserId,
+                projectId: projectId,
+            };
+            const oneUptimeUserId = await MicrosoftTeamsAuthAction.getOneUptimeUserIdFromTeamsUserId(userLookupParamsRes);
+            // Handle incident actions
+            if (MicrosoftTeamsIncidentActions.isIncidentAction({ actionType })) {
+                await MicrosoftTeamsIncidentActions.handleBotIncidentAction({
+                    actionType,
+                    actionValue,
+                    value,
+                    projectId,
+                    oneUptimeUserId,
+                    turnContext: data.turnContext,
+                });
+                return;
+            }
+            // Handle alert actions
+            if (MicrosoftTeamsAlertActions.isAlertAction({ actionType })) {
+                await MicrosoftTeamsAlertActions.handleBotAlertAction({
+                    actionType,
+                    actionValue,
+                    value,
+                    projectId,
+                    oneUptimeUserId,
+                    turnContext: data.turnContext,
+                });
+                return;
+            }
+            // Handle monitor actions
+            if (MicrosoftTeamsMonitorActions.isMonitorAction({ actionType })) {
+                await MicrosoftTeamsMonitorActions.handleBotMonitorAction({
+                    actionType,
+                    actionValue,
+                    value,
+                    projectId,
+                    oneUptimeUserId,
+                    turnContext: data.turnContext,
+                });
+                return;
+            }
+            // Handle scheduled maintenance actions
+            if (MicrosoftTeamsScheduledMaintenanceActions.isScheduledMaintenanceAction({
+                actionType,
+            })) {
+                await MicrosoftTeamsScheduledMaintenanceActions.handleBotScheduledMaintenanceAction(actionType, data.turnContext, value, {
+                    userId: oneUptimeUserId.toString(),
+                    projectId,
+                    isAuthorized: true,
+                    authToken: "",
+                    payloadType: "invoke",
+                });
+                return;
+            }
+            // Handle on-call duty actions
+            if (MicrosoftTeamsOnCallDutyActions.isOnCallDutyAction({ actionType })) {
+                await MicrosoftTeamsOnCallDutyActions.handleBotOnCallDutyAction(actionType, data.turnContext, value);
+                return;
+            }
+        }
+        catch (error) {
+            logger.error("Error handling bot invoke activity:");
+            logger.error(error);
+            await data.turnContext.sendActivity("Sorry, that action failed. Please try again later.");
+        }
+    }
+    static async handleConversationUpdateActivity(data) {
+        // Handle bot added to team/channel or members added/removed
+        const membersAdded = data.activity["membersAdded"] || [];
+        const membersRemoved = data.activity["membersRemoved"] || [];
+        const conversation = data.activity["conversation"] || {};
+        const channelData = data.activity["channelData"] || {};
+        logger.debug(`Conversation update - Members added: ${JSON.stringify(membersAdded)}`);
+        logger.debug(`Conversation update - Members removed: ${JSON.stringify(membersRemoved)}`);
+        logger.debug(`Conversation: ${JSON.stringify(conversation)}`);
+        logger.debug(`Channel data: ${JSON.stringify(channelData)}`);
+        // Check if the bot was added
+        const botWasAdded = membersAdded.some((member) => {
+            return member["id"] === MicrosoftTeamsAppClientId;
+        });
+        if (botWasAdded) {
+            logger.debug("OneUptime bot was added to a Teams conversation");
+            const welcomeText = "🎉 Welcome to OneUptime!\n\nI'm your monitoring and alerting assistant. I'll help you stay on top of your system's health and notify you about any incidents.\n\nType 'help' to see what I can do for you.";
+            try {
+                // Send welcome message directly using TurnContext
+                await data.turnContext.sendActivity(welcomeText);
+                logger.debug("Welcome message sent successfully using TurnContext");
+            }
+            catch (error) {
+                logger.error("Error sending welcome message via TurnContext: " + error);
+            }
+        }
+    }
+    static async handleInstallationUpdateActivity(data) {
+        // Handle bot installation/uninstallation
+        const action = data.activity["action"] || "";
+        const conversation = data.activity["conversation"] || {};
+        logger.debug(`Installation update - Action: ${action}`);
+        logger.debug(`Conversation: ${JSON.stringify(conversation)}`);
+        if (action === "add") {
+            logger.debug("OneUptime bot was installed");
+        }
+        else if (action === "remove") {
+            logger.debug("OneUptime bot was uninstalled");
+        }
+    }
+    /**
+     * Process Bot Framework activity using the botbuilder SDK adapter.processActivity
+     * This replaces the manual JWT validation and activity handling with proper SDK methods
+     */
+    static async processBotActivity(req, res) {
+        var _a, _b, _c;
+        logger.debug("Processing Bot Framework activity using adapter.processActivity");
+        logger.debug("Request body: " + JSON.stringify(req.body, null, 2));
+        try {
+            if (!MicrosoftTeamsAppClientId || !MicrosoftTeamsAppClientSecret) {
+                logger.error("Microsoft Teams App credentials not configured");
+                res.status(500).json({ error: "Bot credentials not configured" });
+                return;
+            }
+            // Extract tenant ID from the activity
+            const tenantId = (_c = (_b = (_a = req.body) === null || _a === void 0 ? void 0 : _a.channelData) === null || _b === void 0 ? void 0 : _b.tenant) === null || _c === void 0 ? void 0 : _c.id;
+            if (!tenantId) {
+                logger.error("Tenant ID not found in activity channelData");
+                res.status(400).json({ error: "Invalid activity: missing tenant ID" });
+                return;
+            }
+            // Get Bot Framework adapter
+            const adapter = this.getBotAdapter(tenantId);
+            // Create custom activity handler class that extends TeamsActivityHandler
+            class OneUptimeTeamsActivityHandler extends TeamsActivityHandler {
+                constructor() {
+                    super();
+                    // Set up message handlers using the proper API
+                    this.onMessage(async (context, next) => {
+                        logger.debug("Handling message activity: " +
+                            JSON.stringify(context.activity));
+                        await MicrosoftTeamsUtil.handleBotMessageActivity({
+                            activity: context.activity,
+                            turnContext: context,
+                        });
+                        await next();
+                    });
+                    this.onMembersAdded(async (context, next) => {
+                        logger.debug("Handling members added activity: " +
+                            JSON.stringify(context.activity));
+                        await MicrosoftTeamsUtil.handleConversationUpdateActivity({
+                            activity: context.activity,
+                            turnContext: context,
+                        });
+                        await next();
+                    });
+                }
+                async onInvokeActivity(context) {
+                    logger.debug("Handling invoke activity: " + JSON.stringify(context.activity));
+                    await MicrosoftTeamsUtil.handleBotInvokeActivity({
+                        activity: context.activity,
+                        turnContext: context,
+                    });
+                    // Return empty response for invoke activities
+                    return { status: 200 };
+                }
+            }
+            // Create activity handler instance
+            const activityHandler = new OneUptimeTeamsActivityHandler();
+            // Use the adapter's process method with Express-style req/res
+            await adapter.process(req, res, async (context) => {
+                var _a, _b;
+                logger.debug("Processing activity with TurnContext: " +
+                    JSON.stringify({
+                        activityType: context.activity.type,
+                        activityId: context.activity.id,
+                        from: (_a = context.activity.from) === null || _a === void 0 ? void 0 : _a.name,
+                        conversationId: (_b = context.activity.conversation) === null || _b === void 0 ? void 0 : _b.id,
+                    }));
+                // Run the activity through our activity handler
+                await activityHandler.run(context);
+            });
+            logger.debug("Bot Framework activity processed successfully");
+        }
+        catch (error) {
+            logger.error("Error processing Bot Framework activity: " + error);
+            if (!res.headersSent) {
+                res.status(500).json({ error: "Failed to process bot activity" });
+            }
+        }
+    }
+    // Method to refresh teams list for a user
+    static async refreshTeams(data) {
+        logger.debug("=== refreshTeams called ===");
+        logger.debug(`Project ID: ${data.projectId.toString()}`);
+        try {
+            // Get project auth to get app access token
+            const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+                projectId: data.projectId,
+                workspaceType: WorkspaceType.MicrosoftTeams,
+            });
+            if (!projectAuth || !projectAuth.miscData) {
+                throw new BadDataException("Microsoft Teams integration not found for this project");
+            }
+            // Get a valid app access token
+            const accessToken = await this.refreshAccessToken({
+                projectId: data.projectId,
+                miscData: projectAuth.miscData,
+            });
+            if (!accessToken) {
+                throw new BadDataException("Could not obtain valid access token for Microsoft Teams");
+            }
+            // Fetch all teams from Microsoft Graph API using app permissions
+            const teamsResponse = await API.get({
+                url: URL.fromString("https://graph.microsoft.com/v1.0/teams"),
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            if (teamsResponse instanceof HTTPErrorResponse) {
+                logger.error("Error fetching teams from Microsoft Teams:");
+                logger.error(teamsResponse);
+                throw new BadDataException("Failed to fetch teams from Microsoft Teams");
+            }
+            const teams = teamsResponse.data["value"] || [];
+            if (teams.length === 0) {
+                logger.debug("No teams found in organization");
+                return {};
+            }
+            // Process teams
+            const availableTeams = teams.reduce((acc, t) => {
+                const team = {
+                    id: t["id"],
+                    name: t["displayName"] || "Unnamed Team",
+                };
+                acc[team.name] = team;
+                return acc;
+            }, {});
+            logger.debug(`Fetched ${Object.keys(availableTeams).length} teams`);
+            // Update project auth token with new teams
+            const miscData = projectAuth.miscData || {};
+            miscData.availableTeams = availableTeams;
+            await WorkspaceProjectAuthTokenService.updateOneById({
+                id: projectAuth.id,
+                data: {
+                    miscData: miscData,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            logger.debug("Updated project auth token with refreshed teams");
+            return availableTeams;
+        }
+        catch (error) {
+            logger.error("Error refreshing teams:");
+            logger.error(error);
+            throw error;
+        }
+    }
+    // Method to get user's joined teams using user access token
+    static async getUserJoinedTeams(accessToken) {
+        logger.debug("=== getUserJoinedTeams called ===");
+        try {
+            // Get user's teams
+            const teamsResponse = await API.get({
+                url: URL.fromString("https://graph.microsoft.com/v1.0/me/joinedTeams"),
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            if (teamsResponse instanceof HTTPErrorResponse) {
+                logger.error("Error getting teams:");
+                logger.error(teamsResponse);
+                throw teamsResponse;
+            }
+            const teamsData = teamsResponse.data;
+            const teams = teamsData["value"] || [];
+            if (teams.length === 0) {
+                logger.debug("No joined teams found for user");
+                return {};
+            }
+            // Process teams
+            const availableTeams = teams.reduce((acc, t) => {
+                const team = {
+                    id: t["id"],
+                    name: t["displayName"] || "Unnamed Team",
+                };
+                acc[team.name] = team;
+                return acc;
+            }, {});
+            logger.debug(`Fetched ${Object.keys(availableTeams).length} joined teams`);
+            return availableTeams;
+        }
+        catch (error) {
+            logger.error("Error getting user joined teams:");
+            logger.error(error);
+            throw error;
+        }
+    }
 }
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], MicrosoftTeams, "sendMessageToChannelViaIncomingWebhook", null);
+], MicrosoftTeamsUtil, "sendMessageToChannelViaIncomingWebhook", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getUsernameFromUserId", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "sendDirectMessageToUser", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "createChannelsIfDoesNotExist", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "createChannel", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getWorkspaceChannelFromChannelName", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getWorkspaceChannelByName", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "sendMessage", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "sendAdaptiveCardToChannel", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getWorkspaceChannelFromChannelId", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "showModalToUser", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "archiveChannels", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "joinChannel", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "inviteUserToChannelByChannelId", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "inviteUserToChannelByChannelName", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getAllWorkspaceChannels", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "doesChannelExist", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "isUserInDirectMessageChannel", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "isUserInChannel", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getDividerBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getButtonsBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getHeaderBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getMarkdownBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getButtonBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getCheckboxBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getDateTimePickerBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getTextAreaBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getTextBoxBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getImageBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getDropdownBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], MicrosoftTeamsUtil, "getModalBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "sendPayloadBlocksToChannel", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], MicrosoftTeamsUtil, "convertMarkdownToTeamsRichText", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "handleBotMessageActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "handleBotInvokeActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "handleConversationUpdateActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "handleInstallationUpdateActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "processBotActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "refreshTeams", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getUserJoinedTeams", null);
 //# sourceMappingURL=MicrosoftTeams.js.map