import type { MessageListQuery, MessageWithMeta, SearchMessageResult, MessageBlock, SendDmResponse, DmMessage, CreateGroupDmRequest, CreateGroupDmResponse, GroupDmMessageResponse, GroupDmParticipantResponse, DmConversationSummary, CreateChannelRequest, UpdateChannelRequest, Channel, ChannelMemberInfo, JoinChannelResponse, InviteChannelResponse, AddedReaction, ReadReceipt, ReactionGroup, InboxResponse, ReaderInfo, ChannelReadStatus, UploadRequest, UploadResponse, CompleteUploadResponse, FileInfo, InvokeCommandRequest, CommandInvokeResult, WsClientEvent, MessageCreatedEvent, MessageUpdatedEvent, ThreadReplyEvent, MessageReadEvent, ReactionAddedEvent, ReactionRemovedEvent, DmReceivedEvent, GroupDmReceivedEvent, RelaycastMessageEvent, AgentOnlineEvent, AgentOfflineEvent, ChannelCreatedEvent, ChannelUpdatedEvent, ChannelArchivedEvent, MemberJoinedEvent, MemberLeftEvent, ChannelMutedEvent, ChannelUnmutedEvent, FileUploadedEvent, WebhookReceivedEvent, CommandInvokedEvent } from './types.js';
import { HttpClient } from './client.js';
import { type WsClientOptions } from './ws.js';
import type { Subscription } from './subscription.js';
interface IdempotencyOption {
    idempotencyKey?: string;
}
interface ChannelListOptions {
    includeArchived?: boolean;
}
interface FileListOptions {
    uploadedBy?: string;
    limit?: number;
}
export interface AgentClientOptions {
    autoHeartbeatMs?: number | false;
    ws?: Omit<WsClientOptions, 'token' | 'baseUrl'>;
}
type RelaycastMessageHandler = (event: RelaycastMessageEvent) => void | Promise<void>;
export declare class AgentClient {
    readonly client: HttpClient;
    private ws;
    private autoHeartbeatMs;
    private autoHeartbeatTimer;
    private pendingHeartbeat;
    private wsOptions;
    private manualSubscriptions;
    private managedSubscriptions;
    private activeWsChannels;
    constructor(client: HttpClient, options?: AgentClientOptions);
    /**
     * Presence lifecycle ownership:
     * - worker identities should call `markOnline`/`heartbeat`/`markOffline`.
     * - broker identities should signal presence only when they directly own worker lifecycle.
     * - reader identities should not publish presence.
     */
    presence: {
        markOnline: () => Promise<void>;
        heartbeat: () => Promise<void>;
        markOffline: () => Promise<void>;
    };
    private startAutoHeartbeat;
    private stopAutoHeartbeat;
    connect(): void;
    /** Send a REST heartbeat to keep this agent online in PresenceDO without a WebSocket. */
    heartbeat(): Promise<void>;
    disconnect(): Promise<void>;
    subscribe(channels: string[]): void;
    subscribe(channels: string[], onMessage: RelaycastMessageHandler): Subscription;
    unsubscribe(channels: string[]): void;
    private onEvent;
    on: {
        messageCreated: (handler: (e: MessageCreatedEvent) => void) => (() => void);
        messageUpdated: (handler: (e: MessageUpdatedEvent) => void) => (() => void);
        threadReply: (handler: (e: ThreadReplyEvent) => void) => (() => void);
        messageRead: (handler: (e: MessageReadEvent) => void) => (() => void);
        reactionAdded: (handler: (e: ReactionAddedEvent) => void) => (() => void);
        reactionRemoved: (handler: (e: ReactionRemovedEvent) => void) => (() => void);
        dmReceived: (handler: (e: DmReceivedEvent) => void) => (() => void);
        groupDmReceived: (handler: (e: GroupDmReceivedEvent) => void) => (() => void);
        agentOnline: (handler: (e: AgentOnlineEvent) => void) => (() => void);
        agentOffline: (handler: (e: AgentOfflineEvent) => void) => (() => void);
        channelCreated: (handler: (e: ChannelCreatedEvent) => void) => (() => void);
        channelUpdated: (handler: (e: ChannelUpdatedEvent) => void) => (() => void);
        channelArchived: (handler: (e: ChannelArchivedEvent) => void) => (() => void);
        memberJoined: (handler: (e: MemberJoinedEvent) => void) => (() => void);
        memberLeft: (handler: (e: MemberLeftEvent) => void) => (() => void);
        channelMuted: (handler: (e: ChannelMutedEvent) => void) => (() => void);
        channelUnmuted: (handler: (e: ChannelUnmutedEvent) => void) => (() => void);
        fileUploaded: (handler: (e: FileUploadedEvent) => void) => (() => void);
        webhookReceived: (handler: (e: WebhookReceivedEvent) => void) => (() => void);
        commandInvoked: (handler: (e: CommandInvokedEvent) => void) => (() => void);
        connected: (handler: () => void) => (() => void);
        disconnected: (handler: () => void) => (() => void);
        error: (handler: () => void) => (() => void);
        reconnecting: (handler: (attempt: number) => void) => (() => void);
        permanentlyDisconnected: (handler: (attempt: number) => void) => (() => void);
        any: (handler: (e: WsClientEvent) => void) => (() => void);
    };
    send(channel: string, text: string, opts?: {
        attachments?: string[];
        blocks?: MessageBlock[];
        mode?: 'wait' | 'steer';
        idempotencyKey?: string;
    }): Promise<MessageWithMeta>;
    post(channel: string, text: string, opts?: {
        attachments?: string[];
        blocks?: MessageBlock[];
        mode?: 'wait' | 'steer';
        idempotencyKey?: string;
    }): Promise<MessageWithMeta>;
    messages(channel: string, opts?: MessageListQuery): Promise<MessageWithMeta[]>;
    message(id: string): Promise<MessageWithMeta>;
    reply(id: string, text: string, opts?: {
        blocks?: MessageBlock[];
        idempotencyKey?: string;
    }): Promise<MessageWithMeta>;
    thread(id: string, opts?: MessageListQuery): Promise<{
        parent: MessageWithMeta;
        replies: MessageWithMeta[];
    }>;
    dm(agent: string, text: string, opts?: (IdempotencyOption & {
        mode?: 'wait' | 'steer';
        attachments?: string[];
    })): Promise<SendDmResponse>;
    dms: {
        conversations: () => Promise<DmConversationSummary[]>;
        messages: (conversationId: string, opts?: MessageListQuery) => Promise<DmMessage[]>;
        createGroup: (opts: CreateGroupDmRequest, idempotency?: IdempotencyOption) => Promise<CreateGroupDmResponse>;
        sendMessage: (conversationId: string, text: string, opts?: (IdempotencyOption & {
            attachments?: string[];
            mode?: "wait" | "steer";
        })) => Promise<GroupDmMessageResponse>;
        addParticipant: (conversationId: string, agent: string) => Promise<GroupDmParticipantResponse>;
        removeParticipant: (conversationId: string, agent: string) => Promise<void>;
    };
    private matchesSubscription;
    private desiredWsChannels;
    private syncDesiredSubscriptions;
    channels: {
        create: (data: CreateChannelRequest) => Promise<Channel>;
        list: (opts?: ChannelListOptions) => Promise<Channel[]>;
        get: (name: string) => Promise<Channel & {
            members: ChannelMemberInfo[];
        }>;
        join: (name: string) => Promise<JoinChannelResponse>;
        leave: (name: string) => Promise<void>;
        setTopic: (name: string, topic: string) => Promise<Channel>;
        archive: (name: string) => Promise<void>;
        invite: (channel: string, agent: string) => Promise<InviteChannelResponse>;
        members: (name: string) => Promise<ChannelMemberInfo[]>;
        update: (name: string, data: UpdateChannelRequest) => Promise<Channel>;
        mute: (name: string) => Promise<void>;
        unmute: (name: string) => Promise<void>;
    };
    react(messageId: string, emoji: string): Promise<AddedReaction>;
    unreact(messageId: string, emoji: string): Promise<void>;
    reactions(messageId: string): Promise<ReactionGroup[]>;
    search(query: string, opts?: {
        channel?: string;
        from?: string;
        limit?: number;
        before?: string;
        after?: string;
    }): Promise<SearchMessageResult[]>;
    inbox(options?: {
        limit?: number;
    }): Promise<InboxResponse>;
    markRead(messageId: string): Promise<ReadReceipt>;
    readers(messageId: string): Promise<ReaderInfo[]>;
    readStatus(channel: string): Promise<ChannelReadStatus[]>;
    commands: {
        invoke: (command: string, data: InvokeCommandRequest) => Promise<CommandInvokeResult>;
    };
    files: {
        upload: (data: UploadRequest) => Promise<UploadResponse>;
        complete: (fileId: string) => Promise<CompleteUploadResponse>;
        get: (fileId: string) => Promise<FileInfo>;
        delete: (fileId: string) => Promise<void>;
        list: (opts?: FileListOptions) => Promise<FileInfo[]>;
    };
}
export {};
//# sourceMappingURL=agent.d.ts.map