import type { ConversationLogMessage, RunAnswer } from "../../types.js";
import type { MessagingBot, ConversationEvent, MessagingEventHandler, MessagingInfo } from "../../types.js";
import type { EventScheduler } from "../../events/scheduler.js";
import type { SlackChannel, SlackMessagingBotOptions, SlackUser, SuggestedPrompt } from "./types.js";
import type { SlackPersonaIdentity } from "./persona.js";
export declare function chunkStreamText(text: string, limit?: number): string[];
export declare function italicizeLines(text: string): string;
export declare function buildMrkdwnContextBlock(text: string): object;
export declare class SlackMessagingBot implements MessagingBot {
    private socketClient;
    private webClient;
    private readonly statusClient;
    private readonly fetchFn;
    private readonly statusUpdates;
    private handler;
    private workspace;
    private botToken;
    private botUserId;
    private botId;
    private teamId;
    private ownMentionRegex;
    private startupTs;
    private users;
    private channels;
    private assistantThreads;
    private streamStarts;
    private stopped;
    private queues;
    private readonly taskQueueKeys;
    private intake;
    private readonly recentMessageKeys;
    private agentSurfaceUnavailable;
    private eventScheduler;
    private office;
    private conversationDir;
    private resolveReplyMode;
    private createContext;
    constructor(handler: MessagingEventHandler, config: SlackMessagingBotOptions);
    setEventScheduler(scheduler: EventScheduler): void;
    start(): Promise<void>;
    stop(): Promise<void>;
    getUser(userId: string): SlackUser | undefined;
    getChannel(channelId: string): SlackChannel | undefined;
    getAllUsers(): SlackUser[];
    getAllChannels(): SlackChannel[];
    private stripOwnMention;
    private resolveMentions;
    postMessage(channel: string, text: string, threadTs?: string, identity?: SlackPersonaIdentity): Promise<string>;
    addReaction(channel: string, messageTs: string, emoji: string): Promise<void>;
    postEphemeral(channel: string, user: string, text: string, threadTs?: string, blocks?: object[]): Promise<void>;
    postEphemeralBlocks(channel: string, user: string, text: string, blocks: object[], threadTs?: string): Promise<void>;
    postMessageBlocks(channel: string, text: string, blocks: object[], threadTs?: string): Promise<string>;
    updateMessageBlocks(channel: string, ts: string, text: string, blocks: object[]): Promise<void>;
    postPrivate(conversationId: string, userId: string, text: string): Promise<void>;
    postPrivateDiagnostic(conversationId: string, userId: string, text: string, options?: {
        style?: "muted" | "error";
    }): Promise<void>;
    private openDirectConversation;
    updateMessage(channel: string, ts: string, text: string): Promise<void>;
    tryReserveStreamStart(): boolean;
    startMessageStream(channel: string, text: string, threadTs?: string, recipientUserId?: string): Promise<string>;
    appendMessageStream(channel: string, ts: string, text: string): Promise<void>;
    private appendStreamChunk;
    stopMessageStream(channel: string, ts: string): Promise<void>;
    deleteMessage(channel: string, ts: string): Promise<void>;
    setAssistantStatus(channel: string, threadTs: string, status: string): Promise<void>;
    setAssistantSuggestedPrompts(channel: string, threadTs: string | undefined, prompts: SuggestedPrompt[]): Promise<void>;
    setAssistantTitle(channel: string, threadTs: string, title: string): Promise<void>;
    private assistantOps;
    private handleAssistantThreadStarted;
    private handleAgentContextChangedEvent;
    postInThread(channel: string, threadTs: string, text: string, identity?: SlackPersonaIdentity): Promise<string>;
    postInThreadBlocks(channel: string, threadTs: string, text: string, blocks: object[]): Promise<string>;
    uploadFile(channel: string, filePath: string, title?: string, threadTs?: string): Promise<void>;
    logToFile(channel: string, entry: ConversationLogMessage): void;
    logBotResponse(channel: string, text: string, ts: string, threadTs?: string, { slackBlocks, answer }?: {
        slackBlocks?: object[];
        answer?: RunAnswer;
    }): void;
    ownsBlockKitMessage(channel: string, ts: string, threadTs?: string): boolean;
    getMessagingInfo(): MessagingInfo;
    enqueueEvent(event: ConversationEvent): boolean;
    private getQueue;
    private resolveQueueKey;
    private enqueueTaskRun;
    private resumeInterruptedTasks;
    private isTaskThread;
    private hasRunningTaskThread;
    private hasKnownThreadSession;
    private channelKindFor;
    private backfillChannelKinds;
    private processSlackMessageIntake;
    private appendRunningTasks;
    private appendScheduledJobs;
    private buildHomeView;
    private createCommandAdapters;
    private buildSlashCommandEvent;
    private routeSlashCommand;
    private setupEventHandlers;
    private isRedelivery;
    private handleAppMention;
    private admitHumanMessage;
    private deliverTaskUpdate;
    private evaluateJevAddressed;
    private handleMessageEvent;
    private handleSlashCommand;
    private handleAppHomeOpened;
    private handleBlockAction;
    private handleSlackInteraction;
    private processAttachments;
    private downloadSlackFile;
    private logUserMessage;
    private logExternalMessagingBotMessage;
    private getExistingTimestamps;
    private isBackfillableMessage;
    private backfillChannel;
    private backfillAllChannels;
    private fetchUsers;
    private fetchChannels;
}
//# sourceMappingURL=bot.d.ts.map