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 AlertEpisodeService from "../../../../Services/AlertEpisodeService";
import SlackUtil from "../Slack";
import SlackActionType, { PrivateNoteEmojis } from "./ActionTypes";
import Response from "../../../Response";
import AlertEpisodeInternalNoteService from "../../../../Services/AlertEpisodeInternalNoteService";
import OnCallDutyPolicyService from "../../../../Services/OnCallDutyPolicyService";
import { LIMIT_PER_PROJECT } from "../../../../../Types/Database/LimitMax";
import UserNotificationEventType from "../../../../../Types/UserNotification/UserNotificationEventType";
import AlertStateService from "../../../../Services/AlertStateService";
import logger from "../../../Logger";
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 SlackAlertEpisodeActions {
    static isAlertEpisodeAction(data) {
        const { actionType } = data;
        switch (actionType) {
            case SlackActionType.AcknowledgeAlertEpisode:
            case SlackActionType.ResolveAlertEpisode:
            case SlackActionType.ViewAddAlertEpisodeNote:
            case SlackActionType.SubmitAlertEpisodeNote:
            case SlackActionType.ViewChangeAlertEpisodeState:
            case SlackActionType.SubmitChangeAlertEpisodeState:
            case SlackActionType.ViewExecuteAlertEpisodeOnCallPolicy:
            case SlackActionType.SubmitExecuteAlertEpisodeOnCallPolicy:
            case SlackActionType.ViewAlertEpisode:
                return true;
            default:
                return false;
        }
    }
    static async acknowledgeAlertEpisode(data) {
        var _a;
        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 Alert 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.AcknowledgeAlertEpisode) {
            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 AlertEpisodeService.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 **[Alert Episode](${await AlertEpisodeService.getEpisodeLinkInDashboard(slackRequest.projectId, episodeId)})**. It has already been acknowledged.`,
                };
                await SlackUtil.sendDirectMessageToUser({
                    messageBlocks: [markdwonPayload],
                    authToken: projectAuthToken,
                    workspaceUserId: slackRequest.slackUserId,
                });
                return;
            }
            await AlertEpisodeService.acknowledgeEpisode(episodeId, userId);
            // Log the button interaction
            if (slackRequest.projectId) {
                try {
                    const logData = {
                        projectId: slackRequest.projectId,
                        workspaceType: WorkspaceType.Slack,
                        userId: userId,
                        buttonAction: "acknowledge_alert_episode",
                    };
                    if (slackRequest.slackChannelId) {
                        logData.channelId = slackRequest.slackChannelId;
                    }
                    logData.alertEpisodeId = episodeId;
                    await WorkspaceNotificationLogService.logButtonPressed(logData, {
                        isRoot: true,
                    });
                }
                catch (err) {
                    logger.error("Error logging button interaction:", {
                        projectId: (_a = slackRequest.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
                    });
                    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 resolveAlertEpisode(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 Alert 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.ResolveAlertEpisode) {
            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 AlertEpisodeService.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 **[Alert Episode](${await AlertEpisodeService.getEpisodeLinkInDashboard(slackRequest.projectId, episodeId)})**. It has already been resolved.`,
                };
                await SlackUtil.sendDirectMessageToUser({
                    messageBlocks: [markdwonPayload],
                    authToken: projectAuthToken,
                    workspaceUserId: slackRequest.slackUserId,
                });
                return;
            }
            await AlertEpisodeService.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 Alert 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 !== "";
        });
        if (dropdownOption.length === 0) {
            if (data.slackRequest.slackChannelId) {
                await SlackUtil.sendEphemeralMessageToChannel({
                    messageBlocks: [
                        {
                            _type: "WorkspacePayloadMarkdown",
                            text: "No on-call policies have been configured for this project yet. Please add an on-call policy in the OneUptime Dashboard under On-Call Duty > Policies to use this feature.",
                        },
                    ],
                    authToken: data.slackRequest.projectAuthToken,
                    channelId: data.slackRequest.slackChannelId,
                    userId: data.slackRequest.slackUserId,
                });
            }
            return;
        }
        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.SubmitExecuteAlertEpisodeOnCallPolicy,
            actionValue: actionValue,
            blocks: [onCallPolicyDropdown],
        };
        await SlackUtil.showModalToUser({
            authToken: data.slackRequest.projectAuthToken,
            modalBlock: modalBlock,
            triggerId: data.slackRequest.triggerId,
        });
    }
    static async viewChangeAlertEpisodeState(data) {
        const { req, res } = data;
        const { actionValue } = data.action;
        if (!actionValue) {
            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Alert 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",
        });
        // Alert Episodes use the same alert states
        const alertStates = await AlertStateService.getAllAlertStates({
            projectId: data.slackRequest.projectId,
            props: {
                isRoot: true,
            },
        });
        const dropdownOptions = alertStates
            .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.SubmitChangeAlertEpisodeState,
            actionValue: actionValue,
            blocks: [statePickerDropdown],
        };
        await SlackUtil.showModalToUser({
            authToken: data.slackRequest.projectAuthToken,
            modalBlock: modalBlock,
            triggerId: data.slackRequest.triggerId,
        });
    }
    static async submitChangeAlertEpisodeState(data) {
        var _a;
        const { req, res } = data;
        const { actionValue } = data.action;
        if (!actionValue) {
            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Alert 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 AlertEpisodeService.changeEpisodeState({
            projectId: data.slackRequest.projectId,
            episodeId: episodeId,
            alertStateId: stateId,
            notifyOwners: true,
            rootCause: "State changed via Slack.",
            props: {
                isRoot: true,
                userId: data.slackRequest.userId,
            },
        });
        // 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_alert_episode_state",
                };
                if (data.slackRequest.slackChannelId) {
                    logData.channelId = data.slackRequest.slackChannelId;
                }
                logData.alertEpisodeId = episodeId;
                await WorkspaceNotificationLogService.logButtonPressed(logData, {
                    isRoot: true,
                });
            }
            catch (err) {
                logger.error("Error logging button interaction:", {
                    projectId: (_a = data.slackRequest.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
                    alertEpisodeId: episodeId.toString(),
                });
                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 Alert 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.SubmitExecuteAlertEpisodeOnCallPolicy) {
            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 AlertEpisodeService.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 **[Alert Episode](${await AlertEpisodeService.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, {
                triggeredByAlertEpisodeId: episodeId,
                userNotificationEventType: UserNotificationEventType.AlertCreated,
            });
        }
    }
    static async submitAlertEpisodeNote(data) {
        const { req, res } = data;
        const { actionValue } = data.action;
        if (!actionValue) {
            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Alert 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 AlertEpisodeInternalNoteService.addNote({
            alertEpisodeId: episodeId,
            note: note || "",
            projectId: data.slackRequest.projectId,
            userId: data.slackRequest.userId,
        });
    }
    static async viewAddAlertEpisodeNote(data) {
        const { req, res } = data;
        const { actionValue } = data.action;
        if (!actionValue) {
            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Alert 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.SubmitAlertEpisodeNote,
            actionValue: actionValue,
            blocks: [noteTextArea],
        };
        await SlackUtil.showModalToUser({
            authToken: data.slackRequest.projectAuthToken,
            modalBlock: modalBlock,
            triggerId: data.slackRequest.triggerId,
        });
    }
    static async handleAlertEpisodeAction(data) {
        const actionType = data.action.actionType;
        if (actionType === SlackActionType.AcknowledgeAlertEpisode) {
            return await this.acknowledgeAlertEpisode(data);
        }
        if (actionType === SlackActionType.ResolveAlertEpisode) {
            return await this.resolveAlertEpisode(data);
        }
        if (actionType === SlackActionType.ViewAddAlertEpisodeNote) {
            return await this.viewAddAlertEpisodeNote(data);
        }
        if (actionType === SlackActionType.SubmitAlertEpisodeNote) {
            return await this.submitAlertEpisodeNote(data);
        }
        if (actionType === SlackActionType.ViewExecuteAlertEpisodeOnCallPolicy) {
            return await this.viewExecuteOnCallPolicy(data);
        }
        if (actionType === SlackActionType.SubmitExecuteAlertEpisodeOnCallPolicy) {
            return await this.executeOnCallPolicy(data);
        }
        if (actionType === SlackActionType.ViewChangeAlertEpisodeState) {
            return await this.viewChangeAlertEpisodeState(data);
        }
        if (actionType === SlackActionType.SubmitChangeAlertEpisodeState) {
            return await this.submitChangeAlertEpisodeState(data);
        }
        if (actionType === SlackActionType.ViewAlertEpisode) {
            // 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 Alert Episode with data:", {
            channelId: data.channelId,
        });
        logger.debug(data);
        const { teamId, reaction, userId, channelId, messageTs } = data;
        // Alert Episodes only support private notes
        const isPrivateNoteEmoji = PrivateNoteEmojis.includes(reaction);
        if (!isPrivateNoteEmoji) {
            logger.debug(`Emoji "${reaction}" is not a supported private note emoji for alert 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 alert episode linked to this channel
        const workspaceLog = await WorkspaceNotificationLogService.findOneBy({
            query: {
                channelId: channelId,
                workspaceType: WorkspaceType.Slack,
                projectId: projectId,
            },
            select: {
                alertEpisodeId: true,
            },
            props: {
                isRoot: true,
            },
        });
        if (!workspaceLog || !workspaceLog.alertEpisodeId) {
            logger.debug("No alert episode found linked to this channel. Ignoring emoji reaction.");
            return;
        }
        const episodeId = workspaceLog.alertEpisodeId;
        // 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:", {
                projectId: projectId.toString(),
                alertEpisodeId: episodeId.toString(),
                channelId: channelId,
            });
            logger.error(err);
            return;
        }
        if (!messageText) {
            logger.debug("No message text found. Ignoring emoji reaction.", {
                projectId: projectId.toString(),
                alertEpisodeId: episodeId.toString(),
                channelId: channelId,
            });
            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 AlertEpisodeInternalNoteService.hasNoteFromSlackMessage({
            alertEpisodeId: episodeId,
            postedFromSlackMessageId: postedFromSlackMessageId,
        });
        if (hasExistingNote) {
            logger.debug("Private note from this Slack message already exists. Skipping duplicate.");
            return;
        }
        // Save as private note
        try {
            await AlertEpisodeInternalNoteService.addNote({
                alertEpisodeId: episodeId,
                note: messageText,
                projectId: projectId,
                userId: oneUptimeUserId,
                postedFromSlackMessageId: postedFromSlackMessageId,
            });
            logger.debug("Private note added to alert episode successfully.", {
                projectId: projectId.toString(),
                alertEpisodeId: episodeId.toString(),
            });
        }
        catch (err) {
            logger.error("Error saving note:", {
                projectId: projectId.toString(),
                alertEpisodeId: episodeId.toString(),
            });
            logger.error(err);
            return;
        }
        // Send confirmation message as a reply to the original message thread
        try {
            const episodeLink = (await AlertEpisodeService.getEpisodeLinkInDashboard(projectId, episodeId)).toString();
            const confirmationMessage = `✅ Message saved as *private note* to <${episodeLink}|Alert 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:", {
                projectId: projectId.toString(),
                alertEpisodeId: episodeId.toString(),
            });
            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)
], SlackAlertEpisodeActions, "isAlertEpisodeAction", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "acknowledgeAlertEpisode", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "resolveAlertEpisode", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "viewExecuteOnCallPolicy", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "viewChangeAlertEpisodeState", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "submitChangeAlertEpisodeState", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "executeOnCallPolicy", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "submitAlertEpisodeNote", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "viewAddAlertEpisodeNote", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "handleAlertEpisodeAction", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], SlackAlertEpisodeActions, "handleEmojiReaction", null);
//# sourceMappingURL=AlertEpisode.js.map