@hypercli.com/sdk 2026.6.26 → 2026.8.11

package/dist/openclaw/slack.d.ts

@@ -0,0 +1,818 @@
+import { type OpenClawConfigSchemaLookupResult } from './gateway.js';
+export type OpenClawSecretRefSource = 'env' | 'file' | 'exec';
+export interface OpenClawSecretRef {
+    source: OpenClawSecretRefSource;
+    provider: string;
+    id: string;
+}
+export type OpenClawSlackSecretRefSource = OpenClawSecretRefSource;
+export type OpenClawSlackSecretRef = OpenClawSecretRef;
+export type OpenClawSlackSecretInput = string | OpenClawSecretRef;
+export type OpenClawSlackMode = 'socket' | 'http' | 'relay';
+export type OpenClawSlackReplyToMode = 'off' | 'first' | 'all' | 'batched';
+export type OpenClawSlackGroupPolicy = 'open' | 'disabled' | 'allowlist';
+export type OpenClawSlackDmPolicy = 'pairing' | 'allowlist' | 'open' | 'disabled';
+export type OpenClawSlackContextVisibility = 'all' | 'allowlist' | 'allowlist_quote';
+export interface OpenClawSlackToolPolicy {
+    allow?: string[];
+    alsoAllow?: string[];
+    deny?: string[];
+}
+export type OpenClawSlackToolPolicyBySender = Record<string, OpenClawSlackToolPolicy>;
+export interface OpenClawSlackBotLoopProtectionConfig {
+    enabled?: boolean;
+    maxEventsPerWindow?: number;
+    windowSeconds?: number;
+    cooldownSeconds?: number;
+}
+export interface OpenClawSlackImplicitMentionsConfig {
+    replyToBot?: boolean;
+    quotedBot?: boolean;
+    threadParticipation?: boolean;
+}
+export interface OpenClawSlackPresenceEventsConfig {
+    mode?: 'off' | 'auto' | 'on';
+}
+export interface OpenClawSlackChannelConfig {
+    enabled?: boolean;
+    requireMention?: boolean;
+    ignoreOtherMentions?: boolean;
+    replyToMode?: OpenClawSlackReplyToMode;
+    tools?: OpenClawSlackToolPolicy;
+    toolsBySender?: OpenClawSlackToolPolicyBySender;
+    allowBots?: boolean | 'mentions';
+    botLoopProtection?: OpenClawSlackBotLoopProtectionConfig;
+    users?: Array<string | number>;
+    skills?: string[];
+    systemPrompt?: string;
+    presenceEvents?: OpenClawSlackPresenceEventsConfig;
+}
+export interface OpenClawSlackDmConfig {
+    enabled?: boolean;
+    /** @deprecated Use account-level dmPolicy. */
+    policy?: OpenClawSlackDmPolicy;
+    /** @deprecated Use account-level allowFrom. */
+    allowFrom?: Array<string | number>;
+    groupEnabled?: boolean;
+    groupChannels?: Array<string | number>;
+    /** @deprecated Prefer replyToModeByChatType.direct. */
+    replyToMode?: OpenClawSlackReplyToMode;
+}
+export interface OpenClawSlackSocketModeConfig {
+    clientPingTimeout?: number;
+    serverPingTimeout?: number;
+    pingPongLoggingEnabled?: boolean;
+}
+export interface OpenClawSlackRelayConfig {
+    url?: string;
+    authToken?: OpenClawSlackSecretInput;
+    gatewayId?: string;
+}
+export interface OpenClawSlackStreamingChunkConfig {
+    minChars?: number;
+    maxChars?: number;
+    breakPreference?: 'paragraph' | 'newline' | 'sentence';
+}
+export interface OpenClawSlackStreamingPreviewConfig {
+    chunk?: OpenClawSlackStreamingChunkConfig;
+    toolProgress?: boolean;
+    commandText?: 'raw' | 'status';
+}
+export interface OpenClawSlackStreamingProgressConfig {
+    label?: string | false;
+    labels?: string[];
+    maxLines?: number;
+    maxLineChars?: number;
+    render?: 'text' | 'rich';
+    toolProgress?: boolean;
+    commandText?: 'raw' | 'status';
+    commentary?: boolean;
+    narration?: boolean;
+    nativeTaskCards?: boolean;
+}
+export interface OpenClawSlackStreamingCoalesceConfig {
+    minChars?: number;
+    maxChars?: number;
+    idleMs?: number;
+}
+export interface OpenClawSlackStreamingBlockConfig {
+    enabled?: boolean;
+    coalesce?: OpenClawSlackStreamingCoalesceConfig;
+}
+export interface OpenClawSlackStreamingConfig {
+    mode?: 'off' | 'partial' | 'block' | 'progress';
+    chunkMode?: 'length' | 'newline';
+    nativeTransport?: boolean;
+    preview?: OpenClawSlackStreamingPreviewConfig;
+    progress?: OpenClawSlackStreamingProgressConfig;
+    block?: OpenClawSlackStreamingBlockConfig;
+}
+export interface OpenClawSlackExecApprovalConfig {
+    enabled?: boolean | 'auto';
+    approvers?: Array<string | number>;
+    agentFilter?: string[];
+    sessionFilter?: string[];
+    target?: 'dm' | 'channel' | 'both';
+}
+export type OpenClawSlackCapabilitiesConfig = string[] | {
+    interactiveReplies?: boolean;
+};
+export interface OpenClawSlackActionsConfig {
+    reactions?: boolean;
+    messages?: boolean;
+    pins?: boolean;
+    search?: boolean;
+    permissions?: boolean;
+    memberInfo?: boolean;
+    channelInfo?: boolean;
+    emojiList?: boolean;
+}
+export interface OpenClawSlackSlashCommandConfig {
+    enabled?: boolean;
+    name?: string;
+    sessionPrefix?: string;
+    ephemeral?: boolean;
+}
+export interface OpenClawSlackCommandsConfig {
+    native?: boolean | 'auto';
+    nativeSkills?: boolean | 'auto';
+}
+export interface OpenClawSlackMarkdownConfig {
+    tables?: 'off' | 'bullets' | 'code' | 'block';
+}
+export interface OpenClawSlackMentionPatternsConfig {
+    mode?: 'allow' | 'deny';
+    allowIn?: string[];
+    denyIn?: string[];
+}
+export interface OpenClawSlackThreadConfig {
+    historyScope?: 'thread' | 'channel';
+    inheritParent?: boolean;
+    initialHistoryLimit?: number;
+}
+export interface OpenClawSlackHeartbeatConfig {
+    showOk?: boolean;
+    showAlerts?: boolean;
+    useIndicator?: boolean;
+}
+export interface OpenClawSlackHealthMonitorConfig {
+    enabled?: boolean;
+}
+export interface OpenClawSlackAccountConfig {
+    name?: string;
+    mode?: OpenClawSlackMode;
+    enterpriseOrgInstall?: boolean;
+    socketMode?: OpenClawSlackSocketModeConfig;
+    relay?: OpenClawSlackRelayConfig;
+    signingSecret?: OpenClawSlackSecretInput;
+    webhookPath?: string;
+    capabilities?: OpenClawSlackCapabilitiesConfig;
+    execApprovals?: OpenClawSlackExecApprovalConfig;
+    markdown?: OpenClawSlackMarkdownConfig;
+    commands?: OpenClawSlackCommandsConfig;
+    configWrites?: boolean;
+    enabled?: boolean;
+    botToken?: OpenClawSlackSecretInput;
+    appToken?: OpenClawSlackSecretInput;
+    userToken?: OpenClawSlackSecretInput;
+    userTokenReadOnly?: boolean;
+    allowBots?: boolean | 'mentions';
+    botLoopProtection?: OpenClawSlackBotLoopProtectionConfig;
+    dangerouslyAllowNameMatching?: boolean;
+    requireMention?: boolean;
+    implicitMentions?: OpenClawSlackImplicitMentionsConfig;
+    groupPolicy?: OpenClawSlackGroupPolicy;
+    mentionPatterns?: OpenClawSlackMentionPatternsConfig;
+    contextVisibility?: OpenClawSlackContextVisibility;
+    historyLimit?: number;
+    dmHistoryLimit?: number;
+    dms?: Record<string, {
+        historyLimit?: number;
+    }>;
+    textChunkLimit?: number;
+    unfurlLinks?: boolean;
+    unfurlMedia?: boolean;
+    streaming?: OpenClawSlackStreamingConfig;
+    mediaMaxMb?: number;
+    reactionNotifications?: 'off' | 'own' | 'all' | 'allowlist';
+    reactionAllowlist?: Array<string | number>;
+    replyToMode?: OpenClawSlackReplyToMode;
+    replyToModeByChatType?: Partial<Record<'direct' | 'group' | 'channel', OpenClawSlackReplyToMode>>;
+    thread?: OpenClawSlackThreadConfig;
+    presenceEvents?: OpenClawSlackPresenceEventsConfig;
+    actions?: OpenClawSlackActionsConfig;
+    slashCommand?: OpenClawSlackSlashCommandConfig;
+    dmPolicy?: OpenClawSlackDmPolicy;
+    allowFrom?: Array<string | number>;
+    defaultTo?: string;
+    dm?: OpenClawSlackDmConfig;
+    channels?: Record<string, OpenClawSlackChannelConfig>;
+    heartbeat?: OpenClawSlackHeartbeatConfig;
+    healthMonitor?: OpenClawSlackHealthMonitorConfig;
+    responsePrefix?: string;
+    ackReaction?: string;
+    typingReaction?: string;
+}
+export interface OpenClawSlackConfig extends OpenClawSlackAccountConfig {
+    accounts?: Record<string, OpenClawSlackAccountConfig>;
+    defaultAccount?: string;
+}
+export type OpenClawSlackChannelId = string;
+export type OpenClawSlackUserId = string;
+export type OpenClawSlackMessageId = string;
+export type OpenClawSlackThreadId = string;
+export type OpenClawSlackFileId = string;
+export type OpenClawSlackEmoji = string;
+export type OpenClawSlackTarget = OpenClawSlackChannelId | OpenClawSlackUserId;
+export type OpenClawPresentationTone = 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+export type OpenClawPresentationButtonStyle = 'primary' | 'secondary' | 'success' | 'danger';
+export type OpenClawPresentationAction = {
+    type: 'command';
+    command: string;
+} | {
+    type: 'callback';
+    value: string;
+} | {
+    type: 'approval';
+    approvalId: string;
+    approvalKind: 'exec' | 'plugin';
+    decision: 'allow-once' | 'allow-always' | 'deny';
+} | {
+    type: 'url';
+    url: string;
+} | {
+    type: 'web-app';
+    url: string;
+    widgetId?: string;
+} | {
+    type: 'web-app';
+    url?: string;
+    widgetId: string;
+};
+export interface OpenClawPresentationButton {
+    label: string;
+    action?: OpenClawPresentationAction;
+    /** @deprecated Use action. */
+    value?: string;
+    /** @deprecated Use action with type "url". */
+    url?: string;
+    /** @deprecated Use action with type "web-app". */
+    webApp?: {
+        url: string;
+    };
+    /** @deprecated Use action with type "web-app". */
+    web_app?: {
+        url: string;
+    };
+    priority?: number;
+    disabled?: boolean;
+    reusable?: boolean;
+    style?: OpenClawPresentationButtonStyle;
+}
+export interface OpenClawPresentationOption {
+    label: string;
+    action?: Extract<OpenClawPresentationAction, {
+        type: 'command' | 'callback';
+    }>;
+    /** @deprecated Use action. */
+    value?: string;
+}
+export interface OpenClawPresentationPieChart {
+    type: 'chart';
+    chartType: 'pie';
+    title: string;
+    segments: Array<{
+        label: string;
+        value: number;
+    }>;
+}
+export interface OpenClawPresentationSeriesChart {
+    type: 'chart';
+    chartType: 'bar' | 'area' | 'line';
+    title: string;
+    categories: string[];
+    series: Array<{
+        name: string;
+        values: number[];
+    }>;
+    xLabel?: string;
+    yLabel?: string;
+}
+export interface OpenClawPresentationTable {
+    type: 'table';
+    caption: string;
+    headers: string[];
+    rows: Array<Array<string | number>>;
+    rowHeaderColumnIndex?: number;
+}
+export type OpenClawPresentationBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'context';
+    text: string;
+} | {
+    type: 'divider';
+} | {
+    type: 'buttons';
+    buttons: OpenClawPresentationButton[];
+} | {
+    type: 'select';
+    placeholder?: string;
+    options: OpenClawPresentationOption[];
+} | OpenClawPresentationPieChart | OpenClawPresentationSeriesChart | OpenClawPresentationTable;
+export interface OpenClawPresentation {
+    title?: string;
+    tone?: OpenClawPresentationTone;
+    blocks: OpenClawPresentationBlock[];
+}
+export type OpenClawInteractiveReplyBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'buttons';
+    buttons: OpenClawPresentationButton[];
+} | {
+    type: 'select';
+    placeholder?: string;
+    options: OpenClawPresentationOption[];
+};
+export interface OpenClawInteractiveReply {
+    blocks: OpenClawInteractiveReplyBlock[];
+}
+export interface OpenClawSlackOperationOptions {
+    accountId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    agentId?: string;
+    directOperator?: boolean;
+    idempotencyKey?: string;
+}
+export interface OpenClawSlackMessageActionRequest {
+    channel: 'slack';
+    action: OpenClawSlackActionName;
+    params: Record<string, unknown>;
+    accountId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    agentId?: string;
+    conversationReadOrigin?: 'direct-operator';
+    idempotencyKey: string;
+}
+export type OpenClawSlackActionName = 'send' | 'upload-file' | 'download-file' | 'read' | 'edit' | 'delete' | 'react' | 'reactions' | 'pin' | 'unpin' | 'list-pins' | 'member-info' | 'emoji-list';
+type ForwardCompatible<T extends object> = T & Record<string, unknown>;
+export interface OpenClawSlackMessageSummary extends Record<string, unknown> {
+    ts?: string;
+    timestampMs?: number;
+    timestampUtc?: string;
+    text?: string;
+    user?: string;
+    thread_ts?: string;
+    reply_count?: number;
+    reactions?: OpenClawSlackReaction[];
+    files?: Array<{
+        id?: string;
+        name?: string;
+        mimetype?: string;
+    } & Record<string, unknown>>;
+}
+export interface OpenClawSlackReaction extends Record<string, unknown> {
+    name?: string;
+    count?: number;
+    users?: string[];
+}
+export interface OpenClawSlackPin extends Record<string, unknown> {
+    type?: string;
+    message?: ({
+        ts?: string;
+        timestampMs?: number;
+        timestampUtc?: string;
+        text?: string;
+    } & Record<string, unknown>);
+    file?: ({
+        id?: string;
+        name?: string;
+    } & Record<string, unknown>);
+}
+export type OpenClawMessageReceiptPartKind = 'text' | 'media' | 'voice' | 'poll' | 'card' | 'preview' | 'unknown';
+export interface OpenClawMessageReceiptPart extends Record<string, unknown> {
+    platformMessageId: string;
+    kind: OpenClawMessageReceiptPartKind;
+    index: number;
+    threadId?: string;
+    replyToId?: string;
+    raw?: Record<string, unknown>;
+}
+export interface OpenClawMessageReceipt extends Record<string, unknown> {
+    primaryPlatformMessageId?: string;
+    platformMessageIds: string[];
+    parts: OpenClawMessageReceiptPart[];
+    threadId?: string;
+    replyToId?: string;
+    editToken?: string;
+    deleteToken?: string;
+    sentAt: number;
+    raw?: readonly Record<string, unknown>[];
+}
+export type OpenClawSlackSendResult = ForwardCompatible<{
+    channelId: string;
+    messageId: string;
+    receipt: OpenClawMessageReceipt;
+    threadTs?: string;
+}>;
+export type OpenClawSlackSendActionResult = ForwardCompatible<{
+    ok: true;
+    result: OpenClawSlackSendResult;
+}>;
+export type OpenClawSlackMutationResult = ForwardCompatible<{
+    ok: true;
+}>;
+export type OpenClawSlackAddReactionResult = ForwardCompatible<{
+    ok: true;
+    added: string;
+}>;
+export type OpenClawSlackRemoveReactionResult = ForwardCompatible<{
+    ok: true;
+    removed: string;
+}>;
+export type OpenClawSlackClearReactionsResult = ForwardCompatible<{
+    ok: true;
+    removed: string[];
+}>;
+export type OpenClawSlackListReactionsResult = ForwardCompatible<{
+    ok: true;
+    reactions: OpenClawSlackReaction[];
+}>;
+export type OpenClawSlackReadResult = ForwardCompatible<{
+    ok: true;
+    channelId: string;
+    threadId?: string;
+    messages: OpenClawSlackMessageSummary[];
+    hasMore: boolean;
+}>;
+export type OpenClawSlackPinsResult = ForwardCompatible<{
+    ok: true;
+    pins: OpenClawSlackPin[];
+}>;
+export type OpenClawSlackMemberInfoResult = ForwardCompatible<{
+    ok: true;
+    info: Record<string, unknown>;
+}>;
+export type OpenClawSlackEmojiListResult = ForwardCompatible<{
+    ok: true;
+    emojis: ForwardCompatible<{
+        emoji?: Record<string, string>;
+    }>;
+}>;
+export type OpenClawSlackDownloadResult = ForwardCompatible<{
+    ok: false;
+    error: string;
+}> | ForwardCompatible<{
+    ok?: true;
+    fileId: string;
+    path: string;
+    contentType?: string;
+    placeholder?: string;
+    media: ForwardCompatible<{
+        mediaUrl: string;
+        outbound: false;
+        contentType?: string;
+    }>;
+}>;
+interface OpenClawSlackSendMessageInputBase {
+    to: OpenClawSlackTarget;
+    threadId?: OpenClawSlackThreadId | null;
+    replyTo?: OpenClawSlackMessageId;
+    topLevel?: boolean;
+}
+type OpenClawSlackNonMediaContent = {
+    message: string;
+    presentation?: OpenClawPresentation; /** @deprecated Use presentation. */
+    interactive?: OpenClawInteractiveReply;
+} | {
+    message?: string;
+    presentation: OpenClawPresentation; /** @deprecated Use presentation. */
+    interactive?: OpenClawInteractiveReply;
+} | {
+    message?: string;
+    presentation?: OpenClawPresentation; /** @deprecated Use presentation. */
+    interactive: OpenClawInteractiveReply;
+};
+export type OpenClawSlackSendMessageInput = OpenClawSlackSendMessageInputBase & (({
+    media: string;
+    replyBroadcast?: never;
+} & Partial<OpenClawSlackNonMediaContent>) | ({
+    media?: never;
+    replyBroadcast?: boolean;
+} & OpenClawSlackNonMediaContent));
+export interface OpenClawSlackUploadFileInput {
+    to: OpenClawSlackTarget;
+    filePath: string;
+    initialComment?: string;
+    filename?: string;
+    title?: string;
+    threadId?: OpenClawSlackThreadId | null;
+    replyTo?: OpenClawSlackMessageId;
+    topLevel?: boolean;
+}
+interface OpenClawSlackEditMessageInputBase {
+    channelId: OpenClawSlackChannelId;
+    messageId: OpenClawSlackMessageId;
+}
+export type OpenClawSlackEditMessageInput = OpenClawSlackEditMessageInputBase & ({
+    message: string;
+    presentation?: OpenClawPresentation;
+} | {
+    message?: string;
+    presentation: OpenClawPresentation;
+});
+interface OpenClawSlackDownloadFileInputBase {
+    fileId: OpenClawSlackFileId;
+    threadId?: OpenClawSlackThreadId;
+}
+export type OpenClawSlackDownloadFileInput = OpenClawSlackDownloadFileInputBase & ({
+    channelId: OpenClawSlackChannelId;
+    to?: OpenClawSlackTarget;
+} | {
+    channelId?: OpenClawSlackChannelId;
+    to: OpenClawSlackTarget;
+});
+export interface OpenClawSlackReadMessagesInput {
+    channelId: OpenClawSlackChannelId;
+    limit?: number;
+    before?: string;
+    after?: string;
+    threadId?: OpenClawSlackThreadId;
+    messageId?: OpenClawSlackMessageId;
+}
+export interface OpenClawSlackMessageReference {
+    channelId: OpenClawSlackChannelId;
+    messageId: OpenClawSlackMessageId;
+}
+export interface OpenClawSlackReactionInput extends OpenClawSlackMessageReference {
+    emoji: OpenClawSlackEmoji;
+}
+export interface OpenClawSlackAccountStatus extends Record<string, unknown> {
+    accountId?: string;
+    name?: string;
+    mode?: OpenClawSlackMode;
+    configured?: boolean;
+    enabled?: boolean;
+    running?: boolean;
+    connected?: boolean;
+    authenticated?: boolean;
+    healthState?: string;
+    lastError?: string;
+    lastProbeAt?: number;
+    botTokenSource?: string;
+    appTokenSource?: string;
+    signingSecretSource?: string;
+    userTokenSource?: string;
+    botTokenStatus?: 'available' | 'configured_unavailable' | 'missing';
+    appTokenStatus?: 'available' | 'configured_unavailable' | 'missing';
+    signingSecretStatus?: 'available' | 'configured_unavailable' | 'missing';
+    userTokenStatus?: 'available' | 'configured_unavailable' | 'missing';
+    probe?: Record<string, unknown>;
+}
+export type OpenClawSlackStartResult = ForwardCompatible<{
+    channel: 'slack';
+    accountId: string;
+    started: boolean;
+}>;
+export type OpenClawSlackStopResult = ForwardCompatible<{
+    channel: 'slack';
+    accountId: string;
+    stopped: boolean;
+}>;
+export type OpenClawSlackLogoutResult = ForwardCompatible<{
+    channel: 'slack';
+    accountId: string;
+    cleared: boolean;
+}>;
+export type OpenClawSlackPluginInstallAction = {
+    source: 'clawhub';
+    packageName: string;
+} | {
+    source: 'official';
+    pluginId: string;
+};
+export interface OpenClawSlackPluginInfo extends Record<string, unknown> {
+    id: string;
+    name: string;
+    packageName?: string;
+    description?: string;
+    version?: string;
+    kind?: string[];
+    origin?: string;
+    installed: boolean;
+    enabled: boolean;
+    state: 'enabled' | 'disabled' | 'not-installed' | 'error';
+    install?: OpenClawSlackPluginInstallAction;
+    error?: string;
+    removable?: boolean;
+}
+export interface OpenClawSlackPluginsListResult extends Record<string, unknown> {
+    plugins: OpenClawSlackPluginInfo[];
+    diagnostics: unknown[];
+    mutationAllowed: boolean;
+}
+export type OpenClawSlackPluginSupport = {
+    supported: false;
+    mutationAllowed: false;
+} | {
+    supported: true;
+    mutationAllowed: boolean;
+    plugin?: OpenClawSlackPluginInfo;
+};
+export type OpenClawSlackPluginInstallResult = ForwardCompatible<{
+    ok: true;
+    plugin: OpenClawSlackPluginInfo;
+    restartRequired: true;
+    warnings?: string[];
+}>;
+export type OpenClawSlackPluginEnabledResult = ForwardCompatible<{
+    ok: true;
+    plugin: OpenClawSlackPluginInfo;
+    restartRequired: boolean;
+    warnings?: string[];
+}>;
+export type OpenClawSlackPluginUninstallResult = ForwardCompatible<{
+    ok: true;
+    pluginId: string;
+    restartRequired: true;
+    removed: string[];
+    warnings?: string[];
+}>;
+export type OpenClawSlackPluginRefreshResult = ForwardCompatible<{
+    ok: true;
+}>;
+export interface OpenClawSlackCommandArgument {
+    name: string;
+    description: string;
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    choices?: Array<{
+        value: string;
+        label: string;
+    }>;
+    dynamic?: boolean;
+}
+export interface OpenClawSlackCommand {
+    name: string;
+    nativeName?: string;
+    textAliases?: string[];
+    description: string;
+    category?: 'session' | 'options' | 'status' | 'management' | 'media' | 'tools' | 'docks';
+    source: 'native' | 'skill' | 'plugin';
+    scope: 'text' | 'native' | 'both';
+    acceptsArgs: boolean;
+    args?: OpenClawSlackCommandArgument[];
+}
+export interface OpenClawSlackCommandListOptions {
+    agentId?: string;
+    scope?: 'text' | 'native' | 'both';
+    includeArgs?: boolean;
+}
+export type OpenClawSlackCommandRunnerResult = string | {
+    exitCode?: number;
+    exit_code?: number;
+    stdout?: string;
+    stderr?: string;
+};
+export interface OpenClawSlackProviderOptions {
+    runCommand?: (command: string) => Promise<OpenClawSlackCommandRunnerResult>;
+}
+export interface OpenClawSlackPairingRequest extends Record<string, unknown> {
+    id: string;
+    code: string;
+    createdAt: string;
+    lastSeenAt: string;
+    meta?: Record<string, string>;
+}
+export type OpenClawSlackPairingListResult = ForwardCompatible<{
+    channel: 'slack';
+    requests: OpenClawSlackPairingRequest[];
+}>;
+export type OpenClawSlackPairingApprovalResult = ForwardCompatible<{
+    channel: 'slack';
+    approved: true;
+    code: string;
+    mayBootstrapCommandOwner: true;
+    raw?: string;
+}>;
+export interface OpenClawSlackClient {
+    configGet(): Promise<Record<string, unknown>>;
+    configSchemaLookup(path: string): Promise<OpenClawConfigSchemaLookupResult>;
+    configPatch(patch: Record<string, unknown>): Promise<unknown>;
+    channelsStatus(probe?: boolean, timeoutMs?: number, channel?: string): Promise<Record<string, unknown>>;
+    channelsStart(channel: string, accountId?: string): Promise<unknown>;
+    channelsStop(channel: string, accountId?: string): Promise<unknown>;
+    channelsLogout(channel: string, accountId?: string): Promise<unknown>;
+    messageAction(request: OpenClawSlackMessageActionRequest): Promise<unknown>;
+    pluginsList(): Promise<unknown>;
+    pluginsInstall(action: OpenClawSlackPluginInstallAction): Promise<unknown>;
+    pluginsSetEnabled(params: {
+        pluginId: string;
+        enabled: boolean;
+    }): Promise<unknown>;
+    pluginsUninstall(params: {
+        pluginId: string;
+    }): Promise<unknown>;
+    pluginsRefresh(): Promise<unknown>;
+    commandsList(params: {
+        provider: string;
+        agentId?: string;
+        scope?: 'text' | 'native' | 'both';
+        includeArgs?: boolean;
+    }): Promise<{
+        commands: OpenClawSlackCommand[];
+    }>;
+}
+type OpenClawSlackTransportConfigurationBase = Omit<OpenClawSlackAccountConfig, 'mode' | 'botToken' | 'appToken' | 'signingSecret' | 'relay' | 'socketMode' | 'webhookPath'>;
+export type OpenClawSlackSocketConfiguration = OpenClawSlackTransportConfigurationBase & {
+    botToken: OpenClawSlackSecretInput;
+    appToken: OpenClawSlackSecretInput;
+    socketMode?: OpenClawSlackSocketModeConfig;
+};
+export type OpenClawSlackHttpConfiguration = OpenClawSlackTransportConfigurationBase & {
+    botToken: OpenClawSlackSecretInput;
+    signingSecret: OpenClawSlackSecretInput;
+    webhookPath?: string;
+};
+export type OpenClawSlackRelayConfiguration = OpenClawSlackTransportConfigurationBase & {
+    botToken: OpenClawSlackSecretInput;
+    relay: Required<OpenClawSlackRelayConfig>;
+};
+export type OpenClawSlackAccountConfigPatch = {
+    [K in keyof OpenClawSlackAccountConfig]?: OpenClawSlackAccountConfig[K] | null;
+};
+export type OpenClawSlackConfigPatch = OpenClawSlackAccountConfigPatch & {
+    accounts?: Record<string, OpenClawSlackAccountConfigPatch | null> | null;
+    defaultAccount?: string | null;
+};
+export interface OpenClawSlackEnsurePluginResult {
+    plugin: OpenClawSlackPluginInfo;
+    changed: boolean;
+    restartRequired: boolean;
+    warnings?: string[];
+}
+export declare class OpenClawSlackProvider {
+    private readonly client;
+    private readonly options;
+    constructor(client: OpenClawSlackClient, options?: OpenClawSlackProviderOptions);
+    getConfig(): Promise<OpenClawSlackConfig | undefined>;
+    getSchema(): Promise<OpenClawConfigSchemaLookupResult>;
+    getAccountConfig(accountId: string): Promise<OpenClawSlackAccountConfig | undefined>;
+    patchConfig(patch: OpenClawSlackConfigPatch): Promise<void>;
+    patchAccount(accountId: string, patch: OpenClawSlackAccountConfigPatch): Promise<void>;
+    configureSocket(config: OpenClawSlackSocketConfiguration, accountId?: string): Promise<void>;
+    configureHttp(config: OpenClawSlackHttpConfiguration, accountId?: string): Promise<void>;
+    configureRelay(config: OpenClawSlackRelayConfiguration, accountId?: string): Promise<void>;
+    removeConfig(): Promise<void>;
+    removeAccount(accountId: string): Promise<void>;
+    setDefaultAccount(accountId: string): Promise<void>;
+    status(accountId?: string): Promise<OpenClawSlackAccountStatus | undefined>;
+    probe(accountId?: string, timeoutMs?: number): Promise<OpenClawSlackAccountStatus | undefined>;
+    start(accountId?: string): Promise<OpenClawSlackStartResult>;
+    stop(accountId?: string): Promise<OpenClawSlackStopResult>;
+    logout(accountId?: string): Promise<OpenClawSlackLogoutResult>;
+    pluginInfo(): Promise<OpenClawSlackPluginInfo | undefined>;
+    pluginSupport(): Promise<OpenClawSlackPluginSupport>;
+    ensurePluginInstalled(): Promise<OpenClawSlackEnsurePluginResult>;
+    ensurePluginInstalledWithCli(): Promise<OpenClawSlackEnsurePluginResult>;
+    verifyPluginRuntimeWithCli(): Promise<OpenClawSlackPluginInfo>;
+    restartGateway(): Promise<void>;
+    setPluginEnabled(enabled: boolean): Promise<OpenClawSlackPluginEnabledResult>;
+    uninstallPlugin(): Promise<OpenClawSlackPluginUninstallResult>;
+    refreshPlugins(): Promise<OpenClawSlackPluginRefreshResult>;
+    listCommands(options?: OpenClawSlackCommandListOptions): Promise<OpenClawSlackCommand[]>;
+    listPairings(accountId?: string): Promise<OpenClawSlackPairingListResult>;
+    approvePairing(code: string, options?: {
+        accountId?: string;
+        notify?: boolean;
+    }): Promise<OpenClawSlackPairingApprovalResult>;
+    sendMessage(input: OpenClawSlackSendMessageInput, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackSendActionResult>;
+    uploadFile(input: OpenClawSlackUploadFileInput, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackSendActionResult>;
+    downloadFile(input: OpenClawSlackDownloadFileInput, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackDownloadResult>;
+    readMessages(input: OpenClawSlackReadMessagesInput, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackReadResult>;
+    editMessage(input: OpenClawSlackEditMessageInput, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackMutationResult>;
+    deleteMessage(input: OpenClawSlackMessageReference, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackMutationResult>;
+    addReaction(input: OpenClawSlackReactionInput, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackAddReactionResult>;
+    removeReaction(input: OpenClawSlackReactionInput, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackRemoveReactionResult>;
+    clearOwnReactions(input: OpenClawSlackMessageReference, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackClearReactionsResult>;
+    listReactions(input: OpenClawSlackMessageReference, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackListReactionsResult>;
+    pinMessage(input: OpenClawSlackMessageReference, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackMutationResult>;
+    unpinMessage(input: OpenClawSlackMessageReference, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackMutationResult>;
+    listPins(channelId: OpenClawSlackChannelId, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackPinsResult>;
+    getMemberInfo(userId: OpenClawSlackUserId, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackMemberInfoResult>;
+    listEmojis(limit?: number, options?: OpenClawSlackOperationOptions): Promise<OpenClawSlackEmojiListResult>;
+    private patchTransport;
+    private readStatus;
+    private requireCommandRunner;
+    private safeCliAccountId;
+    private messageReference;
+    private messageReferenceAction;
+    private action;
+}
+export {};
+//# sourceMappingURL=slack.d.ts.map