import type { ContextVisibilityMode, DmPolicy, GroupPolicy, MarkdownConfig, ReplyToMode, SlackChannelStreamingConfig } from "./types.base.js";
import type { ChannelHealthMonitorConfig, ChannelHeartbeatVisibilityConfig } from "./types.channels.js";
import type { DmConfig, ProviderCommandsConfig } from "./types.messages.js";
import type { GroupToolPolicyBySenderConfig, GroupToolPolicyConfig } from "./types.tools.js";
export type SlackDmConfig = {
    /** If false, ignore all incoming Slack DMs. Default: true. */
    enabled?: boolean;
    /** Direct message access policy (default: pairing). */
    policy?: DmPolicy;
    /** Allowlist for DM senders (ids). */
    allowFrom?: Array<string | number>;
    /** If true, allow group DMs (default: false). */
    groupEnabled?: boolean;
    /** Optional allowlist for group DM channels (ids or slugs). */
    groupChannels?: Array<string | number>;
    /** @deprecated Prefer channels.slack.replyToModeByChatType.direct. */
    replyToMode?: ReplyToMode;
};
export type SlackChannelConfig = {
    /** If false, disable the bot in this channel. */
    enabled?: boolean;
    /** Require mentioning the bot to trigger replies. */
    requireMention?: boolean;
    /** Optional tool policy overrides for this channel. */
    tools?: GroupToolPolicyConfig;
    toolsBySender?: GroupToolPolicyBySenderConfig;
    /** Allow bot-authored messages to trigger replies (default: false). */
    allowBots?: boolean;
    /** Allowlist of users that can invoke the bot in this channel. */
    users?: Array<string | number>;
    /** Optional skill filter for this channel. */
    skills?: string[];
    /** Optional system prompt for this channel. */
    systemPrompt?: string;
};
export type SlackReactionNotificationMode = "off" | "own" | "all" | "allowlist";
export type SlackStreamingMode = "off" | "partial" | "block" | "progress";
export type SlackExecApprovalTarget = "dm" | "channel" | "both";
export type SlackExecApprovalConfig = {
    /** Enable mode for Slack exec approvals on this account. Default: auto when approvers can be resolved; false disables. */
    enabled?: import("./types.approvals.js").NativeExecApprovalEnableMode;
    /** Slack user IDs allowed to approve exec requests. Optional: falls back to commands.ownerAllowFrom when possible. */
    approvers?: Array<string | number>;
    /** Only forward approvals for these agent IDs. Omit = all agents. */
    agentFilter?: string[];
    /** Only forward approvals matching these session key patterns (substring or regex). */
    sessionFilter?: string[];
    /** Where to send approval prompts. Default: "dm". */
    target?: SlackExecApprovalTarget;
};
export type SlackCapabilitiesConfig = string[] | {
    interactiveReplies?: boolean;
};
export type SlackActionConfig = {
    reactions?: boolean;
    messages?: boolean;
    pins?: boolean;
    search?: boolean;
    permissions?: boolean;
    memberInfo?: boolean;
    channelInfo?: boolean;
    emojiList?: boolean;
};
export type SlackSlashCommandConfig = {
    /** Enable handling for the configured slash command (default: false). */
    enabled?: boolean;
    /** Slash command name (default: "openclaw"). */
    name?: string;
    /** Session key prefix for slash commands (default: "slack:slash"). */
    sessionPrefix?: string;
    /** Reply ephemerally (default: true). */
    ephemeral?: boolean;
};
export type SlackThreadConfig = {
    /** Scope for thread history context (thread|channel). Default: thread. */
    historyScope?: "thread" | "channel";
    /** If true, thread sessions inherit the parent channel transcript. Default: false. */
    inheritParent?: boolean;
    /** Maximum number of thread messages to fetch as context when starting a new thread session (default: 20). Set to 0 to disable thread history fetching. */
    initialHistoryLimit?: number;
    /**
     * If true, require explicit @mention even inside threads where the bot has
     * previously participated. By default (false), replying in a thread where
     * the bot is a participant counts as an implicit mention and bypasses
     * requireMention gating. Set to true to suppress implicit thread mentions
     * so only explicit @bot mentions trigger replies in threads.
     */
    requireExplicitMention?: boolean;
};
export type SlackSocketModeConfig = {
    /** Slack SDK pong timeout in milliseconds. Socket Mode only. Default: 15000. */
    clientPingTimeout?: number;
    /** Slack SDK server ping timeout in milliseconds. Socket Mode only. */
    serverPingTimeout?: number;
    /** Enable Slack SDK ping/pong transport logging. Socket Mode only. */
    pingPongLoggingEnabled?: boolean;
};
export type SlackAccountConfig = {
    /** Optional display name for this account (used in CLI/UI lists). */
    name?: string;
    /** Slack connection mode (socket|http). Default: socket. */
    mode?: "socket" | "http";
    /** Slack SDK Socket Mode transport options. Ignored in HTTP mode. */
    socketMode?: SlackSocketModeConfig;
    /** Slack signing secret (required for HTTP mode). */
    signingSecret?: string;
    /** Slack Events API webhook path (default: /slack/events). */
    webhookPath?: string;
    /** Optional provider capability tags used for agent/runtime guidance. */
    capabilities?: SlackCapabilitiesConfig;
    /** Slack-native exec approval delivery + approver authorization. */
    execApprovals?: SlackExecApprovalConfig;
    /** Markdown formatting overrides (tables). */
    markdown?: MarkdownConfig;
    /** Override native command registration for Slack (bool or "auto"). */
    commands?: ProviderCommandsConfig;
    /** Allow channel-initiated config writes (default: true). */
    configWrites?: boolean;
    /** If false, do not start this Slack account. Default: true. */
    enabled?: boolean;
    botToken?: string;
    appToken?: string;
    userToken?: string;
    /** If true, restrict user token to read operations only. Default: true. */
    userTokenReadOnly?: boolean;
    /** Allow bot-authored messages to trigger replies (default: false). */
    allowBots?: boolean;
    /**
     * Break-glass override: allow mutable identity matching (name/slug) in allowlists.
     * Default behavior is ID-only matching.
     */
    dangerouslyAllowNameMatching?: boolean;
    /** Default mention requirement for channel messages (default: true). */
    requireMention?: boolean;
    /**
     * Controls how channel messages are handled:
     * - "open": channels bypass allowlists; mention-gating applies
     * - "disabled": block all channel messages
     * - "allowlist": only allow channels present in channels.slack.channels
     */
    groupPolicy?: GroupPolicy;
    /** Supplemental context visibility policy (all|allowlist|allowlist_quote). */
    contextVisibility?: ContextVisibilityMode;
    /** Max channel messages to keep as history context (0 disables). */
    historyLimit?: number;
    /** Max DM turns to keep as history context. */
    dmHistoryLimit?: number;
    /** Per-DM config overrides keyed by user ID. */
    dms?: Record<string, DmConfig>;
    textChunkLimit?: number;
    /** Streaming + chunking settings. Prefer this nested shape over legacy flat keys. */
    streaming?: SlackChannelStreamingConfig;
    mediaMaxMb?: number;
    /** Reaction notification mode (off|own|all|allowlist). Default: own. */
    reactionNotifications?: SlackReactionNotificationMode;
    /** Allowlist for reaction notifications when mode is allowlist. */
    reactionAllowlist?: Array<string | number>;
    /** Control reply threading when reply tags are present (off|first|all|batched). */
    replyToMode?: ReplyToMode;
    /**
     * Optional per-chat-type reply threading overrides.
     * Example: { direct: "all", group: "first", channel: "off" }.
     */
    replyToModeByChatType?: Partial<Record<"direct" | "group" | "channel", ReplyToMode>>;
    /** Thread session behavior. */
    thread?: SlackThreadConfig;
    actions?: SlackActionConfig;
    slashCommand?: SlackSlashCommandConfig;
    /**
     * Alias for dm.policy (prefer this so it inherits cleanly via base->account shallow merge).
     * Legacy key: channels.slack.dm.policy.
     */
    dmPolicy?: DmPolicy;
    /**
     * Alias for dm.allowFrom (prefer this so it inherits cleanly via base->account shallow merge).
     * Legacy key: channels.slack.dm.allowFrom.
     */
    allowFrom?: Array<string | number>;
    /** Default delivery target for CLI --deliver when no explicit --reply-to is provided. */
    defaultTo?: string;
    dm?: SlackDmConfig;
    channels?: Record<string, SlackChannelConfig>;
    /** Heartbeat visibility settings for this channel. */
    heartbeat?: ChannelHeartbeatVisibilityConfig;
    /** Channel health monitor overrides for this channel/account. */
    healthMonitor?: ChannelHealthMonitorConfig;
    /** Outbound response prefix override for this channel/account. */
    responsePrefix?: string;
    /**
     * Per-channel ack reaction override.
     * Slack uses shortcodes (e.g., "eyes") rather than unicode emoji.
     */
    ackReaction?: string;
    /** Reaction emoji added while processing a reply (e.g. "hourglass_flowing_sand"). Removed when done. Useful as a typing indicator fallback when assistant mode is not enabled. */
    typingReaction?: string;
};
export type SlackConfig = {
    /** Optional per-account Slack configuration (multi-account). */
    accounts?: Record<string, SlackAccountConfig>;
    /** Optional default account id when multiple accounts are configured. */
    defaultAccount?: string;
} & SlackAccountConfig;
declare module "./types.channels.js" {
    interface ChannelsConfig {
        slack?: SlackConfig;
    }
}
