@cuylabs/channel-slack 0.9.0 → 0.11.0

package/dist/socket.d.ts

@@ -0,0 +1,142 @@
+import { App } from '@slack/bolt';
+import { C as CreateSlackSocketBoltAppOptions } from './bolt-app-BM0tiL7c.js';
+import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from './types-B9NfCVrk.js';
+import { S as SlackAssistantBridge, C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig } from './options-DQacQDmD.js';
+import { SlackAppSurfaceOptions } from './app-surface.js';
+import { SlackFeedbackHandler } from './feedback/index.js';
+import 'node:http';
+import '@slack/web-api';
+import './turn-BGAXddH_.js';
+import './activity-ByrD9Ftr.js';
+import './interactive-CbKYkkc_.js';
+import './formatting-C-kwQseI.js';
+import './options-B0xQCaez.js';
+import './types-C8nkPuD4.js';
+import './types-Cywfj8Mj.js';
+import './logging-Bl3HfcC8.js';
+import './types-wLZzyI9r.js';
+import '@slack/types';
+
+/**
+ * Socket Mode helpers for direct Slack.
+ *
+ * Slack's Socket Mode is the recommended local-development transport because
+ * it does not need a public webhook URL. The starter agent in
+ * `bolt-js-starter-agent` uses it for that reason. These helpers mirror the
+ * HTTP/Express mounts for the Socket Mode case so application code stays
+ * identical across transports.
+ *
+ * @example
+ * ```ts
+ * import { mountSlackAssistantSocket } from "@cuylabs/channel-slack/socket";
+ *
+ * await mountSlackAssistantSocket({
+ *   source: agent,
+ *   appToken: process.env.SLACK_APP_TOKEN, // xapp-...
+ *   botToken: process.env.SLACK_BOT_TOKEN, // xoxb-...
+ *   getSuggestedPrompts: () => ({
+ *     prompts: [
+ *       { title: "Roll dice", message: "Roll 2d20" },
+ *       { title: "Brainstorm", message: "Help me brainstorm a launch plan" },
+ *     ],
+ *   }),
+ * });
+ * ```
+ */
+
+interface MountSlackAssistantSocketOptions extends Omit<CreateSlackAssistantBridgeOptions, "feedback"> {
+    /**
+     * Slack app-level token (`xapp-...`) with `connections:write` scope.
+     * @default process.env.SLACK_APP_TOKEN
+     */
+    appToken?: string;
+    /**
+     * Slack bot token (`xoxb-...`) for the bot user in single-workspace mode.
+     * @default process.env.SLACK_BOT_TOKEN
+     */
+    botToken?: string;
+    /**
+     * Direct-mode auth config (single-workspace, OAuth, custom).
+     *
+     * Socket Mode still requires `appToken`; OAuth/custom authorize only change
+     * how Bolt resolves workspace bot/user tokens once events arrive.
+     */
+    auth?: SlackDirectAuthOptions;
+    /**
+     * Additional Bolt `App` options. Socket/auth fields are controlled by this
+     * helper and cannot be overridden. In OAuth Socket Mode, use `port` here to
+     * control the small HTTP server Bolt starts for install/callback routes.
+     */
+    boltAppOptions?: CreateSlackSocketBoltAppOptions["boltAppOptions"];
+    /**
+     * Additional native Socket Mode receiver options. Use this for websocket
+     * health tuning such as ping timeouts and reconnect behavior.
+     */
+    socketModeReceiverOptions?: CreateSlackSocketBoltAppOptions["socketModeReceiverOptions"];
+    /**
+     * Feedback config. Pass `false` to omit the feedback block. Pass an object
+     * to override action ids, button labels, or the handler.
+     */
+    feedback?: SlackAssistantFeedbackConfig | false;
+    /**
+     * Convenience shorthand: `onFeedback: handler` is equivalent to
+     * `feedback: { onFeedback: handler }`. Ignored if `feedback` is set.
+     */
+    onFeedback?: SlackFeedbackHandler;
+    /**
+     * Whether to call `app.start()` automatically. When `false`, callers own
+     * the lifecycle and must call `result.boltApp.start()` themselves.
+     * @default true
+     */
+    start?: boolean;
+}
+interface MountSlackAssistantSocketResult {
+    boltApp: App;
+    bridge: SlackAssistantBridge;
+    authMode: SlackDirectAuthMode;
+}
+interface MountSlackAppSocketOptions extends SlackAppSurfaceOptions {
+    /**
+     * Slack app-level token (`xapp-...`) with `connections:write` scope.
+     * @default process.env.SLACK_APP_TOKEN
+     */
+    appToken?: string;
+    /**
+     * Slack bot token (`xoxb-...`) for the bot user in single-workspace mode.
+     * @default process.env.SLACK_BOT_TOKEN
+     */
+    botToken?: string;
+    /**
+     * Direct-mode auth config (single-workspace, OAuth, custom).
+     *
+     * Socket Mode still requires `appToken`; OAuth/custom authorize only change
+     * how Bolt resolves workspace bot/user tokens once events arrive.
+     */
+    auth?: SlackDirectAuthOptions;
+    /**
+     * Additional Bolt `App` options. Socket/auth fields are controlled by this
+     * helper and cannot be overridden. In OAuth Socket Mode, use `port` here to
+     * control the small HTTP server Bolt starts for install/callback routes.
+     */
+    boltAppOptions?: CreateSlackSocketBoltAppOptions["boltAppOptions"];
+    /**
+     * Additional native Socket Mode receiver options. Use this for websocket
+     * health tuning such as ping timeouts and reconnect behavior.
+     */
+    socketModeReceiverOptions?: CreateSlackSocketBoltAppOptions["socketModeReceiverOptions"];
+    /**
+     * Whether to call `app.start()` automatically. When `false`, callers own
+     * the lifecycle and must call `result.boltApp.start()` themselves.
+     * @default true
+     */
+    start?: boolean;
+}
+interface MountSlackAppSocketResult {
+    boltApp: App;
+    bridge: SlackAssistantBridge;
+    authMode: SlackDirectAuthMode;
+}
+declare function mountSlackAssistantSocket(options: MountSlackAssistantSocketOptions): Promise<MountSlackAssistantSocketResult>;
+declare function mountSlackAppSocket(options: MountSlackAppSocketOptions): Promise<MountSlackAppSocketResult>;
+
+export { type MountSlackAppSocketOptions, type MountSlackAppSocketResult, type MountSlackAssistantSocketOptions, type MountSlackAssistantSocketResult, mountSlackAppSocket, mountSlackAssistantSocket };

