@openmarket/rooms-client 0.1.0

package/dist/shared/rooms-protocol.js

@@ -0,0 +1,160 @@
+export const RoomClientMessageType = {
+    AUTHENTICATE: "AUTHENTICATE",
+    CREATE_ROOM: "CREATE_ROOM",
+    INVITE: "INVITE",
+    REMOVE_MEMBER: "REMOVE_MEMBER",
+    SEARCH: "SEARCH",
+    JOIN: "JOIN",
+    HISTORY: "HISTORY",
+    PEEK: "PEEK",
+    LEAVE: "LEAVE",
+    POST: "POST",
+    REACT: "REACT",
+    EDIT: "EDIT",
+    DELETE: "DELETE",
+    THREAD: "THREAD",
+    PIN: "PIN",
+    UNPIN: "UNPIN",
+    PINS: "PINS",
+    REACTORS: "REACTORS",
+    REPORT: "REPORT",
+    MUTE: "MUTE",
+    KICK: "KICK",
+    BAN: "BAN",
+    ROLE_CHANGE: "ROLE_CHANGE",
+    SET_READ_ONLY: "SET_READ_ONLY",
+    AUDIT_LOG: "AUDIT_LOG",
+    SPACES: "SPACES",
+    JOIN_SPACE: "JOIN_SPACE",
+    READ_STATE: "READ_STATE",
+    SEARCH_ENTRIES: "SEARCH_ENTRIES",
+    WHO: "WHO",
+    TYPING: "TYPING",
+    STATUS: "STATUS",
+    ACK: "ACK",
+    PING: "PING",
+    FRIENDS: "FRIENDS",
+    DM_OPEN: "DM_OPEN",
+    DM_HISTORY: "DM_HISTORY",
+    DM_SEND: "DM_SEND",
+    DM_READ: "DM_READ",
+    TOPIC_CREATE: "TOPIC_CREATE",
+    TOPIC_RENAME: "TOPIC_RENAME",
+    TOPIC_MOVE: "TOPIC_MOVE",
+    TOPIC_MERGE: "TOPIC_MERGE",
+    TOPIC_RESOLVE: "TOPIC_RESOLVE",
+    TOPIC_SET_ATTENTION: "TOPIC_SET_ATTENTION",
+    TOPIC_LIST: "TOPIC_LIST",
+};
+export const RoomServerMessageType = {
+    AUTH_SUCCESS: "AUTH_SUCCESS",
+    ROOM_CREATED: "ROOM_CREATED",
+    ROOM_INVITED: "ROOM_INVITED",
+    ROOM_MEMBER_REMOVED: "ROOM_MEMBER_REMOVED",
+    ROOMS: "ROOMS",
+    BACKFILL: "BACKFILL",
+    HISTORY: "HISTORY",
+    PEEK_RESULT: "PEEK_RESULT",
+    MESSAGE: "MESSAGE",
+    ENTRY_UPDATED: "ENTRY_UPDATED",
+    THREAD: "THREAD",
+    PINS: "PINS",
+    REACTORS: "REACTORS",
+    ROOM_REPORTED: "ROOM_REPORTED",
+    ROOM_MUTED: "ROOM_MUTED",
+    ROOM_BANNED: "ROOM_BANNED",
+    ROOM_MEMBER_ROLE_CHANGED: "ROOM_MEMBER_ROLE_CHANGED",
+    ROOM_READ_ONLY_SET: "ROOM_READ_ONLY_SET",
+    ROOM_AUDIT_LOG: "ROOM_AUDIT_LOG",
+    SPACES: "SPACES",
+    SPACE_JOINED: "SPACE_JOINED",
+    SPACE_MEMBER_ADDED: "SPACE_MEMBER_ADDED",
+    SPACE_INVITE: "SPACE_INVITE",
+    ROOM_UPDATED: "ROOM_UPDATED",
+    SPACE_UPDATED: "SPACE_UPDATED",
+    READ_STATE: "READ_STATE",
+    SEARCH_RESULTS: "SEARCH_RESULTS",
+    PRESENCE: "PRESENCE",
+    RESYNC: "RESYNC",
+    PRESENCE_DELTA: "PRESENCE_DELTA",
+    WHO: "WHO",
+    TYPING: "TYPING",
+    ERROR: "ERROR",
+    PONG: "PONG",
+    FRIENDS: "FRIENDS",
+    DM_OPENED: "DM_OPENED",
+    DM_HISTORY: "DM_HISTORY",
+    DM_MESSAGE: "DM_MESSAGE",
+    DM_INBOX_UPDATED: "DM_INBOX_UPDATED",
+    TOPIC: "TOPIC",
+    TOPICS: "TOPICS",
+    TOPIC_UPDATED: "TOPIC_UPDATED",
+};
+export function addBounded(set, value, max) {
+    set.add(value);
+    while (set.size > max) {
+        const oldest = set.values().next().value;
+        if (oldest === undefined)
+            return;
+        set.delete(oldest);
+    }
+}
+export const SUPPORTED_ROOM_PROTOCOL_VERSION = 2;
+export const RoomLedgerEntryType = {
+    POST: "post",
+    SYSTEM: "system",
+    SYSTEM_MARKET: "system_market",
+    MODERATION: "moderation",
+    SECRET: "secret",
+};
+export function isSystemRoomLedgerEntryType(type) {
+    return (type === RoomLedgerEntryType.SYSTEM ||
+        type === RoomLedgerEntryType.SYSTEM_MARKET ||
+        type === RoomLedgerEntryType.MODERATION);
+}
+export const ROOM_PRESENCE_SAMPLE_LIMIT = 50;
+/**
+ * Relay typing contract (kiyotaka `room.constants.ts`). Two facts every
+ * client-side typing feature must design against:
+ *
+ * - A typer's roster entry expires ROOM_TYPING_RELAY_ENTRY_TTL_MS after
+ *   their last start frame, and the expiry is pruned lazily on the next
+ *   roster read; it is NEVER broadcast. A client that wants the entry to
+ *   survive a long message must re-send start inside this window, and a
+ *   client rendering the roster must self-expire it locally.
+ * - Roster broadcasts are throttled to one per room per
+ *   ROOM_TYPING_RELAY_BROADCAST_THROTTLE_MS (a trailing broadcast covers
+ *   frames coalesced inside the window), so any roster a client displays
+ *   can be that stale before the next one arrives.
+ */
+export const ROOM_TYPING_RELAY_ENTRY_TTL_MS = 5_000;
+export const ROOM_TYPING_RELAY_BROADCAST_THROTTLE_MS = 2_000;
+export function applyRoomPresenceDelta(current, delta) {
+    let sample = [...(current?.sample ?? current?.members ?? [])];
+    if (delta.left) {
+        const left = delta.left.toLowerCase();
+        sample = sample.filter((member) => member.userId.toLowerCase() !== left);
+    }
+    if (delta.joined) {
+        const joined = delta.joined.userId.toLowerCase();
+        sample = sample.filter((member) => member.userId.toLowerCase() !== joined);
+        if (sample.length < ROOM_PRESENCE_SAMPLE_LIMIT)
+            sample.push(delta.joined);
+    }
+    if (delta.updated) {
+        const updated = delta.updated.userId.toLowerCase();
+        // In-place identity refresh: replace only if already sampled (an update
+        // must not grow the sample past what joins admitted).
+        sample = sample.map((member) => member.userId.toLowerCase() === updated ? { ...member, ...delta.updated } : member);
+    }
+    return {
+        ...(current ?? {}),
+        room: delta.room,
+        humans: delta.humans,
+        agents: delta.agents,
+        total: delta.humans + delta.agents,
+        ...(delta.guestCount !== undefined ? { guestCount: delta.guestCount } : {}),
+        sample,
+        members: sample,
+    };
+}

