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 IncidentEpisodePublicNoteService from "../../../../Services/IncidentEpisodePublicNoteService";
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 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) {
        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 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:", {
                        projectId: (_a = slackRequest.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
                        episodeId: episodeId.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 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.sendTextResponse(req, res, "");
        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.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.sendTextResponse(req, res, "");
        // 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.changeEpisodeState({
            projectId: data.slackRequest.projectId,
            episodeId: episodeId,
            incidentStateId: 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_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["noteType"]) {
            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Note Type"));
        }
        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();
        const noteType = data.slackRequest.viewValues["noteType"].toString();
        if (noteType !== "public" && noteType !== "private") {
            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Note Type"));
        }
        // send empty response.
        Response.sendJsonObjectResponse(req, res, {
            response_action: "clear",
        });
        // if public note then, add a note.
        if (noteType === "public") {
            await IncidentEpisodePublicNoteService.addNote({
                incidentEpisodeId: episodeId,
                note: note || "",
                projectId: data.slackRequest.projectId,
                userId: data.slackRequest.userId,
            });
        }
        // if private note then, add a note.
        if (noteType === "private") {
            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.sendTextResponse(req, res, "");
        const notePickerDropdown = {
            _type: "WorkspaceDropdownBlock",
            label: "Note Type",
            blockId: "noteType",
            placeholder: "Select Note Type",
            options: [
                {
                    label: "Public Note (Will be posted on Status Page)",
                    value: "public",
                },
                {
                    label: "Private Note (Only visible to team members)",
                    value: "private",
                },
            ],
        };
        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: [notePickerDropdown, 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