@automate.ax/integration-contracts 0.95.4 → 0.97.0

package/dist/slack/event-schemas.js

@@ -0,0 +1,714 @@
+import * as z from "zod";
+import { SLACK_MEMBER_SCHEMA, SLACK_MESSAGE_SCHEMA, SLACK_PROVIDER_MEMBER_SCHEMA, SLACK_PROVIDER_MESSAGE_SCHEMA, SLACK_REACTION_ITEM_SCHEMA, toSlackMember, toSlackMessage, } from "./schemas.js";
+export const SLACK_CONVERSATION_TYPE_SCHEMA = z.enum([
+    "channel",
+    "group",
+    "im",
+    "mpim",
+]);
+const SLACK_EVENT_TIMESTAMP_SCHEMA = z.string();
+export const SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA = SLACK_PROVIDER_MESSAGE_SCHEMA.extend({
+    channel: z.string(),
+    channel_type: SLACK_CONVERSATION_TYPE_SCHEMA.optional(),
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    type: z.literal("message"),
+});
+export const SLACK_PROVIDER_ORDINARY_MESSAGE_EVENT_SCHEMA = SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA.extend({
+    app_id: z.undefined().optional(),
+    bot_id: z.undefined().optional(),
+    channel_type: SLACK_CONVERSATION_TYPE_SCHEMA,
+    hidden: z.literal(false).optional(),
+    subtype: z.undefined().optional(),
+    type: z.literal("message"),
+    user: z.string(),
+});
+export const SLACK_PROVIDER_APP_MENTION_EVENT_SCHEMA = SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA.extend({
+    text: z.string(),
+    type: z.literal("app_mention"),
+    user: z.string().optional(),
+});
+export const SLACK_PROVIDER_MESSAGE_CHANGED_EVENT_SCHEMA = z
+    .object({
+    channel: z.string(),
+    channel_type: SLACK_CONVERSATION_TYPE_SCHEMA,
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    hidden: z.literal(true),
+    message: SLACK_PROVIDER_MESSAGE_SCHEMA,
+    previous_message: SLACK_PROVIDER_MESSAGE_SCHEMA,
+    subtype: z.literal("message_changed"),
+    ts: z.string(),
+    type: z.literal("message"),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_MESSAGE_DELETED_EVENT_SCHEMA = z
+    .object({
+    channel: z.string(),
+    channel_type: SLACK_CONVERSATION_TYPE_SCHEMA,
+    deleted_ts: z.string(),
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    hidden: z.literal(true),
+    previous_message: SLACK_PROVIDER_MESSAGE_SCHEMA.optional(),
+    subtype: z.literal("message_deleted"),
+    ts: z.string(),
+    type: z.literal("message"),
+})
+    .catchall(z.json());
+const SLACK_PROVIDER_REACTION_ITEM_SCHEMA = z.discriminatedUnion("type", [
+    z
+        .object({
+        channel: z.string(),
+        channel_type: SLACK_CONVERSATION_TYPE_SCHEMA.optional(),
+        ts: z.string(),
+        type: z.literal("message"),
+    })
+        .catchall(z.json()),
+    z.object({ file: z.string(), type: z.literal("file") }).catchall(z.json()),
+    z
+        .object({
+        file: z.string(),
+        file_comment: z.string(),
+        type: z.literal("file_comment"),
+    })
+        .catchall(z.json()),
+]);
+const SLACK_PROVIDER_REACTION_EVENT_BASE_SCHEMA = z
+    .object({
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    item: SLACK_PROVIDER_REACTION_ITEM_SCHEMA,
+    item_user: z.string().optional(),
+    reaction: z.string(),
+    user: z.string(),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_REACTION_ADDED_EVENT_SCHEMA = SLACK_PROVIDER_REACTION_EVENT_BASE_SCHEMA.extend({
+    type: z.literal("reaction_added"),
+});
+export const SLACK_PROVIDER_REACTION_REMOVED_EVENT_SCHEMA = SLACK_PROVIDER_REACTION_EVENT_BASE_SCHEMA.extend({
+    type: z.literal("reaction_removed"),
+});
+export const SLACK_MEMBERSHIP_CONVERSATION_TYPE_CODE_SCHEMA = z.enum(["C", "G"]);
+const SLACK_PROVIDER_CHANNEL_MEMBERSHIP_EVENT_BASE_SCHEMA = z
+    .object({
+    channel: z.string(),
+    channel_type: SLACK_MEMBERSHIP_CONVERSATION_TYPE_CODE_SCHEMA,
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    team: z.string(),
+    user: z.string(),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_MEMBER_JOINED_CHANNEL_EVENT_SCHEMA = SLACK_PROVIDER_CHANNEL_MEMBERSHIP_EVENT_BASE_SCHEMA.extend({
+    enterprise: z.string().optional(),
+    inviter: z.string().optional(),
+    type: z.literal("member_joined_channel"),
+});
+export const SLACK_PROVIDER_MEMBER_LEFT_CHANNEL_EVENT_SCHEMA = SLACK_PROVIDER_CHANNEL_MEMBERSHIP_EVENT_BASE_SCHEMA.extend({
+    type: z.literal("member_left_channel"),
+});
+const SLACK_PROVIDER_FILE_EVENT_BASE_SCHEMA = z
+    .object({
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    file_id: z.string(),
+})
+    .catchall(z.json());
+const SLACK_PROVIDER_FILE_REFERENCE_SCHEMA = z
+    .object({ id: z.string() })
+    .catchall(z.json());
+export const SLACK_PROVIDER_FILE_CREATED_EVENT_SCHEMA = SLACK_PROVIDER_FILE_EVENT_BASE_SCHEMA.extend({
+    file: SLACK_PROVIDER_FILE_REFERENCE_SCHEMA,
+    type: z.literal("file_created"),
+    user_id: z.string(),
+});
+export const SLACK_PROVIDER_FILE_SHARED_EVENT_SCHEMA = SLACK_PROVIDER_FILE_EVENT_BASE_SCHEMA.extend({
+    channel_id: z.string(),
+    file: SLACK_PROVIDER_FILE_REFERENCE_SCHEMA,
+    type: z.literal("file_shared"),
+    user_id: z.string(),
+});
+export const SLACK_PROVIDER_FILE_DELETED_EVENT_SCHEMA = SLACK_PROVIDER_FILE_EVENT_BASE_SCHEMA.extend({
+    type: z.literal("file_deleted"),
+});
+export const SLACK_PROVIDER_TEAM_JOIN_EVENT_SCHEMA = z
+    .object({
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    type: z.literal("team_join"),
+    user: SLACK_PROVIDER_MEMBER_SCHEMA,
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_USER_CHANGE_EVENT_SCHEMA = z
+    .object({
+    cache_ts: z.number().int().nonnegative().optional(),
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    type: z.literal("user_change"),
+    user: SLACK_PROVIDER_MEMBER_SCHEMA,
+})
+    .catchall(z.json());
+const SLACK_PROVIDER_CHANNEL_SCHEMA = z
+    .object({
+    created: z.number().int().nonnegative(),
+    id: z.string(),
+    is_channel: z.boolean().optional(),
+    is_mpim: z.boolean().optional(),
+    name: z.string(),
+    name_normalized: z.string().optional(),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_CHANNEL_CREATED_EVENT_SCHEMA = z
+    .object({
+    channel: SLACK_PROVIDER_CHANNEL_SCHEMA.extend({
+        context_team_id: z.string().optional(),
+        creator: z.string(),
+        is_archived: z.boolean().optional(),
+        is_ext_shared: z.boolean().optional(),
+        is_frozen: z.boolean().optional(),
+        is_general: z.boolean().optional(),
+        is_group: z.boolean().optional(),
+        is_im: z.boolean().optional(),
+        is_org_shared: z.boolean().optional(),
+        is_pending_ext_shared: z.boolean().optional(),
+        is_private: z.boolean().optional(),
+        is_shared: z.boolean().optional(),
+    }),
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    type: z.literal("channel_created"),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_CHANNEL_RENAME_EVENT_SCHEMA = z
+    .object({
+    channel: SLACK_PROVIDER_CHANNEL_SCHEMA,
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    type: z.literal("channel_rename"),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_CHANNEL_SHARED_EVENT_SCHEMA = z
+    .object({
+    channel: z.string(),
+    connected_team_id: z.string(),
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    type: z.literal("channel_shared"),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_CHANNEL_UNSHARED_EVENT_SCHEMA = z
+    .object({
+    channel: z.string(),
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    is_ext_shared: z.boolean(),
+    previously_connected_team_id: z.string(),
+    type: z.literal("channel_unshared"),
+})
+    .catchall(z.json());
+const SLACK_PROVIDER_PINNED_MESSAGE_SCHEMA = SLACK_PROVIDER_MESSAGE_SCHEMA.extend({
+    permalink: z.string().optional(),
+    user: z.string(),
+});
+const SLACK_PROVIDER_PIN_ITEM_SCHEMA = z
+    .object({
+    channel: z.string(),
+    created: z.number().optional(),
+    created_by: z.string().optional(),
+    file: SLACK_PROVIDER_FILE_REFERENCE_SCHEMA.optional(),
+    message: SLACK_PROVIDER_PINNED_MESSAGE_SCHEMA.optional(),
+    type: z.string(),
+})
+    .catchall(z.json());
+const SLACK_PROVIDER_PINNED_INFO_SCHEMA = z
+    .object({
+    channel: z.string(),
+    pinned_by: z.string(),
+    pinned_ts: z.number(),
+})
+    .catchall(z.json());
+const SLACK_PROVIDER_PIN_EVENT_BASE_SCHEMA = z
+    .object({
+    channel_id: z.string(),
+    event_ts: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    item: SLACK_PROVIDER_PIN_ITEM_SCHEMA,
+    item_user: z.string().optional(),
+    pin_count: z.string().optional(),
+    pinned_info: SLACK_PROVIDER_PINNED_INFO_SCHEMA.optional(),
+    user: z.string(),
+})
+    .catchall(z.json());
+export const SLACK_PROVIDER_PIN_ADDED_EVENT_SCHEMA = SLACK_PROVIDER_PIN_EVENT_BASE_SCHEMA.extend({ type: z.literal("pin_added") });
+export const SLACK_PROVIDER_PIN_REMOVED_EVENT_SCHEMA = SLACK_PROVIDER_PIN_EVENT_BASE_SCHEMA.extend({
+    has_pins: z.boolean().optional(),
+    type: z.literal("pin_removed"),
+});
+export const SLACK_SUPPORTED_PROVIDER_EVENT_SCHEMA = z.union([
+    SLACK_PROVIDER_APP_MENTION_EVENT_SCHEMA,
+    SLACK_PROVIDER_MESSAGE_CHANGED_EVENT_SCHEMA,
+    SLACK_PROVIDER_MESSAGE_DELETED_EVENT_SCHEMA,
+    SLACK_PROVIDER_ORDINARY_MESSAGE_EVENT_SCHEMA,
+    SLACK_PROVIDER_REACTION_ADDED_EVENT_SCHEMA,
+    SLACK_PROVIDER_REACTION_REMOVED_EVENT_SCHEMA,
+    SLACK_PROVIDER_MEMBER_JOINED_CHANNEL_EVENT_SCHEMA,
+    SLACK_PROVIDER_MEMBER_LEFT_CHANNEL_EVENT_SCHEMA,
+    SLACK_PROVIDER_FILE_CREATED_EVENT_SCHEMA,
+    SLACK_PROVIDER_FILE_SHARED_EVENT_SCHEMA,
+    SLACK_PROVIDER_FILE_DELETED_EVENT_SCHEMA,
+    SLACK_PROVIDER_TEAM_JOIN_EVENT_SCHEMA,
+    SLACK_PROVIDER_USER_CHANGE_EVENT_SCHEMA,
+    SLACK_PROVIDER_CHANNEL_CREATED_EVENT_SCHEMA,
+    SLACK_PROVIDER_CHANNEL_RENAME_EVENT_SCHEMA,
+    SLACK_PROVIDER_CHANNEL_SHARED_EVENT_SCHEMA,
+    SLACK_PROVIDER_CHANNEL_UNSHARED_EVENT_SCHEMA,
+    SLACK_PROVIDER_PIN_ADDED_EVENT_SCHEMA,
+    SLACK_PROVIDER_PIN_REMOVED_EVENT_SCHEMA,
+    SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA,
+]);
+export const SLACK_EVENT_AUTHORIZATION_SCHEMA = z
+    .object({
+    enterprise_id: z.string().nullable().optional(),
+    is_bot: z.boolean(),
+    is_enterprise_install: z.boolean().optional(),
+    team_id: z.string().nullable().optional(),
+    user_id: z.string().nullable().optional(),
+})
+    .catchall(z.json());
+export const SLACK_EVENT_CALLBACK_SCHEMA = z
+    .object({
+    api_app_id: z.string(),
+    authorizations: SLACK_EVENT_AUTHORIZATION_SCHEMA.array().optional(),
+    context_enterprise_id: z.string().nullable().optional(),
+    context_team_id: z.string().optional(),
+    event: SLACK_SUPPORTED_PROVIDER_EVENT_SCHEMA,
+    event_context: z.string().optional(),
+    event_id: z.string(),
+    event_time: z.number().int().nonnegative(),
+    is_ext_shared_channel: z.boolean().optional(),
+    team_id: z.string(),
+    type: z.literal("event_callback"),
+})
+    .catchall(z.json());
+const slackEventPayloadSchema = z
+    .object({
+    envelope: SLACK_EVENT_CALLBACK_SCHEMA,
+    event: SLACK_SUPPORTED_PROVIDER_EVENT_SCHEMA,
+    eventTimestamp: SLACK_EVENT_TIMESTAMP_SCHEMA,
+    workspaceId: z.string(),
+})
+    .catchall(z.json());
+const SLACK_MESSAGE_EVENT_BASE_SCHEMA = slackEventPayloadSchema.extend({
+    ...SLACK_MESSAGE_SCHEMA.shape,
+    conversationId: z.string(),
+    conversationType: SLACK_CONVERSATION_TYPE_SCHEMA.optional(),
+});
+export const SLACK_APP_MENTION_CALLBACK_EVENT_SCHEMA = SLACK_MESSAGE_EVENT_BASE_SCHEMA.extend({
+    event: SLACK_PROVIDER_APP_MENTION_EVENT_SCHEMA,
+    type: z.literal("app_mention"),
+});
+export const SLACK_MESSAGE_POSTED_CALLBACK_EVENT_SCHEMA = SLACK_MESSAGE_EVENT_BASE_SCHEMA.extend({
+    conversationType: SLACK_CONVERSATION_TYPE_SCHEMA,
+    event: SLACK_PROVIDER_ORDINARY_MESSAGE_EVENT_SCHEMA,
+    threadTimestamp: z.undefined().optional(),
+    type: z.literal("message"),
+});
+export const SLACK_THREAD_REPLY_POSTED_EVENT_SCHEMA = SLACK_MESSAGE_EVENT_BASE_SCHEMA.extend({
+    conversationType: SLACK_CONVERSATION_TYPE_SCHEMA,
+    event: SLACK_PROVIDER_ORDINARY_MESSAGE_EVENT_SCHEMA,
+    threadTimestamp: z.string(),
+    type: z.literal("message"),
+});
+export const SLACK_MESSAGE_CHANGED_EVENT_SCHEMA = slackEventPayloadSchema.extend({
+    conversationId: z.string(),
+    conversationType: SLACK_CONVERSATION_TYPE_SCHEMA,
+    event: SLACK_PROVIDER_MESSAGE_CHANGED_EVENT_SCHEMA,
+    message: SLACK_PROVIDER_MESSAGE_SCHEMA,
+    previousMessage: SLACK_PROVIDER_MESSAGE_SCHEMA,
+});
+export const SLACK_MESSAGE_DELETED_EVENT_SCHEMA = slackEventPayloadSchema.extend({
+    conversationId: z.string(),
+    conversationType: SLACK_CONVERSATION_TYPE_SCHEMA,
+    deletedTimestamp: z.string(),
+    event: SLACK_PROVIDER_MESSAGE_DELETED_EVENT_SCHEMA,
+    previousMessage: SLACK_PROVIDER_MESSAGE_SCHEMA.optional(),
+});
+export const SLACK_REACTION_CALLBACK_EVENT_SCHEMA = slackEventPayloadSchema.extend({
+    event: z.union([
+        SLACK_PROVIDER_REACTION_ADDED_EVENT_SCHEMA,
+        SLACK_PROVIDER_REACTION_REMOVED_EVENT_SCHEMA,
+    ]),
+    item: SLACK_REACTION_ITEM_SCHEMA,
+    itemUserId: z.string().optional(),
+    reaction: z.string(),
+    userId: z.string(),
+});
+export const SLACK_CHANNEL_MEMBER_EVENT_SCHEMA = slackEventPayloadSchema.extend({
+    conversationId: z.string(),
+    conversationTypeCode: SLACK_MEMBERSHIP_CONVERSATION_TYPE_CODE_SCHEMA,
+    enterpriseId: z.string().optional(),
+    inviterId: z.string().optional(),
+    userId: z.string(),
+});
+export const SLACK_FILE_EVENT_SCHEMA = slackEventPayloadSchema.extend({
+    channelId: z.string().optional(),
+    fileId: z.string(),
+    userId: z.string().optional(),
+});
+export const SLACK_WORKSPACE_MEMBER_EVENT_SCHEMA = slackEventPayloadSchema.extend({ member: SLACK_MEMBER_SCHEMA });
+export const SLACK_CHANNEL_EVENT_SCHEMA = slackEventPayloadSchema.extend({
+    channelId: z.string(),
+    connectedWorkspaceId: z.string().optional(),
+    createdAt: z.number().int().nonnegative().optional(),
+    creatorId: z.string().optional(),
+    isExternallyShared: z.boolean().optional(),
+    name: z.string().optional(),
+    previouslyConnectedWorkspaceId: z.string().optional(),
+});
+export const SLACK_PIN_EVENT_SCHEMA = slackEventPayloadSchema.extend({
+    conversationId: z.string(),
+    hasPins: z.boolean().optional(),
+    item: SLACK_PROVIDER_PIN_ITEM_SCHEMA,
+    userId: z.string(),
+});
+export const SLACK_CHANNEL_CREATED_EVENT_SCHEMA = SLACK_CHANNEL_EVENT_SCHEMA.extend({
+    createdAt: z.number().int().nonnegative(),
+    creatorId: z.string(),
+    event: SLACK_PROVIDER_CHANNEL_CREATED_EVENT_SCHEMA,
+    name: z.string(),
+});
+export const SLACK_CHANNEL_RENAMED_EVENT_SCHEMA = SLACK_CHANNEL_EVENT_SCHEMA.extend({
+    createdAt: z.number().int().nonnegative(),
+    event: SLACK_PROVIDER_CHANNEL_RENAME_EVENT_SCHEMA,
+    name: z.string(),
+});
+export const SLACK_CHANNEL_SHARED_EVENT_SCHEMA = SLACK_CHANNEL_EVENT_SCHEMA.extend({
+    connectedWorkspaceId: z.string(),
+    event: SLACK_PROVIDER_CHANNEL_SHARED_EVENT_SCHEMA,
+});
+export const SLACK_CHANNEL_UNSHARED_EVENT_SCHEMA = SLACK_CHANNEL_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_CHANNEL_UNSHARED_EVENT_SCHEMA,
+    isExternallyShared: z.boolean(),
+    previouslyConnectedWorkspaceId: z.string(),
+});
+export const SLACK_CHANNEL_MEMBER_JOINED_EVENT_SCHEMA = SLACK_CHANNEL_MEMBER_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_MEMBER_JOINED_CHANNEL_EVENT_SCHEMA,
+});
+export const SLACK_CHANNEL_MEMBER_LEFT_EVENT_SCHEMA = SLACK_CHANNEL_MEMBER_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_MEMBER_LEFT_CHANNEL_EVENT_SCHEMA,
+});
+export const SLACK_FILE_CREATED_EVENT_SCHEMA = SLACK_FILE_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_FILE_CREATED_EVENT_SCHEMA,
+    userId: z.string(),
+});
+export const SLACK_FILE_SHARED_EVENT_SCHEMA = SLACK_FILE_EVENT_SCHEMA.extend({
+    channelId: z.string(),
+    event: SLACK_PROVIDER_FILE_SHARED_EVENT_SCHEMA,
+    userId: z.string(),
+});
+export const SLACK_FILE_DELETED_EVENT_SCHEMA = SLACK_FILE_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_FILE_DELETED_EVENT_SCHEMA,
+});
+export const SLACK_PIN_ADDED_EVENT_SCHEMA = SLACK_PIN_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_PIN_ADDED_EVENT_SCHEMA,
+});
+export const SLACK_PIN_REMOVED_EVENT_SCHEMA = SLACK_PIN_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_PIN_REMOVED_EVENT_SCHEMA,
+    hasPins: z.boolean().optional(),
+});
+export const SLACK_REACTION_ADDED_CALLBACK_EVENT_SCHEMA = SLACK_REACTION_CALLBACK_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_REACTION_ADDED_EVENT_SCHEMA,
+});
+export const SLACK_REACTION_REMOVED_CALLBACK_EVENT_SCHEMA = SLACK_REACTION_CALLBACK_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_REACTION_REMOVED_EVENT_SCHEMA,
+});
+export const SLACK_WORKSPACE_MEMBER_JOINED_EVENT_SCHEMA = SLACK_WORKSPACE_MEMBER_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_TEAM_JOIN_EVENT_SCHEMA,
+});
+export const SLACK_WORKSPACE_MEMBER_CHANGED_EVENT_SCHEMA = SLACK_WORKSPACE_MEMBER_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_USER_CHANGE_EVENT_SCHEMA,
+});
+/** Typed union emitted by the broad Slack event trigger. */
+export const SLACK_EVENT_SCHEMA = z.union([
+    SLACK_APP_MENTION_CALLBACK_EVENT_SCHEMA,
+    SLACK_MESSAGE_POSTED_CALLBACK_EVENT_SCHEMA,
+    SLACK_THREAD_REPLY_POSTED_EVENT_SCHEMA,
+    SLACK_MESSAGE_CHANGED_EVENT_SCHEMA,
+    SLACK_MESSAGE_DELETED_EVENT_SCHEMA,
+    SLACK_REACTION_CALLBACK_EVENT_SCHEMA,
+    SLACK_CHANNEL_MEMBER_EVENT_SCHEMA,
+    SLACK_FILE_EVENT_SCHEMA,
+    SLACK_WORKSPACE_MEMBER_EVENT_SCHEMA,
+    SLACK_CHANNEL_EVENT_SCHEMA,
+    SLACK_PIN_EVENT_SCHEMA,
+    slackEventPayloadSchema,
+]);
+export const SLACK_RETRY_NUMBER_SCHEMA = z.coerce.number().int().min(1).max(3);
+export const SLACK_RETRY_REASON_SCHEMA = z.enum([
+    "http_error",
+    "connection_failed",
+    "ssl_error",
+    "http_timeout",
+    "too_many_redirects",
+    "unknown_error",
+]);
+/**
+ * Parses retry metadata sent by Slack for a repeated Events API delivery.
+ *
+ * @param headers - Signed Slack request headers.
+ */
+export function parseSlackRetryHeaders(headers) {
+    const number = headers.get("x-slack-retry-num");
+    const reason = headers.get("x-slack-retry-reason");
+    if (number === null && reason === null)
+        return;
+    return {
+        number: SLACK_RETRY_NUMBER_SCHEMA.parse(number),
+        reason: SLACK_RETRY_REASON_SCHEMA.parse(reason),
+    };
+}
+/**
+ * Converts one typed Slack callback into its broad and semantic events.
+ *
+ * @param input - Provider-native Events API callback envelope.
+ * @throws When the callback is not a supported Slack Events API envelope.
+ */
+export function normalizeSlackEventCallback(input) {
+    const envelope = SLACK_EVENT_CALLBACK_SCHEMA.parse(input);
+    const event = envelope.event;
+    const base = {
+        envelope,
+        event,
+        eventTimestamp: event.event_ts,
+        workspaceId: envelope.team_id,
+    };
+    switch (event.type) {
+        case "app_mention":
+            return {
+                eventTypes: ["slack.app.mentioned", "slack.event.received"],
+                payload: {
+                    ...base,
+                    ...toSlackMessage(event),
+                    conversationId: event.channel,
+                    conversationType: event.channel_type,
+                },
+            };
+        case "message": {
+            if (event.subtype === "message_changed") {
+                return {
+                    eventTypes: [
+                        "slack.message.changed",
+                        "slack.event.received",
+                    ],
+                    payload: {
+                        ...base,
+                        conversationId: event.channel,
+                        conversationType: event.channel_type,
+                        message: event.message,
+                        previousMessage: event.previous_message,
+                    },
+                };
+            }
+            if (event.subtype === "message_deleted") {
+                return {
+                    eventTypes: [
+                        "slack.message.deleted",
+                        "slack.event.received",
+                    ],
+                    payload: {
+                        ...base,
+                        conversationId: event.channel,
+                        conversationType: event.channel_type,
+                        deletedTimestamp: event.deleted_ts,
+                        previousMessage: event.previous_message,
+                    },
+                };
+            }
+            if (event.subtype !== undefined ||
+                event.hidden === true ||
+                event.bot_id !== undefined ||
+                event.app_id !== undefined ||
+                event.user === undefined) {
+                return {
+                    eventTypes: ["slack.event.received"],
+                    payload: base,
+                };
+            }
+            const message = {
+                ...base,
+                ...toSlackMessage(event),
+                conversationId: event.channel,
+                conversationType: event.channel_type,
+            };
+            return event.thread_ts && event.thread_ts !== event.ts
+                ? {
+                    eventTypes: [
+                        "slack.thread.reply.posted",
+                        "slack.event.received",
+                    ],
+                    payload: message,
+                }
+                : {
+                    eventTypes: [
+                        "slack.message.posted",
+                        "slack.event.received",
+                    ],
+                    payload: { ...message, threadTimestamp: undefined },
+                };
+        }
+        case "reaction_added":
+        case "reaction_removed": {
+            const reactionEvent = z
+                .union([
+                SLACK_PROVIDER_REACTION_ADDED_EVENT_SCHEMA,
+                SLACK_PROVIDER_REACTION_REMOVED_EVENT_SCHEMA,
+            ])
+                .parse(event);
+            return {
+                eventTypes: [
+                    reactionEvent.type === "reaction_added"
+                        ? "slack.reaction.added"
+                        : "slack.reaction.removed",
+                    "slack.reaction.event",
+                    "slack.event.received",
+                ],
+                payload: {
+                    ...base,
+                    item: normalizeReactionItem(reactionEvent.item),
+                    itemUserId: reactionEvent.item_user,
+                    reaction: reactionEvent.reaction,
+                    userId: reactionEvent.user,
+                },
+            };
+        }
+        case "member_joined_channel":
+        case "member_left_channel":
+            return {
+                eventTypes: [
+                    event.type === "member_joined_channel"
+                        ? "slack.channel.member.joined"
+                        : "slack.channel.member.left",
+                    "slack.event.received",
+                ],
+                payload: {
+                    ...base,
+                    conversationId: event.channel,
+                    conversationTypeCode: event.channel_type,
+                    enterpriseId: "enterprise" in event ? event.enterprise : undefined,
+                    inviterId: "inviter" in event ? event.inviter : undefined,
+                    userId: event.user,
+                },
+            };
+        case "file_created":
+        case "file_shared":
+        case "file_deleted":
+            return {
+                eventTypes: [
+                    event.type === "file_created"
+                        ? "slack.file.created"
+                        : event.type === "file_shared"
+                            ? "slack.file.shared"
+                            : "slack.file.deleted",
+                    "slack.event.received",
+                ],
+                payload: {
+                    ...base,
+                    channelId: "channel_id" in event ? event.channel_id : undefined,
+                    fileId: event.file_id,
+                    userId: "user_id" in event ? event.user_id : undefined,
+                },
+            };
+        case "team_join":
+        case "user_change": {
+            const memberEvent = z
+                .union([
+                SLACK_PROVIDER_TEAM_JOIN_EVENT_SCHEMA,
+                SLACK_PROVIDER_USER_CHANGE_EVENT_SCHEMA,
+            ])
+                .parse(event);
+            return {
+                eventTypes: [
+                    memberEvent.type === "team_join"
+                        ? "slack.workspace.member.joined"
+                        : "slack.workspace.member.changed",
+                    "slack.event.received",
+                ],
+                payload: { ...base, member: toSlackMember(memberEvent.user) },
+            };
+        }
+        case "channel_created":
+        case "channel_rename": {
+            const channelEvent = z
+                .union([
+                SLACK_PROVIDER_CHANNEL_CREATED_EVENT_SCHEMA,
+                SLACK_PROVIDER_CHANNEL_RENAME_EVENT_SCHEMA,
+            ])
+                .parse(event);
+            return {
+                eventTypes: [
+                    channelEvent.type === "channel_created"
+                        ? "slack.channel.created"
+                        : "slack.channel.renamed",
+                    "slack.event.received",
+                ],
+                payload: {
+                    ...base,
+                    channelId: channelEvent.channel.id,
+                    createdAt: channelEvent.channel.created,
+                    creatorId: "creator" in channelEvent.channel
+                        ? channelEvent.channel.creator
+                        : undefined,
+                    name: channelEvent.channel.name,
+                },
+            };
+        }
+        case "channel_shared":
+        case "channel_unshared":
+            return {
+                eventTypes: [
+                    event.type === "channel_shared"
+                        ? "slack.channel.shared"
+                        : "slack.channel.unshared",
+                    "slack.event.received",
+                ],
+                payload: {
+                    ...base,
+                    channelId: event.channel,
+                    connectedWorkspaceId: "connected_team_id" in event ? event.connected_team_id : undefined,
+                    isExternallyShared: "is_ext_shared" in event ? event.is_ext_shared : undefined,
+                    previouslyConnectedWorkspaceId: "previously_connected_team_id" in event
+                        ? event.previously_connected_team_id
+                        : undefined,
+                },
+            };
+        case "pin_added":
+        case "pin_removed":
+            return {
+                eventTypes: [
+                    event.type === "pin_added" ? "slack.pin.added" : "slack.pin.removed",
+                    "slack.event.received",
+                ],
+                payload: {
+                    ...base,
+                    conversationId: event.channel_id,
+                    hasPins: "has_pins" in event ? event.has_pins : undefined,
+                    item: event.item,
+                    userId: event.user,
+                },
+            };
+    }
+    throw new Error("Unsupported Slack event type.");
+}
+/**
+ * Maps a provider-native reaction target to the public discriminated union.
+ *
+ * @param item - Provider-native reaction target.
+ */
+function normalizeReactionItem(item) {
+    switch (item.type) {
+        case "message":
+            return {
+                conversationId: item.channel,
+                conversationType: item.channel_type,
+                messageTimestamp: item.ts,
+                type: "message",
+            };
+        case "file":
+            return { fileId: item.file, type: "file" };
+        case "file_comment":
+            return {
+                fileCommentId: item.file_comment,
+                fileId: item.file,
+                type: "fileComment",
+            };
+    }
+}