@recursiv/sdk 0.7.49 → 0.7.51

package/dist/resources/chat.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { PaginatedResponse, SingleResponse, SuccessResponse, Conversation, ConversationDetail, Message, SendMessageInput, SentMessage, DmInput, DmResult, PaginationParams } from '../types.js';
+import type { PaginatedResponse, SingleResponse, SuccessResponse, Conversation, ConversationDetail, Message, SendMessageInput, SentMessage, DmInput, DmResult, PaginationParams, ConversationRequestResult, LeaveConversationResult } from '../types.js';
 export declare class ChatResource {
     private client;
     constructor(client: HttpClient);
@@ -11,7 +11,14 @@ export declare class ChatResource {
     communityConversation(communityId: string): Promise<SingleResponse<Conversation>>;
     /** Get a conversation by ID */
     conversation(id: string): Promise<SingleResponse<ConversationDetail>>;
-    /** List messages in a conversation (newest first) */
+    /**
+     * List messages in a conversation (newest first).
+     *
+     * For scrolling back, pass the previous page's `meta.next_cursor` as
+     * `cursor` rather than growing `offset`: an offset counts from the newest
+     * message and shifts every time one arrives, a cursor does not. The cursor
+     * is bound to this conversation.
+     */
     messages(conversationId: string, params?: PaginationParams): Promise<PaginatedResponse<Message>>;
     /** Send a message to a conversation */
     send(input: SendMessageInput): Promise<SingleResponse<SentMessage>>;
@@ -35,8 +42,31 @@ export declare class ChatResource {
         name: string;
         member_ids: string[];
     }): Promise<SingleResponse<ConversationDetail>>;
-    /** Delete a conversation (only the creator can delete) */
+    /**
+     * Delete a conversation for every member. Allowed when the conversation's
+     * `can_delete` is true: the caller started it, or every other member is an
+     * agent. Otherwise the API answers 403 `not_creator`; use `leave()` where
+     * `can_leave` is true.
+     */
     deleteConversation(id: string): Promise<SuccessResponse>;
+    /**
+     * Remove the caller from a conversation (a group, or a room whose other
+     * members are all agents). The last person to leave removes the room. A
+     * one-on-one with another person cannot be left (409 `dm_leave_unsupported`);
+     * check `can_leave` on the conversation first.
+     *
+     * This changes membership. It is not `realtime.leaveConversation()`, which
+     * only stops listening for live events.
+     */
+    leave(conversationId: string): Promise<SingleResponse<LeaveConversationResult>>;
+    /** Accept a message request (`request_status: 'pending'`). Idempotent; also reverses a decline. */
+    acceptRequest(conversationId: string): Promise<SingleResponse<ConversationRequestResult>>;
+    /**
+     * Decline a message request. The conversation leaves the caller's lists and
+     * stops notifying them; the sender is not told. Only a pending request can
+     * be declined (409 `not_a_request` otherwise). Idempotent.
+     */
+    declineRequest(conversationId: string): Promise<SingleResponse<ConversationRequestResult>>;
     /** React to a message (toggles: adds if not present, removes if already reacted) */
     reactToMessage(messageId: string, input: {
         type: string;

package/dist/resources/chat.js

@@ -15,7 +15,14 @@ export class ChatResource {
     conversation(id) {
         return this.client.get(`/chat/conversations/${id}`);
     }
-    /** List messages in a conversation (newest first) */
+    /**
+     * List messages in a conversation (newest first).
+     *
+     * For scrolling back, pass the previous page's `meta.next_cursor` as
+     * `cursor` rather than growing `offset`: an offset counts from the newest
+     * message and shifts every time one arrives, a cursor does not. The cursor
+     * is bound to this conversation.
+     */
     messages(conversationId, params) {
         return this.client.get(`/chat/conversations/${conversationId}/messages`, params);
     }
@@ -41,10 +48,39 @@ export class ChatResource {
     createGroup(input) {
         return this.client.post('/chat/conversations/group', input);
     }
-    /** Delete a conversation (only the creator can delete) */
+    /**
+     * Delete a conversation for every member. Allowed when the conversation's
+     * `can_delete` is true: the caller started it, or every other member is an
+     * agent. Otherwise the API answers 403 `not_creator`; use `leave()` where
+     * `can_leave` is true.
+     */
     deleteConversation(id) {
         return this.client.delete(`/chat/conversations/${id}`);
     }
+    /**
+     * Remove the caller from a conversation (a group, or a room whose other
+     * members are all agents). The last person to leave removes the room. A
+     * one-on-one with another person cannot be left (409 `dm_leave_unsupported`);
+     * check `can_leave` on the conversation first.
+     *
+     * This changes membership. It is not `realtime.leaveConversation()`, which
+     * only stops listening for live events.
+     */
+    leave(conversationId) {
+        return this.client.post(`/chat/conversations/${conversationId}/leave`);
+    }
+    /** Accept a message request (`request_status: 'pending'`). Idempotent; also reverses a decline. */
+    acceptRequest(conversationId) {
+        return this.client.post(`/chat/conversations/${conversationId}/accept`);
+    }
+    /**
+     * Decline a message request. The conversation leaves the caller's lists and
+     * stops notifying them; the sender is not told. Only a pending request can
+     * be declined (409 `not_a_request` otherwise). Idempotent.
+     */
+    declineRequest(conversationId) {
+        return this.client.post(`/chat/conversations/${conversationId}/decline`);
+    }
     /** React to a message (toggles: adds if not present, removes if already reacted) */
     reactToMessage(messageId, input) {
         return this.client.post(`/chat/messages/${messageId}/react`, input);

package/dist/resources/communities.d.ts

@@ -1,18 +1,30 @@
 import type { HttpClient } from '../client.js';
-import type { Community, CommunityBannedMember, CommunityDetail, CommunityMember, CreateCommunityInput, CreatedCommunity, JoinResult, LeaveResult, ListCommunitiesParams, PaginatedResponse, PaginationParams, SingleResponse } from '../types.js';
+import type { Community, CommunityBannedMember, CommunityCard, CommunityDetail, CommunityMember, CommunityPeopleParams, CreateCommunityInput, CreatedCommunity, JoinResult, LeaveResult, ListCommunitiesParams, PaginatedResponse, PaginationParams, RelatedCommunity, SingleResponse } from '../types.js';
 export declare class CommunitiesResource {
     private client;
     constructor(client: HttpClient);
-    /** List public communities, or only the authenticated caller's memberships. */
+    /**
+     * List public communities, or only the authenticated caller's memberships
+     * (`member: true`). `q` filters either list by name or description.
+     */
     list(params?: ListCommunitiesParams): Promise<PaginatedResponse<Community>>;
-    /** Get a community by ID */
-    get(id: string): Promise<SingleResponse<CommunityDetail>>;
-    /** List members of a community */
-    /** Groups related to this one, ranked by shared members; the caller's own groups are left out. */
+    /**
+     * Search communities by name or description, server-side. Name matches rank
+     * first. Pass `{ member: true }` to search only the caller's own groups.
+     */
+    search(query: string, params?: ListCommunitiesParams): Promise<PaginatedResponse<Community>>;
+    /**
+     * Get a community by ID or slug. A private group the caller is not in comes
+     * back as a `CommunityCard` (`limited: true`) instead of a 404; a hidden one
+     * still 404s.
+     */
+    get(id: string): Promise<SingleResponse<CommunityDetail | CommunityCard>>;
+    /** Public groups related to this one, ranked by shared members; each row carries the caller's `is_member`. */
     related(id: string, params?: {
         limit?: number;
-    }): Promise<PaginatedResponse<Community>>;
-    members(id: string, params?: PaginationParams): Promise<PaginatedResponse<CommunityMember>>;
+    }): Promise<PaginatedResponse<RelatedCommunity>>;
+    /** List members of a community. `q` searches by name or username. */
+    members(id: string, params?: CommunityPeopleParams): Promise<PaginatedResponse<CommunityMember>>;
     /** Create a new community */
     create(input: CreateCommunityInput): Promise<SingleResponse<CreatedCommunity>>;
     /** Join a community */
@@ -28,8 +40,8 @@ export declare class CommunitiesResource {
     delete(id: string): Promise<SingleResponse<{
         deleted: boolean;
     }>>;
-    /** People waiting to join a private group. Moderator or higher. */
-    requests(id: string, params?: PaginationParams): Promise<PaginatedResponse<CommunityMember>>;
+    /** People waiting to join a private group. Moderator or higher. `q` searches by name or username. */
+    requests(id: string, params?: CommunityPeopleParams): Promise<PaginatedResponse<CommunityMember>>;
     /** Active bans an admin can review and lift. Admin or higher. */
     bans(id: string, params?: PaginationParams): Promise<PaginatedResponse<CommunityBannedMember>>;
     /** Let a pending member in. Admin or higher. */

package/dist/resources/communities.js

@@ -3,19 +3,33 @@ export class CommunitiesResource {
     constructor(client) {
         this.client = client;
     }
-    /** List public communities, or only the authenticated caller's memberships. */
+    /**
+     * List public communities, or only the authenticated caller's memberships
+     * (`member: true`). `q` filters either list by name or description.
+     */
     list(params) {
         return this.client.get('/communities', params);
     }
-    /** Get a community by ID */
+    /**
+     * Search communities by name or description, server-side. Name matches rank
+     * first. Pass `{ member: true }` to search only the caller's own groups.
+     */
+    search(query, params) {
+        return this.client.get('/communities', { ...params, q: query });
+    }
+    /**
+     * Get a community by ID or slug. A private group the caller is not in comes
+     * back as a `CommunityCard` (`limited: true`) instead of a 404; a hidden one
+     * still 404s.
+     */
     get(id) {
         return this.client.get(`/communities/${id}`);
     }
-    /** List members of a community */
-    /** Groups related to this one, ranked by shared members; the caller's own groups are left out. */
+    /** Public groups related to this one, ranked by shared members; each row carries the caller's `is_member`. */
     related(id, params) {
         return this.client.get(`/communities/${encodeURIComponent(id)}/related`, params);
     }
+    /** List members of a community. `q` searches by name or username. */
     members(id, params) {
         return this.client.get(`/communities/${id}/members`, params);
     }
@@ -40,7 +54,7 @@ export class CommunitiesResource {
         return this.client.delete(`/communities/${id}`);
     }
     // ── Running the group: the tools an owner, admin or moderator has ────────
-    /** People waiting to join a private group. Moderator or higher. */
+    /** People waiting to join a private group. Moderator or higher. `q` searches by name or username. */
     requests(id, params) {
         return this.client.get(`/communities/${id}/requests`, params);
     }

package/dist/resources/curator.d.ts

@@ -116,6 +116,40 @@ export interface CuratorTodaySource {
     url: string;
     published_at: string | null;
 }
+/** One outlet's own words about a world story, quoted with the outlet. */
+export interface CuratorTodayExcerpt {
+    outlet: string;
+    lane: CuratorOutletLane;
+    title: string;
+    url: string;
+    text: string;
+}
+/** An image a Minds member posted about the story. */
+export interface CuratorTodayLeadImage {
+    url: string;
+    post_id: string;
+    author_name: string | null;
+    author_username: string | null;
+}
+/** A post the topic radar counted under the story. Remote posts carry no link to their own network. */
+export interface CuratorTodayReaction {
+    cluster_id: string;
+    network: 'bluesky' | 'activitypub' | 'nostr' | 'minds';
+    text: string;
+    published_at: string;
+    likes: number;
+    reposts: number;
+    replies: number;
+    /** Minds reactions only: the post to open. */
+    post_id?: string;
+}
+/** The topic radar cluster a world story seeded. */
+export interface CuratorTodayRadar {
+    cluster_id: string;
+    kind: 'breaking' | 'viral' | 'story';
+    sources: Partial<Record<'outlet' | 'hackernews' | 'bluesky' | 'activitypub' | 'nostr' | 'minds', number>>;
+    reactions: CuratorTodayReaction[];
+}
 /** Distinct outlets per lane behind a world story. */
 export interface CuratorTodayLaneMix {
     mainstream: number;
@@ -152,6 +186,14 @@ export interface CuratorTodayStory {
     reply_count: number;
     /** Minds posts in the same shape as `sdk.posts.list()`. May be empty for a world story. */
     posts: Post[];
+    /** World stories only: up to three outlet teasers, one per outlet. */
+    excerpts?: CuratorTodayExcerpt[];
+    /** World stories only: 'outlet' when the dek is an outlet's sentence, 'editor' when the world editor model wrote it. */
+    dek_origin?: 'outlet' | 'editor' | null;
+    /** World stories only: the first image among the story's Minds posts. */
+    lead_image?: CuratorTodayLeadImage | null;
+    /** World stories only: the radar cluster the story seeded, or null. */
+    radar?: CuratorTodayRadar | null;
 }
 export interface CuratorTodayEdition {
     id: string;

package/dist/resources/deployments.d.ts

@@ -47,15 +47,20 @@ export interface PrepareProtocolServersInput {
      * hostnames must be allow-listed. Default `staging`.
      */
     target?: 'staging' | 'production';
+    /**
+     * `activitypub` is the staging GoToSocial and is required for staging. A
+     * production stack is the Bluesky PDS and the Nostr relay only (ActivityPub is
+     * Fedify inside the API), and a production request that names it is refused.
+     */
     hosts: {
         pds: string;
-        activitypub: string;
+        activitypub?: string;
         nostr: string;
     };
-    /** Immutable upstream image references including @sha256 digest. */
+    /** Immutable upstream image references including @sha256 digest; `activitypub` as for `hosts`. */
     images: {
         pds: string;
-        activitypub: string;
+        activitypub?: string;
         nostr: string;
     };
     /** A staging PLC, or https://plc.directory for a production PDS whose operator set HOSTED_PDS_PRODUCTION_PLC=true. */

package/dist/resources/notifications.d.ts

@@ -1,5 +1,35 @@
 import type { HttpClient } from '../client.js';
-import type { RegisterTokenInput, SuccessResponse, PaginationParams } from '../types.js';
+import type { RegisterTokenInput, SuccessResponse, SingleResponse, PaginationParams } from '../types.js';
+/** Who did the thing a notification is about. */
+export interface NotificationActor {
+    id: string;
+    name: string | null;
+    username: string | null;
+    image: string | null;
+    is_ai: boolean | null;
+}
+/**
+ * The post a notification references, as it reads NOW, with the viewer's own
+ * state so inline Upvote and Repost can start in the right position. `null`
+ * when the post is gone or no longer visible to the viewer.
+ */
+export interface NotificationPostPreview {
+    id: string;
+    excerpt: string | null;
+    media_url: string | null;
+    media_type: string | null;
+    reactions_count?: number;
+    score?: number;
+    upvote_count?: number;
+    downvote_count?: number;
+    /** The viewer's own reaction on this post ('upvote', 'downvote', ...), if any. */
+    user_reaction?: string | null;
+    reply_count?: number;
+    unique_commenters?: number;
+    reposts_count?: number;
+    /** Id of the viewer's own repost of this post; delete it to undo the repost. */
+    reposted_by_viewer_id?: string | null;
+}
 export interface Notification {
     id: string;
     target_type: string;
@@ -11,8 +41,22 @@ export interface Notification {
     status: 'unread' | 'read' | 'archived';
     created_at: string;
     read_at: string | null;
+    /** For `post_reaction` rows: which reaction ('upvote', 'downvote', ...). Null otherwise or on older rows. */
+    reaction_type?: string | null;
+    actor?: NotificationActor | null;
+    post_preview?: NotificationPostPreview | null;
 }
 export type NotificationCategory = 'all' | 'social' | 'system';
+export type NotificationScopeParams = {
+    /** Which kind of notification to count. Defaults to `all`. Same meaning as in `list`. */
+    category?: NotificationCategory;
+    /** Scope to a specific organization, as `list` does. */
+    organization_id?: string;
+};
+export interface NotificationUnreadCount {
+    count: number;
+    category: NotificationCategory;
+}
 export interface ListNotificationsParams extends PaginationParams {
     status?: 'unread' | 'read' | 'all';
     cursor?: string;
@@ -22,8 +66,10 @@ export interface ListNotificationsParams extends PaginationParams {
      * Which kind of notification to return. Defaults to `all`.
      *
      * `social` is what a person did to you (follows, replies, reactions,
-     * reposts, mentions, chat, community invites/joins). `system` is everything
-     * operational (agent, task, deploy, billing, security).
+     * reposts, mentions, community invites, joins and join requests, moderation
+     * decisions). `system` is everything operational (agent, task, deploy,
+     * billing, security). Direct messages are in neither: they live in the chat
+     * inbox. `all` (the default) lists every row that has not been archived.
      *
      * Ask for it here rather than filtering the page you get back: the server
      * applies the limit AFTER the category, so a client that filters afterwards
@@ -43,10 +89,33 @@ export declare class NotificationsResource {
     constructor(client: HttpClient);
     /** List notifications for the authenticated user */
     list(params?: ListNotificationsParams): Promise<NotificationListResponse>;
+    /**
+     * Count unread notifications in a category, straight from the database.
+     * Use this for badges: `list` returns at most 50 rows, so a badge built from
+     * a page can only ever say "50+".
+     *
+     * @example
+     * const { data } = await r.notifications.unreadCount({ category: 'social' });
+     * setBadge(data.count);
+     */
+    unreadCount(params?: NotificationScopeParams): Promise<SingleResponse<NotificationUnreadCount>>;
     /** Mark a single notification as read */
     markAsRead(notificationId: string): Promise<SuccessResponse>;
-    /** Mark all notifications as read */
-    markAllAsRead(category?: NotificationCategory): Promise<SuccessResponse>;
+    /**
+     * Dismiss a notification (swipe to remove). It stops appearing in `list`
+     * and stops counting as unread; the row is kept, not deleted. Dismissing an
+     * id that is already dismissed, or not yours, succeeds and changes nothing.
+     */
+    archive(notificationId: string): Promise<SuccessResponse>;
+    /**
+     * Mark every unread notification in a scope as read. Pass the same scope the
+     * list was read with, so a client only clears what it could show.
+     *
+     * @example
+     * await r.notifications.markAllAsRead('social');
+     * await r.notifications.markAllAsRead({ category: 'social', organization_id: orgId });
+     */
+    markAllAsRead(scope?: NotificationCategory | NotificationScopeParams): Promise<SuccessResponse>;
     /** Register a push notification token for the current user */
     registerToken(input: RegisterTokenInput): Promise<SuccessResponse>;
     /** Unregister a push notification token (e.g., on logout) */

package/dist/resources/notifications.js

@@ -7,16 +7,46 @@ export class NotificationsResource {
     list(params) {
         return this.client.get('/notifications', params);
     }
+    /**
+     * Count unread notifications in a category, straight from the database.
+     * Use this for badges: `list` returns at most 50 rows, so a badge built from
+     * a page can only ever say "50+".
+     *
+     * @example
+     * const { data } = await r.notifications.unreadCount({ category: 'social' });
+     * setBadge(data.count);
+     */
+    unreadCount(params) {
+        return this.client.get('/notifications/unread-count', params);
+    }
     /** Mark a single notification as read */
     markAsRead(notificationId) {
-        return this.client.post(`/notifications/${notificationId}/read`);
-    }
-    /** Mark all notifications as read */
-    markAllAsRead(category) {
-        const path = category && category !== 'all'
-            ? `/notifications/read-all?category=${encodeURIComponent(category)}`
-            : '/notifications/read-all';
-        return this.client.post(path);
+        return this.client.post(`/notifications/${encodeURIComponent(notificationId)}/read`);
+    }
+    /**
+     * Dismiss a notification (swipe to remove). It stops appearing in `list`
+     * and stops counting as unread; the row is kept, not deleted. Dismissing an
+     * id that is already dismissed, or not yours, succeeds and changes nothing.
+     */
+    archive(notificationId) {
+        return this.client.post(`/notifications/${encodeURIComponent(notificationId)}/archive`);
+    }
+    /**
+     * Mark every unread notification in a scope as read. Pass the same scope the
+     * list was read with, so a client only clears what it could show.
+     *
+     * @example
+     * await r.notifications.markAllAsRead('social');
+     * await r.notifications.markAllAsRead({ category: 'social', organization_id: orgId });
+     */
+    markAllAsRead(scope) {
+        const params = typeof scope === 'string' ? { category: scope } : scope ?? {};
+        const query = [];
+        if (params.category && params.category !== 'all')
+            query.push(`category=${encodeURIComponent(params.category)}`);
+        if (params.organization_id)
+            query.push(`organization_id=${encodeURIComponent(params.organization_id)}`);
+        return this.client.post(query.length ? `/notifications/read-all?${query.join('&')}` : '/notifications/read-all');
     }
     /** Register a push notification token for the current user */
     registerToken(input) {

package/dist/resources/posts.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { PaginatedResponse, SingleResponse, DeleteResponse, Post, PostDetail, CreatePostInput, CreatedPost, UpdatePostInput, ListPostsParams, SearchPostsParams, ReactionType } from '../types.js';
+import type { PaginatedResponse, SingleResponse, DeleteResponse, Post, PostDetail, CreatePostInput, CreatedPost, UpdatePostInput, ListPostsParams, ListPostRepliesParams, PostRepliesPage, SearchPostsParams, ReactionType } from '../types.js';
 export declare class PostsResource {
     private client;
     constructor(client: HttpClient);
@@ -17,8 +17,10 @@ export declare class PostsResource {
         limit?: number;
         organization_id?: string;
     }): Promise<PaginatedResponse<Post>>;
-    /** Get a single post with replies */
+    /** Get a single post with its newest replies; `replies_next_cursor` is set when the thread continues. */
     get(id: string): Promise<SingleResponse<PostDetail>>;
+    /** One page of a post's replies, newest first. Start from `replies_next_cursor` on `get`, then follow `meta.next_cursor`. */
+    replies(id: string, params?: ListPostRepliesParams): Promise<PostRepliesPage>;
     /** Create a new post */
     create(input: CreatePostInput): Promise<SingleResponse<CreatedPost>>;
     /** Update a post's content or tags */

package/dist/resources/posts.js

@@ -19,10 +19,14 @@ export class PostsResource {
     similar(id, params) {
         return this.client.get(`/posts/${encodeURIComponent(id)}/similar`, params);
     }
-    /** Get a single post with replies */
+    /** Get a single post with its newest replies; `replies_next_cursor` is set when the thread continues. */
     get(id) {
         return this.client.get(`/posts/${id}`);
     }
+    /** One page of a post's replies, newest first. Start from `replies_next_cursor` on `get`, then follow `meta.next_cursor`. */
+    replies(id, params) {
+        return this.client.get(`/posts/${encodeURIComponent(id)}/replies`, params ? { limit: params.limit, cursor: params.cursor } : undefined);
+    }
     /** Create a new post */
     create(input) {
         return this.client.post('/posts', input);

package/dist/resources/profiles.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { PaginatedResponse, SingleResponse, SuccessResponse, Profile, ProfileDetail, ProfileMe, LeaderboardEntry, UpdateProfileInput, SearchProfilesParams } from '../types.js';
+import type { PaginatedResponse, SingleResponse, SuccessResponse, Profile, ProfileDetail, ProfileMe, LeaderboardEntry, UpdateProfileInput, SearchProfilesParams, SearchMentionsParams, MentionCandidate, FollowListProfile, BlockedProfile, MutedProfile, ModerationListParams, ViewerRelationship } from '../types.js';
 export declare class ProfilesResource {
     private client;
     constructor(client: HttpClient);
@@ -16,26 +16,62 @@ export declare class ProfilesResource {
     getByUsername(username: string): Promise<SingleResponse<ProfileDetail>>;
     /** Search users by name or username */
     search(params: SearchProfilesParams): Promise<PaginatedResponse<Profile>>;
+    /**
+     * Accounts to @mention: people and agents on the caller's network, the
+     * caller's follows first. Unlike `search`, this includes agents the app may
+     * discover (an agent answers when mentioned); another member's personal AI
+     * is never offered.
+     */
+    mentions(params: SearchMentionsParams): Promise<PaginatedResponse<MentionCandidate>>;
     /** Update own profile */
     update(input: UpdateProfileInput): Promise<SingleResponse<Profile>>;
     /** Follow a user */
     follow(userId: string): Promise<SuccessResponse>;
     /** Unfollow a user */
     unfollow(userId: string): Promise<SuccessResponse>;
-    /** List a user's followers */
+    /**
+     * List a user's followers. Each row carries the caller's relationship with
+     * it (`is_following`, `follows_you`), so a Follow button needs no second read.
+     */
     followers(userId: string, params?: {
         limit?: number;
         offset?: number;
-    }): Promise<PaginatedResponse<Profile>>;
-    /** List who a user follows */
+    }): Promise<PaginatedResponse<FollowListProfile>>;
+    /** List who a user follows, each row with the caller's relationship with it. */
     following(userId: string, params?: {
         limit?: number;
         offset?: number;
-    }): Promise<PaginatedResponse<Profile>>;
-    /** Check if current user follows another user */
-    isFollowing(userId: string): Promise<SingleResponse<{
-        is_following: boolean;
-    }>>;
+    }): Promise<PaginatedResponse<FollowListProfile>>;
+    /**
+     * The caller's whole follow set as ids, up to 5000 per page (default 1000).
+     * Answers what `isFollowing` answers, for every account at once. Pass
+     * `meta.next_cursor` as `cursor` until it is null.
+     */
+    followingIds(params?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<PaginatedResponse<string>>;
+    /** The follow relationship with another user in both directions (mutual when both are true). */
+    isFollowing(userId: string): Promise<SingleResponse<ViewerRelationship>>;
+    /**
+     * Block a user. A block is a two-way wall: it severs follows in both
+     * directions and hides each side's posts from the other.
+     */
+    block(userId: string): Promise<SuccessResponse>;
+    /** Remove a block. Follows severed by the block are not restored. */
+    unblock(userId: string): Promise<SuccessResponse>;
+    /** The users the caller has blocked, newest first. `search` matches name or username. */
+    blocked(params?: ModerationListParams): Promise<PaginatedResponse<BlockedProfile>>;
+    /**
+     * Mute a user. One-directional: the server stops showing their posts (and
+     * reposts of them) in the caller's feeds and stops notifying the caller about
+     * them. Their profile and direct links stay reachable, and they are not told.
+     */
+    mute(userId: string): Promise<SuccessResponse>;
+    /** Remove a mute. */
+    unmute(userId: string): Promise<SuccessResponse>;
+    /** The users the caller has muted, newest first. `search` matches name or username. */
+    muted(params?: ModerationListParams): Promise<PaginatedResponse<MutedProfile>>;
     /**
      * Channels related to a profile, ranked by co-follow: accounts that the
      * profile's followees also follow. Suggestion list, so the caller's own

package/dist/resources/profiles.js

@@ -23,6 +23,15 @@ export class ProfilesResource {
     search(params) {
         return this.client.get('/profiles/search', params);
     }
+    /**
+     * Accounts to @mention: people and agents on the caller's network, the
+     * caller's follows first. Unlike `search`, this includes agents the app may
+     * discover (an agent answers when mentioned); another member's personal AI
+     * is never offered.
+     */
+    mentions(params) {
+        return this.client.get('/profiles/mentions', params);
+    }
     /** Update own profile */
     update(input) {
         return this.client.put('/profiles/me', input);
@@ -35,18 +44,60 @@ export class ProfilesResource {
     unfollow(userId) {
         return this.client.delete(`/profiles/${userId}/follow`);
     }
-    /** List a user's followers */
+    /**
+     * List a user's followers. Each row carries the caller's relationship with
+     * it (`is_following`, `follows_you`), so a Follow button needs no second read.
+     */
     followers(userId, params) {
         return this.client.get(`/profiles/${userId}/followers`, params);
     }
-    /** List who a user follows */
+    /** List who a user follows, each row with the caller's relationship with it. */
     following(userId, params) {
         return this.client.get(`/profiles/${userId}/following`, params);
     }
-    /** Check if current user follows another user */
+    /**
+     * The caller's whole follow set as ids, up to 5000 per page (default 1000).
+     * Answers what `isFollowing` answers, for every account at once. Pass
+     * `meta.next_cursor` as `cursor` until it is null.
+     */
+    followingIds(params) {
+        return this.client.get('/profiles/me/following/ids', params);
+    }
+    /** The follow relationship with another user in both directions (mutual when both are true). */
     isFollowing(userId) {
         return this.client.get(`/profiles/${userId}/is-following`);
     }
+    /**
+     * Block a user. A block is a two-way wall: it severs follows in both
+     * directions and hides each side's posts from the other.
+     */
+    block(userId) {
+        return this.client.post(`/profiles/${encodeURIComponent(userId)}/block`);
+    }
+    /** Remove a block. Follows severed by the block are not restored. */
+    unblock(userId) {
+        return this.client.delete(`/profiles/${encodeURIComponent(userId)}/block`);
+    }
+    /** The users the caller has blocked, newest first. `search` matches name or username. */
+    blocked(params) {
+        return this.client.get('/profiles/blocked', params);
+    }
+    /**
+     * Mute a user. One-directional: the server stops showing their posts (and
+     * reposts of them) in the caller's feeds and stops notifying the caller about
+     * them. Their profile and direct links stay reachable, and they are not told.
+     */
+    mute(userId) {
+        return this.client.post(`/profiles/${encodeURIComponent(userId)}/mute`);
+    }
+    /** Remove a mute. */
+    unmute(userId) {
+        return this.client.delete(`/profiles/${encodeURIComponent(userId)}/mute`);
+    }
+    /** The users the caller has muted, newest first. `search` matches name or username. */
+    muted(params) {
+        return this.client.get('/profiles/muted', params);
+    }
     /**
      * Channels related to a profile, ranked by co-follow: accounts that the
      * profile's followees also follow. Suggestion list, so the caller's own