package/dist/socket.js

@@ -0,0 +1,77 @@
+import {
+  createSlackSocketBoltApp
+} from "./chunk-73QXT7MA.js";
+import "./chunk-S3SWPYXJ.js";
+import {
+  installSlackAppSurface
+} from "./chunk-LFQCINHI.js";
+import {
+  createSlackAssistantBridge
+} from "./chunk-Q6YX7HHK.js";
+import "./chunk-RHOIVQLD.js";
+import "./chunk-IRFKUPJN.js";
+import "./chunk-RTDLIYEE.js";
+import "./chunk-IAQXQESO.js";
+import "./chunk-37RN2YUI.js";
+import "./chunk-3KP3CBCC.js";
+import "./chunk-FPCE5V5Y.js";
+import "./chunk-6WHFQUYQ.js";
+
+// src/socket.ts
+async function mountSlackAssistantSocket(options) {
+  const {
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions,
+    feedback: feedbackOption,
+    onFeedback,
+    start,
+    ...bridgeOptions
+  } = options;
+  const { boltApp, authMode } = await createSlackSocketBoltApp({
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions
+  });
+  const feedback = feedbackOption !== void 0 ? feedbackOption : onFeedback ? { onFeedback } : void 0;
+  const bridge = createSlackAssistantBridge({
+    ...bridgeOptions,
+    ...feedback !== void 0 ? { feedback } : {}
+  });
+  bridge.install(boltApp);
+  if (start !== false) {
+    await boltApp.start();
+  }
+  return { boltApp, bridge, authMode };
+}
+async function mountSlackAppSocket(options) {
+  const {
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions,
+    start,
+    ...surfaceOptions
+  } = options;
+  const { boltApp, authMode } = await createSlackSocketBoltApp({
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions
+  });
+  const { bridge } = installSlackAppSurface(boltApp, surfaceOptions);
+  if (start !== false) {
+    await boltApp.start();
+  }
+  return { boltApp, bridge, authMode };
+}
+export {
+  mountSlackAppSocket,
+  mountSlackAssistantSocket
+};

package/dist/transports/index.d.ts

