/**
 * SlackLiveSender — the real Slack `SurfaceSender` for the live-test harness
 * (docs/specs/live-user-channel-proof-standard.md §5.4). It posts a message into a
 * Slack channel AS A NON-AGENT IDENTITY (a user/second-bot token, NOT Echo's own bot
 * — Echo never replies to itself) and then waits for the AGENT's reply by polling the
 * channel history for a message from the agent's bot user id.
 *
 * Parameterization is deliberate: the sender takes an already-constructed
 * `SlackApiClient` (carrying the non-Echo sender token) + the agent's bot user id. So
 * the CODE is complete and unit-testable here; the only thing that has to be provided
 * at wiring time is the sender CREDENTIAL (a user token / second-bot token in the
 * demo workspace). That credential is the one piece that may need provisioning — the
 * logic does not.
 *
 * `awaitReply` identifies the agent's reply DETERMINISTICALLY (a message strictly
 * after the sent ts whose author is the agent's bot user id), never a fuzzy guess, and
 * resolves null on timeout (the harness records that as a FAIL with reason). The
 * responder-MACHINE attribution (the cross-machine proof) is NOT done here — that is
 * the RealChannelDriver's injected placement reader; this sender only returns the
 * reply text + id.
 */
import type { SurfaceSender } from './RealChannelDriver.js';
import type { SendResult, ReplyResult } from './LiveTestHarness.js';
/** Minimal Slack client surface this sender needs (matches SlackApiClient.call). */
export interface SlackCaller {
    call(method: string, params?: Record<string, unknown>): Promise<{
        ok?: boolean;
        ts?: string;
        messages?: Array<{
            ts: string;
            user?: string;
            bot_id?: string;
            text?: string;
            subtype?: string;
        }>;
        [k: string]: unknown;
    }>;
}
export interface SlackLiveSenderDeps {
    /** A SlackApiClient constructed with the NON-AGENT sender token (the user-role identity). */
    api: SlackCaller;
    /** The agent's (Echo's) Slack bot user id — awaitReply waits for a reply authored by THIS id. */
    agentBotUserId: string;
    /** Poll cadence while awaiting a reply. Default 2000ms. */
    pollIntervalMs?: number;
    /** Injected for tests; defaults to real timers / clock. */
    sleep?: (ms: number) => Promise<void>;
    now?: () => number;
    logger?: (m: string) => void;
}
export declare class SlackLiveSender implements SurfaceSender {
    private readonly d;
    constructor(deps: SlackLiveSenderDeps);
    private now;
    private sleep;
    private log;
    send(channelId: string, text: string): Promise<SendResult>;
    awaitReply(channelId: string, opts: {
        timeoutMs: number;
        afterMessageId?: string;
    }): Promise<Omit<ReplyResult, 'responderMachineId'> | null>;
    /** Find the FIRST agent-authored message strictly after `after` (oldest-first). */
    private findAgentReply;
}
//# sourceMappingURL=SlackLiveSender.d.ts.map