import { ChannelSync } from "../channel-sync";
import { MessageStore } from "../message-store";
import { MemoryOutboxStorage, Outbox } from "../outbox";
import { SimServer } from "./server";
import type { Message } from "@slackwsh/contracts";
export declare class SimClient {
    readonly userId: number;
    private readonly server;
    private readonly uuidOffset;
    readonly store: MessageStore;
    readonly outboxStorage: MemoryOutboxStorage;
    readonly outbox: Outbox;
    sync: ChannelSync;
    connected: boolean;
    socketId: string;
    extraSocketId: string | null;
    /** Last presence snapshot this client rendered. */
    readonly presence: Map<number, "active" | "offline">;
    /** Server-authoritative unread, discarded and rehydrated on reconnect (§5.3). */
    displayedUnread: number;
    displayedMentionBadge: number;
    displayedThreadUnread: Map<number, number>;
    private nextClientMsg;
    private socketSeq;
    constructor(userId: number, server: SimServer, uuidOffset: number);
    private newSync;
    open(): Promise<void>;
    catchUp(): Promise<void>;
    /** Channel re-open: drop the cache and load the latest window from the server. */
    fullReconcile(): Promise<void>;
    rehydrateReadState(): void;
    disconnect(graceful: boolean): void;
    reconnect(): Promise<void>;
    addExtraSocket(): void;
    dropExtraSocket(graceful: boolean): void;
    heartbeat(): void;
    onEvent(event: {
        type: string;
        messageId?: number;
        seq?: number;
        userId?: number;
        status?: "active" | "offline";
    }): Promise<void>;
    send(text: string, opts?: {
        parentId?: number | null;
        isBroadcast?: boolean;
    }): Promise<void>;
    private flushEntry;
    ackUpToLatest(): void;
    markLatestUnread(): void;
    ackThreads(): void;
    renderedChannel(): Message[];
}
export declare function uuidFrom(n: number): string;
export declare function assertInvariants(server: SimServer, clients: SimClient[]): void;
//# sourceMappingURL=client.d.ts.map