@@ -1,5 +1,6 @@
 export { CreateSlackBoltAppOptions, CreateSlackBoltAppResult, createSlackBoltApp, createSlackBoltApp as createSlackHttpBoltApp } from './http/index.js';
-export { CreateSlackSocketBoltAppOptions, CreateSlackSocketBoltAppResult, SlackSocketModePostgresLock, SlackSocketModePostgresLockClient, SlackSocketModePostgresLockOptions, SlackSocketModePostgresLockPool, SlackSocketModeProcessLock, SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock, createSlackSocketBoltApp } from './socket/index.js';
+export { C as CreateSlackSocketBoltAppOptions, a as CreateSlackSocketBoltAppResult, c as createSlackSocketBoltApp } from '../bolt-app-BM0tiL7c.js';
+export { SlackSocketModePostgresLock, SlackSocketModePostgresLockClient, SlackSocketModePostgresLockOptions, SlackSocketModePostgresLockPool, SlackSocketModeProcessLock, SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock } from './socket/index.js';
 export { S as SlackSocketModeReceiverRuntimeOptions, a as SlackSocketModeRestartGuard, b as SlackSocketModeRuntime, c as SlackSocketModeRuntimeOptions, d as SlackSocketModeRuntimePolicy, e as createSlackSdkLogger, f as createSlackSocketModeRestartGuard, g as createSlackSocketModeRuntime, r as redactSlackSocketModeLogValue } from '../runtime-BNBHOZSQ.js';
 export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
 import 'express';

package/dist/transports/socket/index.d.ts

@@ -1,55 +1,10 @@
-import { AppOptions, SocketModeReceiverOptions, App } from '@slack/bolt';
-export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
-import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from '../../types-B9NfCVrk.js';
+export { C as CreateSlackSocketBoltAppOptions, a as CreateSlackSocketBoltAppResult, c as createSlackSocketBoltApp } from '../../bolt-app-BM0tiL7c.js';
 import { L as Logger } from '../../logging-Bl3HfcC8.js';
 export { S as SlackSocketModeReceiverRuntimeOptions, a as SlackSocketModeRestartGuard, b as SlackSocketModeRuntime, c as SlackSocketModeRuntimeOptions, d as SlackSocketModeRuntimePolicy, e as createSlackSdkLogger, f as createSlackSocketModeRestartGuard, g as createSlackSocketModeRuntime, r as redactSlackSocketModeLogValue } from '../../runtime-BNBHOZSQ.js';
+export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
+import '../../types-B9NfCVrk.js';
 import 'node:http';
 