package/dist/social-client.d.ts

@@ -0,0 +1,361 @@
+import type { RoomDmConversation, RoomDmHistory, RoomDmSendResult, RoomDmUnreadConversation, RoomDoc, RoomDocAttribution, RoomDocChanges, RoomDocConflictHead, RoomDocEditingLease, RoomDocProvenance, RoomDocRevision, RoomDocRunRevertResult, RoomDocWriteResult, RoomFollow, RoomFollowResult, RoomFriend, RoomFriendRequests, RoomPublicProfile, RoomRepliesReadResult, RoomRepliesResult, RoomSocialConfig, RoomSpaceRestorePlan, RoomSpaceRestoreReceipt, RoomSuggestion, RoomSuggestionRequest } from "./social-types.js";
+export type { RoomAttachment, RoomDmConversation, RoomDmHistory, RoomDmMessage, RoomDmParticipant, RoomDmSendResult, RoomDmUnreadConversation, RoomDocAttribution, RoomDocEditingLease, RoomDocMergeRegion, RoomDocRevisionSource, RoomDocRunRevertResult, RoomFollow, RoomFollowResult, RoomFriend, RoomFriendRequest, RoomFriendRequests, RoomPublicProfile, RoomRepliesReadResult, RoomRepliesResult, RoomReplyInboxItem, RoomSocialConfig, RoomSpaceRestoreAction, RoomSpaceRestoreActionKind, RoomSpaceRestorePlan, RoomSpaceRestoreReceipt, RoomSpaceRestoreSummary, RoomSuggestion, RoomSuggestionIntent, RoomSuggestionRequest, RoomSuggestionSource, } from "./social-types.js";
+export declare const ROOM_ATTACHMENT_MAX_BYTES: number;
+export declare class RoomSocialError extends Error {
+    readonly name = "RoomSocialError";
+    readonly status: number;
+    readonly details?: unknown;
+    constructor(message: string, status: number, details?: unknown);
+}
+export declare function resolveRoomChatApiUrl(): string;
+export declare function deriveRoomChatApiUrlFromRoomsUrl(wsUrl: string): string | undefined;
+export declare function listRoomFriends(config: RoomSocialConfig): Promise<RoomFriend[]>;
+export declare function sendRoomFriendRequest(config: RoomSocialConfig, username: string): Promise<{
+    friendshipId?: string;
+    systemMessage?: unknown;
+}>;
+export declare function listRoomFriendRequests(config: RoomSocialConfig): Promise<RoomFriendRequests>;
+export declare function acceptRoomFriendRequest(config: RoomSocialConfig, friendshipId: string): Promise<{
+    friendshipId?: string;
+    systemMessage?: unknown;
+}>;
+export declare function rejectRoomFriendRequest(config: RoomSocialConfig, friendshipId: string): Promise<{
+    success: boolean;
+}>;
+export declare function removeRoomFriend(config: RoomSocialConfig, friendshipId: string): Promise<{
+    success: boolean;
+    systemMessage?: unknown;
+}>;
+export declare function listRoomFollowing(config: RoomSocialConfig): Promise<RoomFollow[]>;
+export declare function followRoomUser(config: RoomSocialConfig, username: string): Promise<RoomFollowResult>;
+export declare function unfollowRoomUser(config: RoomSocialConfig, username: string): Promise<{
+    target?: RoomFollowResult["target"];
+}>;
+export declare function listRoomDmInbox(config: RoomSocialConfig, options?: {
+    unreadOnly?: boolean;
+    limit?: number;
+}): Promise<RoomDmConversation[]>;
+export declare function listUnreadRoomDms(config: RoomSocialConfig, options?: {
+    username?: string;
+    limitPerConversation?: number;
+    markRead?: boolean;
+    signal?: AbortSignal;
+}): Promise<RoomDmUnreadConversation[]>;
+export declare function getRoomDmHistory(config: RoomSocialConfig, username: string, options?: {
+    limit?: number;
+    before?: number;
+    markRead?: boolean;
+}): Promise<RoomDmHistory>;
+export declare function sendRoomDm(config: RoomSocialConfig, username: string, content: string): Promise<RoomDmSendResult>;
+/** Send a sealed DM: the opaque envelope rides in place of content (the door
+ *  accepts exactly one of the two). Callers seal first; nothing here can. */
+export declare function sendRoomDmSecret(config: RoomSocialConfig, username: string, secret: {
+    armored: string;
+    recipients: string[];
+    kind: "text";
+}): Promise<RoomDmSendResult>;
+/**
+ * CAS write conflict: the doc's head moved past the caller's baseRev. Carries
+ * the current head (fetched on demand when the transport dropped it) so the
+ * caller can rebase — typically an agent merge — and retry.
+ */
+export declare class RoomDocConflictError extends RoomSocialError {
+    readonly head: RoomDocConflictHead | null;
+    constructor(message: string, head: RoomDocConflictHead | null);
+}
+export declare function listRoomDocs(config: RoomSocialConfig, options: {
+    spaceId: string;
+    prefix?: string;
+    includeArchived?: boolean;
+    limit?: number;
+}): Promise<RoomDoc[]>;
+export declare function getRoomDocChanges(config: RoomSocialConfig, options: {
+    spaceId: string;
+    since?: number;
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<RoomDocChanges>;
+export declare function searchRoomDocs(config: RoomSocialConfig, options: {
+    spaceId: string;
+    q: string;
+    limit?: number;
+}): Promise<RoomDoc[]>;
+export declare function resolveRoomDoc(config: RoomSocialConfig, spaceId: string, path: string): Promise<RoomDoc>;
+export declare function getRoomDoc(config: RoomSocialConfig, docId: string): Promise<RoomDoc>;
+export declare function createRoomDoc(config: RoomSocialConfig, input: {
+    spaceId: string;
+    path: string;
+    content: string;
+    note?: string;
+    provenance?: RoomDocProvenance;
+    aclMode?: "space" | "owner";
+    asAgent?: boolean;
+} & RoomDocAttribution): Promise<RoomDoc>;
+export declare function updateRoomDoc(config: RoomSocialConfig, docId: string, input: {
+    baseRev: number;
+    content: string;
+    note?: string;
+    provenance?: RoomDocProvenance;
+    asAgent?: boolean;
+} & RoomDocAttribution): Promise<RoomDocWriteResult>;
+export declare function updateRoomDocMeta(config: RoomSocialConfig, docId: string, input: {
+    path?: string;
+    aclMode?: "space" | "owner";
+    restrictedToRoomId?: string | null;
+    note?: string;
+    asAgent?: boolean;
+}): Promise<RoomDoc>;
+export declare function listRoomDocRevisions(config: RoomSocialConfig, docId: string, options?: {
+    beforeRev?: number;
+    limit?: number;
+}): Promise<RoomDocRevision[]>;
+export declare function getRoomDocRevision(config: RoomSocialConfig, docId: string, rev: number): Promise<RoomDocRevision>;
+export declare function revertRoomDoc(config: RoomSocialConfig, docId: string, input: {
+    toRev: number;
+    note?: string;
+    asAgent?: boolean;
+} & RoomDocAttribution): Promise<RoomDocWriteResult>;
+/**
+ * Selective run revert: undo every revision one agent run produced, as ONE
+ * new attributed revision computed server-side (inverse three-way merge
+ * against the current head; later edits survive). A diverging merge comes
+ * back as {status:"conflict"} OUTCOME data carrying the three contents and
+ * regions for the reconcile surface; nothing was written. A mid-commit CAS
+ * race still throws RoomDocConflictError like every other doc write.
+ */
+export declare function revertRoomDocRun(config: RoomSocialConfig, docId: string, input: {
+    runId: string;
+    note?: string;
+    asAgent?: boolean;
+} & RoomDocAttribution): Promise<RoomDocRunRevertResult>;
+export declare function createSpaceRestorePlan(config: RoomSocialConfig, input: {
+    spaceId: string;
+    restoreAt: string;
+    reason: string;
+}): Promise<RoomSpaceRestorePlan>;
+export declare function getSpaceRestorePlan(config: RoomSocialConfig, planId: string): Promise<RoomSpaceRestorePlan>;
+export declare function applySpaceRestorePlan(config: RoomSocialConfig, planId: string, confirmSpaceId: string): Promise<RoomSpaceRestoreReceipt>;
+/** Recover the durable receipt shape from an authoritative applied plan.
+ * Useful when the apply response was lost after the server committed. */
+export declare function spaceRestoreReceiptFromPlan(plan: RoomSpaceRestorePlan): RoomSpaceRestoreReceipt | null;
+export declare function archiveRoomDoc(config: RoomSocialConfig, docId: string, input?: {
+    note?: string;
+    asAgent?: boolean;
+}): Promise<RoomDoc>;
+/** Renew (or create) the caller's "editing" lease on a doc: I hold a dirty
+ *  working copy. Heartbeat well inside the server TTL; content never rides. */
+export declare function heartbeatDocEditing(config: RoomSocialConfig, docId: string, options?: {
+    asAgent?: boolean;
+}): Promise<RoomDocEditingLease | null>;
+/** Drop the caller's own editing lease (publish or discard). */
+export declare function clearDocEditing(config: RoomSocialConfig, docId: string): Promise<{
+    cleared: boolean;
+}>;
+/** Active editing leases across a space (rides the existing library poll). */
+export declare function listDocEditing(config: RoomSocialConfig, spaceId: string): Promise<RoomDocEditingLease[]>;
+export interface RoomSpaceSummary {
+    spaceId: string;
+    name: string;
+    access?: "open" | "invite";
+    joined?: boolean;
+    role?: string | null;
+    /** The #general a new server is born with (present on create). */
+    defaultRoom?: {
+        roomId: string;
+        name?: string;
+    } | undefined;
+    iconUrl?: string | null;
+    /** Creation time — the stable server-rail sort key. */
+    createdAt?: string | number | null;
+}
+export declare function listRoomSpacesViaChat(config: RoomSocialConfig): Promise<RoomSpaceSummary[]>;
+export interface RoomSpaceMember {
+    userId: string;
+    role: "owner" | "admin" | "member";
+    /** Named identity roles (RoomSpaceRole.roleId). */
+    roleIds?: string[];
+    joinedAt?: string;
+}
+export declare function getUserPrefs(config: RoomSocialConfig): Promise<Record<string, unknown>>;
+/** Whole-blob replace (16KB cap server-side; last writer wins). */
+export declare function setUserPrefs(config: RoomSocialConfig, prefs: Record<string, unknown>): Promise<void>;
+export interface RoomSpaceRole {
+    roleId: string;
+    name: string;
+    /** #rrggbb, or null for the default (uncolored) name. */
+    color: string | null;
+    hoist: boolean;
+    position: number;
+}
+export declare function listSpaceRoles(config: RoomSocialConfig, spaceId: string): Promise<RoomSpaceRole[]>;
+export declare function createSpaceRole(config: RoomSocialConfig, spaceId: string, input: {
+    name: string;
+    color?: string | null;
+    hoist?: boolean;
+}): Promise<RoomSpaceRole>;
+export declare function updateSpaceRole(config: RoomSocialConfig, spaceId: string, roleId: string, patch: {
+    name?: string;
+    color?: string | null;
+    hoist?: boolean;
+    position?: number;
+}): Promise<RoomSpaceRole>;
+export declare function deleteSpaceRole(config: RoomSocialConfig, spaceId: string, roleId: string): Promise<void>;
+export declare function setSpaceMemberRoles(config: RoomSocialConfig, spaceId: string, targetUserId: string, roleIds: string[]): Promise<{
+    spaceId: string;
+    userId: string;
+    roleIds: string[];
+}>;
+export declare function listSpaceMembers(config: RoomSocialConfig, spaceId: string): Promise<RoomSpaceMember[]>;
+export declare function addSpaceMember(config: RoomSocialConfig, spaceId: string, input: {
+    targetUserId?: string;
+    targetUsername?: string;
+    role?: "admin" | "member";
+}): Promise<RoomSpaceMember>;
+export interface RoomSpaceInvite {
+    inviteId: string;
+    spaceId: string;
+    spaceName?: string;
+    invitedUserId?: string;
+    invitedBy?: string;
+    role: "admin" | "member";
+    createdAt?: string;
+}
+/** Create (or refresh) a pending invitation. Membership needs their accept. */
+export declare function createSpaceInvite(config: RoomSocialConfig, spaceId: string, input: {
+    targetUserId?: string;
+    targetUsername?: string;
+    role?: "admin" | "member";
+}): Promise<RoomSpaceInvite>;
+/** The caller's own pending invitations. */
+export declare function listMySpaceInvites(config: RoomSocialConfig): Promise<RoomSpaceInvite[]>;
+/** Pending invitations for a space (managers only). */
+export declare function listSpaceInvites(config: RoomSocialConfig, spaceId: string): Promise<RoomSpaceInvite[]>;
+export declare function acceptSpaceInvite(config: RoomSocialConfig, inviteId: string): Promise<{
+    spaceId: string;
+    spaceName?: string;
+    role?: string;
+    joined?: boolean;
+}>;
+export declare function declineSpaceInvite(config: RoomSocialConfig, inviteId: string): Promise<{
+    declined?: boolean;
+}>;
+/** Mint (or rotate) the shareable join code; plaintext comes back once. */
+export declare function setSpaceJoinCode(config: RoomSocialConfig, spaceId: string): Promise<{
+    spaceId: string;
+    code: string;
+}>;
+export declare function clearSpaceJoinCode(config: RoomSocialConfig, spaceId: string): Promise<{
+    cleared?: boolean;
+}>;
+/** Redeem a shareable `<spaceId>:<code>` invite. */
+export declare function joinSpaceByCode(config: RoomSocialConfig, spaceId: string, code: string): Promise<{
+    spaceId: string;
+    spaceName?: string;
+    joined?: boolean;
+}>;
+export interface RoomChatProfile {
+    userId: string;
+    status: "online" | "idle" | "dnd" | null;
+    statusText: string | null;
+    avatarUrl: string | null;
+}
+/**
+ * Bulk identity read (avatar/status/custom text) for tapes and rosters: ONE
+ * request, cap 100 ids. Identity lives on the platform user record
+ * (user_settings.profileUrl / presenceStatus / statusText) — the wire names
+ * map onto the chat-facing shape here. Status WRITES ride the ws STATUS
+ * frame (the relay persists them), avatar writes go through uploadAvatar.
+ */
+export declare function getBulkProfiles(config: RoomSocialConfig, userIds: string[]): Promise<RoomChatProfile[]>;
+/** Rename / re-describe / re-order a channel (owner/admin). */
+export declare function updateRoomChannel(config: RoomSocialConfig, room: string, input: {
+    title?: string;
+    description?: string;
+    category?: string | null;
+    sortOrder?: number;
+    /** The per-channel topics dial (off / allowed / required), owner-set. */
+    topicsPolicy?: "off" | "allowed" | "required";
+}): Promise<Record<string, unknown>>;
+/** Authoritative single-room meta: the store's resolve route through the
+ *  relay BFF (existence-hiding 404 preserved). The task engine's policy
+ *  read rides this, never the ranked room search, because a fresh
+ *  zero-heat room can be crowded out of a search page and an enforcement
+ *  read must be deterministic. */
+export declare function resolveRoomChannel(config: RoomSocialConfig, room: string): Promise<Record<string, unknown> & {
+    topicsPolicy?: "off" | "allowed" | "required";
+}>;
+/** Archive a channel (owner/admin): drops from listings, refuses posts. */
+export declare function archiveRoomChannel(config: RoomSocialConfig, room: string): Promise<{
+    roomId?: string;
+    archived?: boolean;
+}>;
+/** Rename / re-access / re-icon a server (managers). */
+export declare function updateRoomSpace(config: RoomSocialConfig, spaceId: string, input: {
+    name?: string;
+    access?: "open" | "invite";
+    iconUrl?: string | null;
+}): Promise<RoomSpaceSummary>;
+/** Archive a server (owner only). */
+export declare function archiveRoomSpace(config: RoomSocialConfig, spaceId: string): Promise<{
+    archived?: boolean;
+}>;
+/** Full channel roster (paged): role + lastSeen for every membership row. */
+export declare function listRoomChannelMembers(config: RoomSocialConfig, roomId: string, options?: {
+    offset?: number;
+    limit?: number;
+}): Promise<{
+    total: number;
+    offset: number;
+    members: Array<{
+        userId: string;
+        handle: string;
+        role: string;
+        joinedAt?: string;
+        lastSeenAt?: string;
+        avatarUrl?: string | null;
+        status?: string | null;
+        statusText?: string | null;
+    }>;
+}>;
+export declare function removeSpaceMember(config: RoomSocialConfig, spaceId: string, targetUserId: string): Promise<{
+    removed?: boolean;
+}>;
+export declare function changeSpaceMemberRole(config: RoomSocialConfig, spaceId: string, targetUserId: string, role: "admin" | "member"): Promise<RoomSpaceMember>;
+export declare function createRoomSpace(config: RoomSocialConfig, input: {
+    name: string;
+    access?: "open" | "invite";
+}): Promise<Partial<RoomSpaceSummary>>;
+export declare function restoreRoomDoc(config: RoomSocialConfig, docId: string, input?: {
+    note?: string;
+    asAgent?: boolean;
+}): Promise<RoomDoc>;
+export declare function getRoomAttachmentUrl(config: RoomSocialConfig, room: string, key: string): Promise<{
+    url: string;
+    expiresAt: string | null;
+}>;
+export declare function getRoomPublicProfile(config: RoomSocialConfig, userId: string, hints?: {
+    handle?: string;
+    username?: string;
+    displayName?: string;
+}): Promise<RoomPublicProfile>;
+export declare function listRoomReplies(config: RoomSocialConfig, options?: {
+    unreadOnly?: boolean;
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<RoomRepliesResult>;
+export declare function markRoomRepliesRead(config: RoomSocialConfig, options?: {
+    room?: string;
+    before?: string | Date;
+}): Promise<RoomRepliesReadResult>;
+export declare function suggestRooms(config: RoomSocialConfig, request: RoomSuggestionRequest, options?: {
+    signal?: AbortSignal;
+}): Promise<RoomSuggestion[]>;
+export declare function socialRequest<T>(config: RoomSocialConfig, path: string, init?: {
+    method?: string;
+    body?: unknown;
+    signal?: AbortSignal;
+    formData?: FormData;
+}): Promise<T>;
+export declare function cleanUsername(username: string): string;
+export declare function cleanRoomId(room: string): string;
+export declare function mimeFromFilename(filename: string): string;