@oneuptime/common 9.4.12 → 9.4.13

package/build/dist/Server/Utils/Workspace/Slack/Actions/IncidentEpisode.js

@@ -0,0 +1,651 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../Types/ObjectID";
+import IncidentEpisodeService from "../../../../Services/IncidentEpisodeService";
+import SlackUtil from "../Slack";
+import SlackActionType, { PrivateNoteEmojis } from "./ActionTypes";
+import Response from "../../../Response";
+import IncidentEpisodeInternalNoteService from "../../../../Services/IncidentEpisodeInternalNoteService";
+import OnCallDutyPolicyService from "../../../../Services/OnCallDutyPolicyService";
+import { LIMIT_PER_PROJECT } from "../../../../../Types/Database/LimitMax";
+import UserNotificationEventType from "../../../../../Types/UserNotification/UserNotificationEventType";
+import IncidentStateService from "../../../../Services/IncidentStateService";
+import logger from "../../../Logger";
+import AccessTokenService from "../../../../Services/AccessTokenService";
+import CaptureSpan from "../../../Telemetry/CaptureSpan";
+import WorkspaceNotificationLogService from "../../../../Services/WorkspaceNotificationLogService";
+import WorkspaceUserAuthTokenService from "../../../../Services/WorkspaceUserAuthTokenService";
+import WorkspaceType from "../../../../../Types/Workspace/WorkspaceType";
+import WorkspaceProjectAuthTokenService from "../../../../Services/WorkspaceProjectAuthTokenService";
+export default class SlackIncidentEpisodeActions {
+    static isIncidentEpisodeAction(data) {
+        const { actionType } = data;
+        switch (actionType) {
+            case SlackActionType.AcknowledgeIncidentEpisode:
+            case SlackActionType.ResolveIncidentEpisode:
+            case SlackActionType.ViewAddIncidentEpisodeNote:
+            case SlackActionType.SubmitIncidentEpisodeNote:
+            case SlackActionType.ViewChangeIncidentEpisodeState:
+            case SlackActionType.SubmitChangeIncidentEpisodeState:
+            case SlackActionType.ViewExecuteIncidentEpisodeOnCallPolicy:
+            case SlackActionType.SubmitExecuteIncidentEpisodeOnCallPolicy:
+            case SlackActionType.ViewIncidentEpisode:
+                return true;
+            default:
+                return false;
+        }
+    }
+    static async acknowledgeIncidentEpisode(data) {
+        const { slackRequest, req, res } = data;
+        const { botUserId, userId, projectAuthToken, slackUsername } = slackRequest;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        if (!userId) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid User ID"));
+        }
+        if (!projectAuthToken) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Project Auth Token"));
+        }
+        if (!botUserId) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Bot User ID"));
+        }
+        if (data.action.actionType === SlackActionType.AcknowledgeIncidentEpisode) {
+            const episodeId = new ObjectID(actionValue);
+            // We send this early let slack know we're ok. We'll do the rest in the background.
+            Response.sendJsonObjectResponse(req, res, {
+                response_action: "clear",
+            });
+            const isAlreadyAcknowledged = await IncidentEpisodeService.isEpisodeAcknowledged({
+                episodeId: episodeId,
+            });
+            if (isAlreadyAcknowledged) {
+                // send a message to the channel visible to user, that the episode has already been acknowledged.
+                const markdwonPayload = {
+                    _type: "WorkspacePayloadMarkdown",
+                    text: `@${slackUsername}, unfortunately you cannot acknowledge the **[Incident Episode](${await IncidentEpisodeService.getEpisodeLinkInDashboard(slackRequest.projectId, episodeId)})**. It has already been acknowledged.`,
+                };
+                await SlackUtil.sendDirectMessageToUser({
+                    messageBlocks: [markdwonPayload],
+                    authToken: projectAuthToken,
+                    workspaceUserId: slackRequest.slackUserId,
+                });
+                return;
+            }
+            await IncidentEpisodeService.acknowledgeEpisode(episodeId, userId);
+            // Log the button interaction
+            if (slackRequest.projectId) {
+                try {
+                    const logData = {
+                        projectId: slackRequest.projectId,
+                        workspaceType: WorkspaceType.Slack,
+                        userId: userId,
+                        buttonAction: "acknowledge_incident_episode",
+                    };
+                    if (slackRequest.slackChannelId) {
+                        logData.channelId = slackRequest.slackChannelId;
+                    }
+                    logData.incidentEpisodeId = episodeId;
+                    await WorkspaceNotificationLogService.logButtonPressed(logData, {
+                        isRoot: true,
+                    });
+                }
+                catch (err) {
+                    logger.error("Error logging button interaction:");
+                    logger.error(err);
+                    // Don't throw the error, just log it so the main flow continues
+                }
+            }
+            return;
+        }
+        // invalid action type.
+        return Response.sendErrorResponse(req, res, new BadDataException("Invalid Action Type"));
+    }
+    static async resolveIncidentEpisode(data) {
+        const { slackRequest, req, res } = data;
+        const { botUserId, userId, projectAuthToken, slackUsername } = slackRequest;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        if (!userId) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid User ID"));
+        }
+        if (!projectAuthToken) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Project Auth Token"));
+        }
+        if (!botUserId) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Bot User ID"));
+        }
+        if (data.action.actionType === SlackActionType.ResolveIncidentEpisode) {
+            const episodeId = new ObjectID(actionValue);
+            // We send this early let slack know we're ok. We'll do the rest in the background.
+            Response.sendJsonObjectResponse(req, res, {
+                response_action: "clear",
+            });
+            const isAlreadyResolved = await IncidentEpisodeService.isEpisodeResolved(episodeId);
+            if (isAlreadyResolved) {
+                // send a message to the channel visible to user, that the episode has already been Resolved.
+                const markdwonPayload = {
+                    _type: "WorkspacePayloadMarkdown",
+                    text: `@${slackUsername}, unfortunately you cannot resolve the **[Incident Episode](${await IncidentEpisodeService.getEpisodeLinkInDashboard(slackRequest.projectId, episodeId)})**. It has already been resolved.`,
+                };
+                await SlackUtil.sendDirectMessageToUser({
+                    messageBlocks: [markdwonPayload],
+                    authToken: projectAuthToken,
+                    workspaceUserId: slackRequest.slackUserId,
+                });
+                return;
+            }
+            await IncidentEpisodeService.resolveEpisode(episodeId, userId);
+            return;
+        }
+        // invalid action type.
+        return Response.sendErrorResponse(req, res, new BadDataException("Invalid Action Type"));
+    }
+    static async viewExecuteOnCallPolicy(data) {
+        const { req, res } = data;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        // We send this early let slack know we're ok. We'll do the rest in the background.
+        Response.sendJsonObjectResponse(req, res, {
+            response_action: "clear",
+        });
+        const onCallPolicies = await OnCallDutyPolicyService.findBy({
+            query: {
+                projectId: data.slackRequest.projectId,
+            },
+            select: {
+                name: true,
+            },
+            props: {
+                isRoot: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+        });
+        const dropdownOption = onCallPolicies
+            .map((policy) => {
+            var _a;
+            return {
+                label: policy.name || "",
+                value: ((_a = policy._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
+            };
+        })
+            .filter((option) => {
+            return option.label !== "" || option.value !== "";
+        });
+        const onCallPolicyDropdown = {
+            _type: "WorkspaceDropdownBlock",
+            label: "On Call Policy",
+            blockId: "onCallPolicy",
+            placeholder: "Select On Call Policy",
+            options: dropdownOption,
+        };
+        const modalBlock = {
+            _type: "WorkspaceModalBlock",
+            title: "Execute On Call Policy",
+            submitButtonTitle: "Submit",
+            cancelButtonTitle: "Cancel",
+            actionId: SlackActionType.SubmitExecuteIncidentEpisodeOnCallPolicy,
+            actionValue: actionValue,
+            blocks: [onCallPolicyDropdown],
+        };
+        await SlackUtil.showModalToUser({
+            authToken: data.slackRequest.projectAuthToken,
+            modalBlock: modalBlock,
+            triggerId: data.slackRequest.triggerId,
+        });
+    }
+    static async viewChangeIncidentEpisodeState(data) {
+        const { req, res } = data;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        // We send this early let slack know we're ok. We'll do the rest in the background.
+        Response.sendJsonObjectResponse(req, res, {
+            response_action: "clear",
+        });
+        // Incident Episodes use incident states
+        const incidentStates = await IncidentStateService.getAllIncidentStates({
+            projectId: data.slackRequest.projectId,
+            props: {
+                isRoot: true,
+            },
+        });
+        const dropdownOptions = incidentStates
+            .map((state) => {
+            var _a;
+            return {
+                label: state.name || "",
+                value: ((_a = state._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
+            };
+        })
+            .filter((option) => {
+            return option.label !== "" || option.value !== "";
+        });
+        const statePickerDropdown = {
+            _type: "WorkspaceDropdownBlock",
+            label: "Episode State",
+            blockId: "episodeState",
+            placeholder: "Select Episode State",
+            options: dropdownOptions,
+        };
+        const modalBlock = {
+            _type: "WorkspaceModalBlock",
+            title: "Change Episode State",
+            submitButtonTitle: "Submit",
+            cancelButtonTitle: "Cancel",
+            actionId: SlackActionType.SubmitChangeIncidentEpisodeState,
+            actionValue: actionValue,
+            blocks: [statePickerDropdown],
+        };
+        await SlackUtil.showModalToUser({
+            authToken: data.slackRequest.projectAuthToken,
+            modalBlock: modalBlock,
+            triggerId: data.slackRequest.triggerId,
+        });
+    }
+    static async submitChangeIncidentEpisodeState(data) {
+        const { req, res } = data;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        // We send this early let slack know we're ok. We'll do the rest in the background.
+        Response.sendJsonObjectResponse(req, res, {
+            response_action: "clear",
+        });
+        if (!data.slackRequest.viewValues ||
+            !data.slackRequest.viewValues["episodeState"]) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid View Values"));
+        }
+        const episodeId = new ObjectID(actionValue);
+        const stateString = data.slackRequest.viewValues["episodeState"].toString();
+        const stateId = new ObjectID(stateString);
+        await IncidentEpisodeService.updateOneById({
+            id: episodeId,
+            data: {
+                currentIncidentStateId: stateId,
+            },
+            props: await AccessTokenService.getDatabaseCommonInteractionPropsByUserAndProject({
+                userId: data.slackRequest.userId,
+                projectId: data.slackRequest.projectId,
+            }),
+        });
+        // Log the button interaction
+        if (data.slackRequest.projectId && data.slackRequest.userId) {
+            try {
+                const logData = {
+                    projectId: data.slackRequest.projectId,
+                    workspaceType: WorkspaceType.Slack,
+                    userId: data.slackRequest.userId,
+                    buttonAction: "change_incident_episode_state",
+                };
+                if (data.slackRequest.slackChannelId) {
+                    logData.channelId = data.slackRequest.slackChannelId;
+                }
+                logData.incidentEpisodeId = episodeId;
+                await WorkspaceNotificationLogService.logButtonPressed(logData, {
+                    isRoot: true,
+                });
+            }
+            catch (err) {
+                logger.error("Error logging button interaction:");
+                logger.error(err);
+                // Don't throw the error, just log it so the main flow continues
+            }
+        }
+    }
+    static async executeOnCallPolicy(data) {
+        const { slackRequest, req, res } = data;
+        const { botUserId, userId, projectAuthToken, slackUsername } = slackRequest;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        if (!userId) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid User ID"));
+        }
+        if (!projectAuthToken) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Project Auth Token"));
+        }
+        if (!botUserId) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Bot User ID"));
+        }
+        if (data.action.actionType ===
+            SlackActionType.SubmitExecuteIncidentEpisodeOnCallPolicy) {
+            const episodeId = new ObjectID(actionValue);
+            // We send this early let slack know we're ok. We'll do the rest in the background.
+            Response.sendJsonObjectResponse(req, res, {
+                response_action: "clear",
+            });
+            const isAlreadyResolved = await IncidentEpisodeService.isEpisodeResolved(episodeId);
+            if (isAlreadyResolved) {
+                // send a message to the channel visible to user, that the episode has already been Resolved.
+                const markdwonPayload = {
+                    _type: "WorkspacePayloadMarkdown",
+                    text: `@${slackUsername}, unfortunately you cannot execute the on-call policy for **[Incident Episode](${await IncidentEpisodeService.getEpisodeLinkInDashboard(slackRequest.projectId, episodeId)})**. It has already been resolved.`,
+                };
+                await SlackUtil.sendDirectMessageToUser({
+                    messageBlocks: [markdwonPayload],
+                    authToken: projectAuthToken,
+                    workspaceUserId: slackRequest.slackUserId,
+                });
+                return;
+            }
+            if (!data.slackRequest.viewValues ||
+                !data.slackRequest.viewValues["onCallPolicy"]) {
+                return Response.sendErrorResponse(req, res, new BadDataException("Invalid View Values"));
+            }
+            const onCallPolicyString = data.slackRequest.viewValues["onCallPolicy"].toString();
+            // get the on-call policy id.
+            const onCallPolicyId = new ObjectID(onCallPolicyString);
+            await OnCallDutyPolicyService.executePolicy(onCallPolicyId, {
+                triggeredByIncidentEpisodeId: episodeId,
+                userNotificationEventType: UserNotificationEventType.IncidentEpisodeCreated,
+            });
+        }
+    }
+    static async submitIncidentEpisodeNote(data) {
+        const { req, res } = data;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        if (!data.slackRequest.viewValues) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid View Values"));
+        }
+        if (!data.slackRequest.viewValues["note"]) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Note"));
+        }
+        const episodeId = new ObjectID(actionValue);
+        const note = data.slackRequest.viewValues["note"].toString();
+        // send empty response.
+        Response.sendJsonObjectResponse(req, res, {
+            response_action: "clear",
+        });
+        await IncidentEpisodeInternalNoteService.addNote({
+            incidentEpisodeId: episodeId,
+            note: note || "",
+            projectId: data.slackRequest.projectId,
+            userId: data.slackRequest.userId,
+        });
+    }
+    static async viewAddIncidentEpisodeNote(data) {
+        const { req, res } = data;
+        const { actionValue } = data.action;
+        if (!actionValue) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Incident Episode ID"));
+        }
+        // We send this early let slack know we're ok. We'll do the rest in the background.
+        Response.sendJsonObjectResponse(req, res, {
+            response_action: "clear",
+        });
+        const noteTextArea = {
+            _type: "WorkspaceTextAreaBlock",
+            label: "Note",
+            blockId: "note",
+            placeholder: "Note",
+            description: "Please type in plain text or markdown.",
+        };
+        const modalBlock = {
+            _type: "WorkspaceModalBlock",
+            title: "Add Note",
+            submitButtonTitle: "Submit",
+            cancelButtonTitle: "Cancel",
+            actionId: SlackActionType.SubmitIncidentEpisodeNote,
+            actionValue: actionValue,
+            blocks: [noteTextArea],
+        };
+        await SlackUtil.showModalToUser({
+            authToken: data.slackRequest.projectAuthToken,
+            modalBlock: modalBlock,
+            triggerId: data.slackRequest.triggerId,
+        });
+    }
+    static async handleIncidentEpisodeAction(data) {
+        const actionType = data.action.actionType;
+        if (actionType === SlackActionType.AcknowledgeIncidentEpisode) {
+            return await this.acknowledgeIncidentEpisode(data);
+        }
+        if (actionType === SlackActionType.ResolveIncidentEpisode) {
+            return await this.resolveIncidentEpisode(data);
+        }
+        if (actionType === SlackActionType.ViewAddIncidentEpisodeNote) {
+            return await this.viewAddIncidentEpisodeNote(data);
+        }
+        if (actionType === SlackActionType.SubmitIncidentEpisodeNote) {
+            return await this.submitIncidentEpisodeNote(data);
+        }
+        if (actionType === SlackActionType.ViewExecuteIncidentEpisodeOnCallPolicy) {
+            return await this.viewExecuteOnCallPolicy(data);
+        }
+        if (actionType === SlackActionType.SubmitExecuteIncidentEpisodeOnCallPolicy) {
+            return await this.executeOnCallPolicy(data);
+        }
+        if (actionType === SlackActionType.ViewChangeIncidentEpisodeState) {
+            return await this.viewChangeIncidentEpisodeState(data);
+        }
+        if (actionType === SlackActionType.SubmitChangeIncidentEpisodeState) {
+            return await this.submitChangeIncidentEpisodeState(data);
+        }
+        if (actionType === SlackActionType.ViewIncidentEpisode) {
+            // do nothing. This is just a view episode action.
+            return Response.sendJsonObjectResponse(data.req, data.res, {
+                response_action: "clear",
+            });
+        }
+        // invalid action type.
+        return Response.sendErrorResponse(data.req, data.res, new BadDataException("Invalid Action Type"));
+    }
+    static async handleEmojiReaction(data) {
+        logger.debug("Handling emoji reaction for Incident Episode with data:");
+        logger.debug(data);
+        const { teamId, reaction, userId, channelId, messageTs } = data;
+        // Incident Episodes only support private notes
+        const isPrivateNoteEmoji = PrivateNoteEmojis.includes(reaction);
+        if (!isPrivateNoteEmoji) {
+            logger.debug(`Emoji "${reaction}" is not a supported private note emoji for incident episodes. Ignoring.`);
+            return;
+        }
+        // Get the project auth token using the team ID
+        const projectAuth = await WorkspaceProjectAuthTokenService.findOneBy({
+            query: {
+                workspaceProjectId: teamId,
+            },
+            select: {
+                projectId: true,
+                authToken: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!projectAuth || !projectAuth.projectId || !projectAuth.authToken) {
+            logger.debug("No project auth found for team ID. Ignoring emoji reaction.");
+            return;
+        }
+        const projectId = projectAuth.projectId;
+        const authToken = projectAuth.authToken;
+        // Find the incident episode linked to this channel
+        const workspaceLog = await WorkspaceNotificationLogService.findOneBy({
+            query: {
+                channelId: channelId,
+                workspaceType: WorkspaceType.Slack,
+                projectId: projectId,
+            },
+            select: {
+                incidentEpisodeId: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!workspaceLog || !workspaceLog.incidentEpisodeId) {
+            logger.debug("No incident episode found linked to this channel. Ignoring emoji reaction.");
+            return;
+        }
+        const episodeId = workspaceLog.incidentEpisodeId;
+        // Get the user ID in OneUptime based on Slack user ID
+        const userAuth = await WorkspaceUserAuthTokenService.findOneBy({
+            query: {
+                workspaceUserId: userId,
+                workspaceType: WorkspaceType.Slack,
+                projectId: projectId,
+            },
+            select: {
+                userId: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!userAuth || !userAuth.userId) {
+            logger.debug("No OneUptime user found for Slack user. Ignoring emoji reaction.");
+            return;
+        }
+        const oneUptimeUserId = userAuth.userId;
+        // Fetch the message text using the timestamp
+        let messageText = null;
+        try {
+            messageText = await SlackUtil.getMessageByTimestamp({
+                authToken: authToken,
+                channelId: channelId,
+                messageTs: messageTs,
+            });
+        }
+        catch (err) {
+            logger.error("Error fetching message text:");
+            logger.error(err);
+            return;
+        }
+        if (!messageText) {
+            logger.debug("No message text found. Ignoring emoji reaction.");
+            return;
+        }
+        // Create a unique identifier for this Slack message to prevent duplicate notes
+        const postedFromSlackMessageId = `${channelId}:${messageTs}`;
+        // Check if a note from this Slack message already exists
+        const hasExistingNote = await IncidentEpisodeInternalNoteService.hasNoteFromSlackMessage({
+            incidentEpisodeId: episodeId,
+            postedFromSlackMessageId: postedFromSlackMessageId,
+        });
+        if (hasExistingNote) {
+            logger.debug("Private note from this Slack message already exists. Skipping duplicate.");
+            return;
+        }
+        // Save as private note
+        try {
+            await IncidentEpisodeInternalNoteService.addNote({
+                incidentEpisodeId: episodeId,
+                note: messageText,
+                projectId: projectId,
+                userId: oneUptimeUserId,
+                postedFromSlackMessageId: postedFromSlackMessageId,
+            });
+            logger.debug("Private note added to incident episode successfully.");
+        }
+        catch (err) {
+            logger.error("Error saving note:");
+            logger.error(err);
+            return;
+        }
+        // Send confirmation message as a reply to the original message thread
+        try {
+            const episodeLink = (await IncidentEpisodeService.getEpisodeLinkInDashboard(projectId, episodeId)).toString();
+            const confirmationMessage = `Message saved as *private note* to <${episodeLink}|Incident Episode>.`;
+            await SlackUtil.sendMessageToThread({
+                authToken: authToken,
+                channelId: channelId,
+                threadTs: messageTs,
+                text: confirmationMessage,
+            });
+            logger.debug("Confirmation message sent successfully.");
+        }
+        catch (err) {
+            logger.error("Error sending confirmation message:");
+            logger.error(err);
+            // Don't throw - note was saved successfully, confirmation is best effort
+        }
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Boolean)
+], SlackIncidentEpisodeActions, "isIncidentEpisodeAction", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "acknowledgeIncidentEpisode", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "resolveIncidentEpisode", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "viewExecuteOnCallPolicy", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "viewChangeIncidentEpisodeState", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "submitChangeIncidentEpisodeState", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "executeOnCallPolicy", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "submitIncidentEpisodeNote", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "viewAddIncidentEpisodeNote", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "handleIncidentEpisodeAction", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SlackIncidentEpisodeActions, "handleEmojiReaction", null);
+//# sourceMappingURL=IncidentEpisode.js.map