@recursiv/sdk 0.7.50 → 0.7.52

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,15 +1,36 @@
 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';
+/** How GET /posts/categories ordered its answer: the member's own order, the app's popularity order, or the fixed order. */
+export type CategoryOrder = 'personal' | 'popular' | 'static';
+/** Why an answer is not `personal`. */
+export type CategoryOrderReason = 'low_signal' | 'deadline' | 'requested' | 'experiment_off';
+export interface CategoryOrderMeta {
+    order: CategoryOrder;
+    /** 16 hex; equal ids mean the same order. */
+    order_id: string;
+    as_of: string;
+    reason?: CategoryOrderReason;
+    /** Whether For You can personalize for this member yet; absent when the member's order was not read. */
+    personalized?: boolean;
+}
 export declare class PostsResource {
     private client;
     constructor(client: HttpClient);
     /** List posts with optional filters */
     list(params?: ListPostsParams): Promise<PaginatedResponse<Post>>;
-    /** Broad categories currently enabled for public posts in this app. */
-    categories(): Promise<SingleResponse<Array<{
+    /**
+     * Broad categories currently enabled for public posts in this app, in the order this member should see
+     * them: their own order once the app serves personal orders, otherwise the app's popularity order. The
+     * order is private to the member. `order` asks for a specific one (default `personal`).
+     */
+    categories(params?: {
+        order?: CategoryOrder;
+    }): Promise<SingleResponse<Array<{
         id: string;
         name: string;
-    }>>>;
+    }>> & {
+        meta?: CategoryOrderMeta;
+    }>;
     /** List posts the authenticated caller has upvoted. */
     liked(params?: Pick<ListPostsParams, 'limit' | 'offset' | 'cursor'>): Promise<PaginatedResponse<Post>>;
     /** Posts similar to this one (embedding neighbours), in the app's scope. */
@@ -17,8 +38,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

@@ -7,9 +7,14 @@ export class PostsResource {
     list(params) {
         return this.client.get('/posts', params);
     }
-    /** Broad categories currently enabled for public posts in this app. */
-    categories() {
-        return this.client.get('/posts/categories');
+    /**
+     * Broad categories currently enabled for public posts in this app, in the order this member should see
+     * them: their own order once the app serves personal orders, otherwise the app's popularity order. The
+     * order is private to the member. `order` asks for a specific one (default `personal`).
+     */
+    categories(params) {
+        // No params, no query: the same request older SDKs make.
+        return params ? this.client.get('/posts/categories', params) : this.client.get('/posts/categories');
     }
     /** List posts the authenticated caller has upvoted. */
     liked(params) {
@@ -19,10 +24,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