/**
 * Inbound Slack event → harness shaping.
 *
 * The channel calls these helpers on inbound Slack message events before
 * handing them to the runtime:
 *
 * 1. {@link slackMessageFromWebhookPayload} converts the shared Chat SDK
 *    webhook payload into a channel-owned {@link SlackMessage}. The legacy
 *    {@link parseAppMentionEvent} and {@link parseDirectMessageEvent}
 *    helpers keep their raw-envelope behavior for direct unit coverage.
 * 2. The channel renders the actor, message, channel, and thread as one
 *    attributed model message so speaker identity cannot drift away from
 *    the content it describes.
 */
import type { SlackAppMentionPayload, SlackDirectMessagePayload } from "#compiled/@chat-adapter/slack/webhook.js";
/**
 * Author metadata for an inbound Slack message. Channel-owned shape;
 * does not depend on the chat SDK's `Author` interface.
 */
export interface SlackAuthor {
    readonly userId: string;
    readonly userName: string | undefined;
    readonly fullName: string | undefined;
    readonly isBot: boolean;
    readonly isMe: boolean;
}
/**
 * Inbound Slack file attachment. The channel reads only `type`, `url`,
 * `name`, `mimeType`, and `size`. The full Slack file object stays
 * available on {@link SlackMessage.raw}.
 */
export interface SlackAttachment {
    readonly id: string;
    readonly type: "image" | "file" | "video" | "audio";
    readonly url: string | undefined;
    readonly name: string | undefined;
    readonly mimeType: string | undefined;
    readonly size: number | undefined;
}
/**
 * Channel-owned representation of one inbound Slack message.
 *
 * Returned for the triggering Slack event. Replaces the chat SDK
 * `Message` type in the public callback surface (e.g.
 * `onAppMention(ctx, message)`).
 */
export interface SlackMessage {
    /** The original Slack text (mrkdwn). */
    readonly text: string;
    /** {@link text} re-rendered as GFM markdown for the agent. */
    readonly markdown: string;
    /** Slack message ts. */
    readonly ts: string;
    /** Thread parent ts (root). Equals {@link ts} for non-thread events. */
    readonly threadTs: string;
    /** Slack channel id. */
    readonly channelId: string;
    /** Slack team id, when the envelope carried one. */
    readonly teamId: string | undefined;
    /** Author of the message. May be `undefined` for system events. */
    readonly author: SlackAuthor | undefined;
    /** File / image attachments on the inbound message. */
    readonly attachments: readonly SlackAttachment[];
    /** Raw inbound event payload from Slack. */
    readonly raw: Record<string, unknown>;
}
/**
 * Open-ended Slack Events API payload handed to `slackChannel({ onEvent })`.
 * `type` is the Slack event discriminator; all event-specific fields pass
 * through unchanged from the signed webhook body.
 */
export interface SlackEvent {
    readonly type: string;
    readonly [key: string]: unknown;
}
/**
 * Slack webhook envelope for an `event_callback`. The channel cares
 * only about `team_id` (for ergonomic auth derivation) and the inner
 * `event` payload.
 */
export interface SlackEventCallback {
    readonly type: "event_callback";
    readonly team_id?: string;
    readonly authorizations?: readonly {
        readonly is_bot?: boolean;
        readonly user_id?: string;
    }[];
    readonly event?: {
        readonly type?: string;
    } & Record<string, unknown>;
    readonly event_id?: string;
    readonly event_time?: number;
    readonly [key: string]: unknown;
}
/**
 * Validated Slack Events API callback envelope handed to `onEvent` through
 * {@link SlackInboundEventContext}. Unlike the permissive parser input type,
 * this shape always carries an event with a non-empty `type` discriminator.
 */
export interface SlackEventEnvelope extends SlackEventCallback {
    readonly event: SlackEvent;
}
/**
 * Parses a raw JSON webhook body into an open-ended Slack Events API envelope.
 * Returns `null` for URL verification, interactivity, and malformed callback
 * payloads. Invalid JSON is allowed to throw so the route can log it once.
 */
export declare function parseSlackEventEnvelope(body: string): SlackEventEnvelope | null;
/**
 * Parses a Slack `app_mention` event into a {@link SlackMessage}.
 *
 * Returns `null` when the envelope is not an `app_mention` event or
 * when required fields (channel id, ts) are missing.
 */
export declare function parseAppMentionEvent(envelope: SlackEventCallback): SlackMessage | null;
/**
 * Parses a Slack `message` event with `channel_type: "im"` into a
 * {@link SlackMessage}.
 *
 * Returns `null` when:
 * - the envelope is not an IM `message` event,
 * - required fields (channel id, ts) are missing,
 * - the message carries a system `subtype` (edits, deletes, joins, etc.)
 *   other than `file_share` — file uploads are real user messages and
 *   must reach the handler with their attachments intact, or
 * - the message was posted by a bot (`bot_id` set) — this prevents the
 *   bot's own DM replies from re-triggering the handler.
 */
/** Returns the bot user id attached to a Slack event authorization. */
export declare function slackEventBotUserId(envelope: SlackEventCallback): string | undefined;
/** Parses a Slack message event without applying bot or subtype policy. */
export declare function parseMessageEvent(envelope: SlackEventCallback): SlackMessage | null;
export declare function parseDirectMessageEvent(envelope: SlackEventCallback): SlackMessage | null;
export declare function slackMessageFromWebhookPayload(payload: SlackAppMentionPayload | SlackDirectMessagePayload): SlackMessage | null;
/**
 * Verified inbound identity used to attribute a model-visible Slack message.
 *
 * Channel-owned shape so the helper does not depend on the inbound
 * `SlackMessage` and is therefore trivially testable in isolation.
 */
export interface SlackInboundContext {
    readonly userId: string;
    readonly userName?: string;
    readonly fullName?: string;
    readonly channelId: string;
    readonly threadTs: string;
    readonly teamId?: string;
}