-/**
- * `createSlackSocketBoltApp` — builds a Socket Mode Bolt `App` from the
- * package's structured auth options. Mirrors `createSlackBoltApp` without
- * owning any assistant/app surface mounting.
- */
-
-type ControlledSocketBoltAppOption = "receiver" | "socketMode" | "appToken" | "token" | "authorize" | "botId" | "botUserId" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions";
-type ControlledSocketModeReceiverOption = "appToken" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions" | "logger" | "logLevel";
-interface CreateSlackSocketBoltAppOptions {
-    /**
-     * Slack app-level token (`xapp-...`) with `connections:write` scope.
-     * @default process.env.SLACK_APP_TOKEN
-     */
-    appToken?: string;
-    /**
-     * Convenience override for single-workspace mode.
-     * @default process.env.SLACK_BOT_TOKEN
-     */
-    botToken?: string;
-    /**
-     * Direct-mode auth configuration.
-     *
-     * - omit for single-workspace token mode
-     * - use `{ mode: "oauth", ... }` for Bolt-managed installs
-     * - use `{ mode: "authorize", authorize }` for external token resolution
-     */
-    auth?: SlackDirectAuthOptions;
-    /**
-     * Additional Bolt `App` options passed after this package sets Socket Mode
-     * and auth. Use for logger/clientOptions and non-auth native Bolt config.
-     */
-    boltAppOptions?: Partial<Omit<AppOptions, ControlledSocketBoltAppOption>>;
-    /**
-     * Additional native Socket Mode receiver options. Use this for websocket
-     * health tuning such as ping timeouts, reconnect behavior, and receiver
-     * error handling. Auth/OAuth fields stay controlled by this helper.
-     */
-    socketModeReceiverOptions?: Partial<Omit<SocketModeReceiverOptions, ControlledSocketModeReceiverOption>>;
-}
-interface CreateSlackSocketBoltAppResult {
-    boltApp: App;
-    authMode: SlackDirectAuthMode;
-}
-declare function createSlackSocketBoltApp(options?: CreateSlackSocketBoltAppOptions): Promise<CreateSlackSocketBoltAppResult>;
-
 interface SlackSocketModeProcessLockOptions {
     appSlug: string;
     appToken?: string;
@@ -91,4 +46,4 @@ interface SlackSocketModePostgresLock {
 }
 declare function acquireSlackSocketModePostgresLock({ appSlug, appToken, client, connectionString, enabled, logger, namespace, pool, }: SlackSocketModePostgresLockOptions): Promise<SlackSocketModePostgresLock | undefined>;
 
-export { type CreateSlackSocketBoltAppOptions, type CreateSlackSocketBoltAppResult, type SlackSocketModePostgresLock, type SlackSocketModePostgresLockClient, type SlackSocketModePostgresLockOptions, type SlackSocketModePostgresLockPool, type SlackSocketModeProcessLock, type SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock, createSlackSocketBoltApp };
+export { type SlackSocketModePostgresLock, type SlackSocketModePostgresLockClient, type SlackSocketModePostgresLockOptions, type SlackSocketModePostgresLockPool, type SlackSocketModeProcessLock, type SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock };

package/dist/turn-BGAXddH_.d.ts

@@ -0,0 +1,178 @@
+import { S as SlackActivityInfo, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
+
+/**
+ * Slack auth context — credentials and identifiers resolved from the inbound
+ * request. **Sensitive**: see security note on `SlackAuthContext`.
+ */
+/**
+ * Slack credentials and identifiers resolved from the inbound request.
+ *
+ * Surfaced to `prepareTurn`, the ambient `currentSlackTurnContext()`, and the
+ * assistant message context so tools and middleware can call the Slack Web
+ * API or attach per-user OAuth tokens to MCP servers (see
+ * `createSlackMcpServerConfig`).
+ *
+ * Security: `botToken` and `userToken` are secrets. Do not include this auth
+ * bag in logs, telemetry attributes, baggage, tool results, message history,
+ * or model-visible prompts. Pass only the exact token needed to a trusted
+ * Slack API/MCP client.
+ *
+ * Most fields come from Bolt's enriched `args.context`. They are all optional
+ * because availability depends on the auth mode (single-workspace vs OAuth)
+ * and on whether the installer granted user scopes.
+ */
+interface SlackAuthContext {
+    /** Workspace bot token (`xoxb-...`). */
+    botToken?: string;
+    /** End-user OAuth token (`xoxp-...`) when user scopes were granted. */
+    userToken?: string;
+    /** Workspace ID (`T...`). */
+    teamId?: string;
+    /** Enterprise grid ID (`E...`) when applicable. */
+    enterpriseId?: string;
+    /** Bot user ID (`U...`) — useful for distinguishing bot self-mentions. */
+    botUserId?: string;
+    /** Internal Slack bot ID (`B...`). */
+    botId?: string;
+    /** Slack user ID (`U...`) of the human author of the inbound event. */
+    userId?: string;
+}
+
+/**
+ * Slack assistant lifecycle types — status updates, suggested prompts, thread
+ * context, and the channel-neutral `SlackAssistantUtilities` interface that
+ * the assistant bridge surfaces ambiently for tools and middleware.
+ */
+/**
+ * Slack assistant thread context — the channel of origin metadata Slack tracks
+ * while a user navigates the workspace. Surfaces the same fields Bolt's
+ * `AssistantThreadContextStore` returns.
+ *
+ * @see https://docs.slack.dev/reference/events/assistant_thread_context_changed
+ */
+interface SlackAssistantThreadContext {
+    channel_id?: string;
+    team_id?: string;
+    enterprise_id?: string | null;
+}
+/** Display mode passed to `client.chatStream`. */
+type SlackAssistantTaskDisplayMode = "plan" | "timeline";
+/**
+ * Slack message authorship fields supported by AI assistant status updates
+ * and native chat stream start calls.
+ */
+interface SlackMessageAuthorshipOptions {
+    /** Emoji shown as the message/status icon, e.g. `":robot_face:"`. */
+    icon_emoji?: string;
+    /** Image URL shown as the message/status icon. */
+    icon_url?: string;
+    /** Display name shown for the message/status. */
+    username?: string;
+}
+/** Optional passthrough fields for Slack's native `chat.startStream`. */
+type SlackChatStreamStartArgs = SlackMessageAuthorshipOptions & {
+    /**
+     * Slack task display mode for streamed tool/task chunks. `timeline` shows
+     * individual task cards; `plan` groups task cards together.
+     */
+    task_display_mode?: SlackAssistantTaskDisplayMode;
+};
+/** A single suggested prompt chip shown in the assistant pane. */
+interface SlackAssistantSuggestedPrompt {
+    title: string;
+    message: string;
+}
+/** Suggested prompts payload for `assistant.threads.setSuggestedPrompts`. */
+interface SlackAssistantSuggestedPrompts {
+    /** Title shown above the chips. Defaults to Slack's "Try these prompts:". */
+    title?: string;
+    prompts: SlackAssistantSuggestedPrompt[];
+}
+/** Status payload accepted by Bolt's assistant `setStatus`. */
+interface SlackAssistantStatusUpdate extends SlackMessageAuthorshipOptions {
+    status: string;
+    loading_messages?: string[];
+}
+/**
+ * Assistant pane utilities surfaced ambiently so tools/middleware can call
+ * them mid-turn without wiring the raw Bolt args through.
+ *
+ * Only present when the turn is running through the assistant bridge.
+ */
+interface SlackAssistantUtilities {
+    setStatus: (update: SlackAssistantStatusUpdate) => Promise<void>;
+    setSuggestedPrompts: (prompts: SlackAssistantSuggestedPrompts) => Promise<void>;
+    setTitle: (title: string) => Promise<void>;
+    getThreadContext: () => Promise<SlackAssistantThreadContext>;
+    saveThreadContext: () => Promise<void>;
+}
+/**
+ * Status utility exposed by Bolt for any message/app_mention event with a
+ * channel + thread timestamp. It calls Slack's assistant thread status API,
+ * but unlike the full Assistant surface it does not imply suggested prompts,
+ * thread titles, or origin-channel context.
+ */
+type SlackThreadStatusSetter = (update: SlackAssistantStatusUpdate) => Promise<void>;
+
+/**
+ * Slack turn-request and turn-preparation contracts shared by Slack transport
+ * packages. Direct Slack fills these from Bolt events; M365-backed Slack fills
+ * the same shape from Bot Framework activities.
+ */
+
+/**
+ * Context available while preparing a Slack turn.
+ */
+interface SlackTurnRequestContext {
+    /** Parsed Slack activity metadata */
+    slackActivity: SlackActivityInfo;
+    /** Extracted Slack user identity */
+    user: SlackUserIdentity;
+    /** Resolved runtime session ID for this conversation */
+    sessionId: string;
+    /** Plain-text message forwarded to the host application */
+    message: string;
+    /**
+     * Slack auth + identity resolved from the inbound request.
+     *
+     * Includes the bot token, optional end-user OAuth token, team/enterprise
+     * IDs, and bot user ID. Tools and `prepareTurn` callers can use these to
+     * call the Slack Web API or attach the user token to MCP servers.
+     */
+    auth?: SlackAuthContext;
+    /**
+     * Assistant thread context resolved by Bolt for assistant-pane turns.
+     *
+     * Tells the runtime which channel/workspace the user is currently viewing
+     * while talking to the assistant — useful for context-aware system prompts
+     * and for resolving relative references like "this channel".
+     *
+     * `undefined` when the turn was not routed through the assistant bridge.
+     */
+    threadContext?: SlackAssistantThreadContext;
+    /**
+     * Slack thread status setter available when Bolt provides `setStatus` for
+     * the inbound event. This can be present on classic `app_mention` /
+     * `message` turns as well as full Assistant-pane turns.
+     */
+    setStatus?: SlackThreadStatusSetter;
+}
+/**
+ * Optional turn preparation result for a Slack turn.
+ */
+interface SlackTurnPreparation {
+    /** Optional system override for the host application */
+    system?: string;
+    /** Optional message override for the host application. */
+    message?: string;
+    /** Optional session override for this turn. */
+    sessionId?: string;
+    /** Optional custom scope name for the activity */
+    scopeName?: string;
+    /** Additional scalar attributes merged into the activity scope */
+    scopeAttributes?: Record<string, string | number | boolean | null | undefined>;
+    /** Arbitrary app-specific per-turn context exposed via AsyncLocalStorage */
+    context?: Record<string, unknown>;
+}
+
+export type { SlackAssistantStatusUpdate as S, SlackAssistantSuggestedPrompt as a, SlackAssistantSuggestedPrompts as b, SlackAssistantTaskDisplayMode as c, SlackAssistantThreadContext as d, SlackAssistantUtilities as e, SlackAuthContext as f, SlackChatStreamStartArgs as g, SlackMessageAuthorshipOptions as h, SlackThreadStatusSetter as i, SlackTurnPreparation as j, SlackTurnRequestContext as k };

package/dist/types-Cywfj8Mj.d.ts

@@ -0,0 +1,91 @@
+import { g as SlackInteractiveRequestContext } from './interactive-CbKYkkc_.js';
+
+type SlackInteractiveRequestStatus = "pending" | "resolved";
+type SlackInteractiveApprovalAction = "allow" | "deny" | "remember";
+type SlackInteractiveHumanInputResponse = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "confirm";
+    confirmed: boolean;
+    text: string;
+} | {
+    kind: "choice";
+    selected: string[];
+    text: string;
+};
+interface SlackInteractiveApprovalRequest {
+    id: string;
+    tool: string;
+    args: unknown;
+    description: string;
+    risk: string;
+    rememberScopes?: string[];
+    defaultRememberScope?: string;
+}
+interface SlackInteractiveHumanInputOption {
+    label: string;
+    value?: string;
+    description?: string;
+}
+interface SlackInteractiveHumanInputRequest {
+    id: string;
+    kind: "text" | "confirm" | "choice";
+    title: string;
+    question: string;
+    options?: SlackInteractiveHumanInputOption[];
+    allowMultiple?: boolean;
+    placeholder?: string;
+    confirmLabel?: string;
+    denyLabel?: string;
+}
+type SlackInteractiveStoredRequest = SlackInteractiveApprovalRequest | SlackInteractiveHumanInputRequest;
+type SlackInteractiveResolution = {
+    kind: "approval";
+    action: SlackInteractiveApprovalAction;
+    feedback?: string;
+    rememberScope?: string;
+} | {
+    kind: "human-input";
+    response: SlackInteractiveHumanInputResponse;
+};
+interface SlackInteractiveMessageTarget {
+    channel: string;
+    ts: string;
+    threadTs?: string;
+    userId: string;
+    teamId?: string;
+}
+interface SlackInteractiveRequestRecord {
+    id: string;
+    kind: SlackInteractiveResolution["kind"];
+    request: SlackInteractiveStoredRequest;
+    status: SlackInteractiveRequestStatus;
+    createdAt: string;
+    updatedAt: string;
+    target?: SlackInteractiveMessageTarget;
+    resolution?: SlackInteractiveResolution;
+}
+interface SlackInteractiveRequestStore {
+    get(requestId: string): Promise<SlackInteractiveRequestRecord | undefined>;
+    upsert(record: SlackInteractiveRequestRecord): Promise<SlackInteractiveRequestRecord>;
+    attachTarget(requestId: string, target: SlackInteractiveMessageTarget): Promise<SlackInteractiveRequestRecord | undefined>;
+    resolve(requestId: string, resolution: SlackInteractiveResolution): Promise<SlackInteractiveRequestRecord | undefined>;
+    delete(requestId: string): Promise<void>;
+}
+interface SlackInteractiveActionIds {
+    approvalAllow: string;
+    approvalDeny: string;
+    approvalRemember: string;
+    humanConfirm: string;
+    humanDeny: string;
+    humanOpen: string;
+    humanSubmit: string;
+}
+interface SlackInteractiveActor {
+    userId: string;
+    teamId?: string;
+}
+type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
+
+export type { SlackInteractiveActionIds as S, SlackInteractiveActor as a, SlackInteractiveApprovalAction as b, SlackInteractiveApprovalRequest as c, SlackInteractiveHumanInputOption as d, SlackInteractiveHumanInputRequest as e, SlackInteractiveHumanInputResponse as f, SlackInteractiveMessageTarget as g, SlackInteractiveRequestHandler as h, SlackInteractiveRequestRecord as i, SlackInteractiveRequestStatus as j, SlackInteractiveRequestStore as k, SlackInteractiveResolution as l, SlackInteractiveStoredRequest as m };