@recursiv/sdk 0.7.51 → 0.7.53

package/dist/resources/bookmarks.d.ts

@@ -0,0 +1,172 @@
+import type { HttpClient } from '../client.js';
+import type { PaginatedResponse, PaginationMeta, Post, SingleResponse } from '../types.js';
+/**
+ * What a bookmark is stored under: `post:<post id>`, `social:<sha256>` (the hash the member's source
+ * controls use for that open-network post) or `article:<sha256 of the url>`. Every save, list and keys
+ * call returns it; pass it back to `unsave`.
+ */
+export type BookmarkKey = string;
+export type BookmarkKind = 'post' | 'social' | 'article';
+export type BookmarkProtocol = 'bluesky' | 'activitypub' | 'nostr';
+/** Something to save: a Minds post, an open-network post (with the snapshot to show it by) or an article. */
+export type BookmarkInput = {
+    kind: 'post';
+    post_id: string;
+} | {
+    kind: 'social';
+    protocol: BookmarkProtocol;
+    /** The network's immutable post id: an at:// URI, an ActivityPub object URL, or a Nostr event id. */
+    native_id: string;
+    /** ActivityPub only: the Mastodon-compatible status id that reopens the conversation. Dropped elsewhere. */
+    read_ref?: string;
+    author: {
+        display_name: string;
+        handle: string;
+        /** The author's immutable id (DID, actor URL, pubkey), so the member's blocks and mutes apply. Derived on Bluesky. */
+        native_id?: string;
+    };
+    /** At most 500 characters. */
+    snippet: string;
+} | {
+    kind: 'article';
+    /** An http(s) URL without credentials, at most 2048 characters. */
+    url: string;
+    title: string;
+    outlet: string;
+    /** A World Today story or edition id. */
+    story?: string;
+    /** An https image URL. */
+    image?: string;
+};
+/** A device's saved item for `merge`: an input plus when the device saved it (held to the last five years, never the future). */
+export type BookmarkMergeItem = BookmarkInput & {
+    saved_at?: string;
+};
+export interface SavedBookmark {
+    key: BookmarkKey;
+    kind: BookmarkKind;
+    saved: true;
+    /** False when it was already saved: nothing changed, not even `saved_at`. */
+    created: boolean;
+    saved_at: string | null;
+    /** Posts only: the post stored. A bare repost is saved as its original, so use this id for its saved state. */
+    post_id?: string;
+}
+export interface UnsavedBookmark {
+    key: BookmarkKey;
+    saved: false;
+    /** False when it was not saved; unsaving is idempotent. */
+    removed: boolean;
+}
+/** A saved open-network post or article, as the snapshot taken when it was saved. */
+export type BookmarkItem = {
+    key: BookmarkKey;
+    kind: 'social';
+    saved_at: string;
+    social: {
+        protocol: BookmarkProtocol;
+        native_id: string;
+        read_ref: string | null;
+        author: {
+            display_name: string;
+            handle: string;
+            native_id: string | null;
+        };
+        snippet: string;
+    };
+} | {
+    key: BookmarkKey;
+    kind: 'article';
+    saved_at: string;
+    article: {
+        url: string;
+        title: string;
+        outlet: string;
+        story: string | null;
+        image: string | null;
+    };
+};
+/** One saved key and the identity it stands for, for an app's synchronous saved-state cache. */
+export interface BookmarkKeyRow {
+    key: BookmarkKey;
+    kind: BookmarkKind;
+    saved_at: string;
+    post_id?: string;
+    protocol?: BookmarkProtocol;
+    native_id?: string;
+    url?: string;
+}
+export interface BookmarkMergeResult {
+    saved: number;
+    already: number;
+    skipped: number;
+    over_limit: number;
+    /** What the member has saved in this app now. */
+    total: number;
+    /** The most one member keeps per app. */
+    limit: number;
+    /** One per item, in input order. */
+    results: Array<{
+        key: BookmarkKey | null;
+        status: 'saved' | 'already' | 'skipped' | 'over_limit';
+        reason?: 'invalid' | 'unavailable';
+    }>;
+}
+/** A saved Minds post, hydrated like a feed post, with when the member saved it. */
+export type BookmarkedPost = Post & {
+    bookmarked_at: string | null;
+};
+export interface BookmarksPage<T> extends PaginatedResponse<T> {
+    /** Page on `next_cursor` until it is null: a page can come back short while it skips posts the member can no longer read. */
+    meta: PaginationMeta & {
+        next_cursor: string | null;
+    };
+}
+/** Most items one `merge` call takes. */
+export declare const BOOKMARK_MERGE_MAX_ITEMS = 200;
+/**
+ * `retry: false` answers after one attempt. Use it for the first call that finds out whether synced
+ * bookmarks exist: a 503 `bookmarks_unavailable` is otherwise retried with backoff like any 5xx.
+ */
+export interface BookmarkRequestOptions {
+    retry?: boolean;
+}
+/**
+ * Synced bookmarks: the signed-in member's saved Minds posts, open-network posts and articles in this app,
+ * across every device they sign in on. Private to the member; needs the member's own app key.
+ *
+ * Until the server has synced bookmarks every call rejects with a 503 whose code is `bookmarks_unavailable`:
+ * keep bookmarks on the device then. Keys that are not a member's own app key get 403 `project_binding_required`.
+ */
+export declare class BookmarksResource {
+    private client;
+    constructor(client: HttpClient);
+    /** Save one item. Idempotent: saving what is saved changes nothing. 409 `bookmark_limit` past the member's limit. */
+    save(item: BookmarkInput, options?: BookmarkRequestOptions): Promise<SingleResponse<SavedBookmark>>;
+    /** Unsave by the key a save, list or keys call returned, or by `{ postId }`. Idempotent. */
+    unsave(target: BookmarkKey | {
+        postId: string;
+    }, options?: BookmarkRequestOptions): Promise<SingleResponse<UnsavedBookmark>>;
+    /** Saved Minds posts, newest saved first, hydrated like the feed. Page on `meta.next_cursor`. */
+    posts(params?: {
+        limit?: number;
+        cursor?: string;
+    }, options?: BookmarkRequestOptions): Promise<BookmarksPage<BookmarkedPost>>;
+    /** Saved open-network posts and articles, newest saved first. Page on `meta.next_cursor`. */
+    list(params?: {
+        kind?: 'social' | 'article';
+        limit?: number;
+        cursor?: string;
+    }, options?: BookmarkRequestOptions): Promise<BookmarksPage<BookmarkItem>>;
+    /** Every saved key (hidden posts included), newest saved first, up to 500 a page. For a saved-state cache. */
+    keys(params?: {
+        limit?: number;
+        cursor?: string;
+    }, options?: BookmarkRequestOptions): Promise<BookmarksPage<BookmarkKeyRow>>;
+    /**
+     * Upload a device's saves, e.g. when its member signs in: at most 200 items a call. Idempotent (a second
+     * merge of the same items is a no-op); invalid items and posts the member cannot read are `skipped`, and
+     * items past the member's limit come back `over_limit` (the newest are kept).
+     */
+    merge(items: BookmarkMergeItem[], options?: BookmarkRequestOptions): Promise<SingleResponse<BookmarkMergeResult>>;
+}

package/dist/resources/bookmarks.js

@@ -0,0 +1,44 @@
+/** Most items one `merge` call takes. */
+export const BOOKMARK_MERGE_MAX_ITEMS = 200;
+/**
+ * Synced bookmarks: the signed-in member's saved Minds posts, open-network posts and articles in this app,
+ * across every device they sign in on. Private to the member; needs the member's own app key.
+ *
+ * Until the server has synced bookmarks every call rejects with a 503 whose code is `bookmarks_unavailable`:
+ * keep bookmarks on the device then. Keys that are not a member's own app key get 403 `project_binding_required`.
+ */
+export class BookmarksResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Save one item. Idempotent: saving what is saved changes nothing. 409 `bookmark_limit` past the member's limit. */
+    save(item, options) {
+        return this.client.put('/bookmarks', item, options);
+    }
+    /** Unsave by the key a save, list or keys call returned, or by `{ postId }`. Idempotent. */
+    unsave(target, options) {
+        const key = typeof target === 'string' ? target : `post:${target.postId}`;
+        return this.client.delete(`/bookmarks/${encodeURIComponent(key)}`, options);
+    }
+    /** Saved Minds posts, newest saved first, hydrated like the feed. Page on `meta.next_cursor`. */
+    posts(params, options) {
+        return this.client.get('/posts', { bookmarked: true, ...params }, options);
+    }
+    /** Saved open-network posts and articles, newest saved first. Page on `meta.next_cursor`. */
+    list(params, options) {
+        return this.client.get('/bookmarks', params, options);
+    }
+    /** Every saved key (hidden posts included), newest saved first, up to 500 a page. For a saved-state cache. */
+    keys(params, options) {
+        return this.client.get('/bookmarks/keys', params, options);
+    }
+    /**
+     * Upload a device's saves, e.g. when its member signs in: at most 200 items a call. Idempotent (a second
+     * merge of the same items is a no-op); invalid items and posts the member cannot read are `skipped`, and
+     * items past the member's limit come back `over_limit` (the newest are kept).
+     */
+    merge(items, options) {
+        return this.client.post('/bookmarks/merge', { items }, options);
+    }
+}

package/dist/resources/boosts.d.ts

@@ -44,10 +44,27 @@ export interface BoostBalance {
     /** The 50 most recent balance movements, newest first. */
     ledger: BoostLedgerEntry[];
 }
+/** The boost credit the key's app includes with its paid plans. */
+export interface BoostPlanCredit {
+    /** Micro-USD each paid billing period of a plan adds, by tier key (e.g. `plus`, `pro`). */
+    per_period_micros: Record<string, number>;
+    /** What your current plan on this app adds each paid period; 0 without one. */
+    current_micros: number;
+    /** When your next paid period starts and adds `current_micros`; null when none is due. */
+    next_grant_at: string | null;
+    /**
+     * Plan credit you owe: taken back after your plan dropped or ended inside a period, but already
+     * spent. Your next plan credit repays it before adding anything. 0 when nothing is owed
+     * (absent from older servers).
+     */
+    owed_micros?: number;
+}
 export interface BoostBalanceResponse extends SingleResponse<BoostBalance> {
+    /** `plan_credit` is null when the app's plans include no boost credit (absent from older servers). */
     meta: {
         min_cpm_micros: number;
         topup?: BoostTopupLimits;
+        plan_credit?: BoostPlanCredit | null;
     };
 }
 export interface BoostCampaignResponse extends SingleResponse<BoostCampaign> {
@@ -98,7 +115,10 @@ export declare class BoostsResource {
         limit?: number;
         offset?: number;
     }): Promise<PaginatedResponse<BoostCampaign>>;
-    /** Your balance, recent ledger, the CPM floor, and the top-up limits. */
+    /**
+     * Your balance, recent ledger, the CPM floor, the top-up limits, and the boost credit your
+     * plan on this app adds each paid period (`meta.plan_credit`, a `grant` ledger row per period).
+     */
     balance(): Promise<BoostBalanceResponse>;
     /** Pause one of your active campaigns. */
     pause(campaignId: string): Promise<BoostCampaignResponse>;
@@ -112,6 +132,8 @@ export declare class BoostsResource {
      * Buy boost credit: opens a one-time Stripe Checkout for `amount_cents` (USD) on the app's
      * own Stripe account. The balance is credited once the payment succeeds. Limits are in
      * `balance().meta.topup`. Requires a project-scoped key with `billing:write`.
+     * `return_url` keeps its own query and fragment; `topup=success&session_id=<id>` or
+     * `topup=cancelled` is added to its query (to the fragment's query for a hash route).
      */
     topup(input: {
         amount_cents: number;

package/dist/resources/boosts.js

@@ -20,7 +20,10 @@ export class BoostsResource {
     mine(params) {
         return this.client.get('/boosts/mine', params);
     }
-    /** Your balance, recent ledger, the CPM floor, and the top-up limits. */
+    /**
+     * Your balance, recent ledger, the CPM floor, the top-up limits, and the boost credit your
+     * plan on this app adds each paid period (`meta.plan_credit`, a `grant` ledger row per period).
+     */
     balance() {
         return this.client.get('/boosts/balance');
     }
@@ -44,6 +47,8 @@ export class BoostsResource {
      * Buy boost credit: opens a one-time Stripe Checkout for `amount_cents` (USD) on the app's
      * own Stripe account. The balance is credited once the payment succeeds. Limits are in
      * `balance().meta.topup`. Requires a project-scoped key with `billing:write`.
+     * `return_url` keeps its own query and fragment; `topup=success&session_id=<id>` or
+     * `topup=cancelled` is added to its query (to the fragment's query for a hash route).
      */
     topup(input) {
         return this.client.post('/boosts/topup', input, { retry: false });

package/dist/resources/communities.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { Community, CommunityBannedMember, CommunityCard, CommunityDetail, CommunityMember, CommunityPeopleParams, CreateCommunityInput, CreatedCommunity, JoinResult, LeaveResult, ListCommunitiesParams, PaginatedResponse, PaginationParams, RelatedCommunity, SingleResponse } from '../types.js';
+import type { AnswerJoinRequestsInput, ApprovedJoinRequests, Community, CommunityBannedMember, CommunityCard, CommunityDetail, CommunityMember, CommunityPeopleParams, CreateCommunityInput, CreatedCommunity, DeclinedJoinRequests, JoinResult, LeaveResult, ListCommunitiesParams, PaginatedResponse, PaginationParams, RelatedCommunity, SingleResponse } from '../types.js';
 export declare class CommunitiesResource {
     private client;
     constructor(client: HttpClient);
@@ -25,7 +25,7 @@ export declare class CommunitiesResource {
     }): 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 a new community. Omit slug for a server-generated collision-resistant slug. */
     create(input: CreateCommunityInput): Promise<SingleResponse<CreatedCommunity>>;
     /** Join a community */
     join(id: string): Promise<SingleResponse<JoinResult>>;
@@ -52,6 +52,16 @@ export declare class CommunitiesResource {
     declineMember(id: string, userId: string): Promise<SingleResponse<{
         declined: boolean;
     }>>;
+    /**
+     * Let many pending members in at once. Admin or higher. Pass `{ user_ids }`
+     * (at most 100) or `{ all: true }` for the oldest 100 waiting; call again
+     * while `remaining` is above 0. Named people with no pending request (already
+     * in, already answered, banned, never asked) come back in `skipped`. A ban is
+     * never answered.
+     */
+    approveMembers(id: string, input: AnswerJoinRequestsInput): Promise<SingleResponse<ApprovedJoinRequests>>;
+    /** Turn many pending members away at once, as `approveMembers` lets them in. Admin or higher. */
+    declineMembers(id: string, input: AnswerJoinRequestsInput): Promise<SingleResponse<DeclinedJoinRequests>>;
     /** Remove a member. Moderator or higher, and only members below your role. */
     removeMember(id: string, userId: string): Promise<SingleResponse<{
         removed: boolean;

package/dist/resources/communities.js

@@ -33,7 +33,7 @@ export class CommunitiesResource {
     members(id, params) {
         return this.client.get(`/communities/${id}/members`, params);
     }
-    /** Create a new community */
+    /** Create a new community. Omit slug for a server-generated collision-resistant slug. */
     create(input) {
         return this.client.post('/communities', input);
     }
@@ -70,6 +70,20 @@ export class CommunitiesResource {
     declineMember(id, userId) {
         return this.client.post(`/communities/${id}/members/${userId}/decline`);
     }
+    /**
+     * Let many pending members in at once. Admin or higher. Pass `{ user_ids }`
+     * (at most 100) or `{ all: true }` for the oldest 100 waiting; call again
+     * while `remaining` is above 0. Named people with no pending request (already
+     * in, already answered, banned, never asked) come back in `skipped`. A ban is
+     * never answered.
+     */
+    approveMembers(id, input) {
+        return this.client.post(`/communities/${encodeURIComponent(id)}/requests/approve`, input);
+    }
+    /** Turn many pending members away at once, as `approveMembers` lets them in. Admin or higher. */
+    declineMembers(id, input) {
+        return this.client.post(`/communities/${encodeURIComponent(id)}/requests/decline`, input);
+    }
     /** Remove a member. Moderator or higher, and only members below your role. */
     removeMember(id, userId) {
         return this.client.delete(`/communities/${id}/members/${userId}`);

package/dist/resources/curator.d.ts

@@ -1,5 +1,23 @@
 import type { HttpClient } from '../client.js';
-import type { PaginatedResponse, Post, SingleResponse } from '../types.js';
+import type { DiscoveryLayout, PaginatedResponse, PaginationMeta, Post, SingleResponse } from '../types.js';
+/** Which surface is asking: Home's For You (default) or Discover's For you. */
+export type ForYouSurface = 'home' | 'discover';
+export type ForYouParams = {
+    limit?: number;
+    offset?: number;
+    /** The previous page's `meta.next_cursor`: pages a stored ranking, so posts read meanwhile never shift the next page. */
+    cursor?: string;
+    /** Adds `meta.discovery` (layouts) and the public safety floor; limit <= 25. */
+    discovery?: boolean;
+    /** `discover` ranks for Discover: fresher, beyond the member's follows, with their category order. */
+    surface?: ForYouSurface;
+};
+export interface ForYouMeta extends PaginationMeta {
+    discovery?: DiscoveryLayout;
+    next_cursor?: string;
+    /** Whether the ranker can personalize for this member yet (3 follows or 3 upvoted authors). */
+    personalized?: boolean;
+}
 /** RSS / Atom source. Default — `type` may be omitted for back-compat. */
 export interface CuratorRssSource {
     type?: 'rss';
@@ -250,10 +268,10 @@ export declare class CuratorResource {
      * existing posts for the signed-in user (engagement + recency + social +
      * affinity, no model calls). Returns posts in the same shape as
      * `sdk.posts.list()`, so any feed UI renders it unchanged. Requires a
-     * project-scoped key (the feed is per-app).
+     * project-scoped key (the feed is per-app). Servers that predate `cursor`,
+     * `discovery` and `surface` ignore them.
      */
-    forYou(params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<PaginatedResponse<Post>>;
+    forYou(params?: ForYouParams): Promise<PaginatedResponse<Post> & {
+        meta: ForYouMeta;
+    }>;
 }

package/dist/resources/curator.js

@@ -47,7 +47,8 @@ export class CuratorResource {
      * existing posts for the signed-in user (engagement + recency + social +
      * affinity, no model calls). Returns posts in the same shape as
      * `sdk.posts.list()`, so any feed UI renders it unchanged. Requires a
-     * project-scoped key (the feed is per-app).
+     * project-scoped key (the feed is per-app). Servers that predate `cursor`,
+     * `discovery` and `surface` ignore them.
      */
     forYou(params = {}) {
         return this.client.get('/curator/foryou', params);

package/dist/resources/discovery.d.ts

@@ -1,8 +1,71 @@
+import type { HttpClient } from '../client.js';
 import type { DiscoveryLayout, Post } from '../types.js';
+import type { CuratorResource } from './curator.js';
 import type { DiscoveryLearning } from './discovery-learning.js';
 import type { PostsResource } from './posts.js';
 import type { ProtocolsResource, SocialNetwork, SocialPost, SocialRadar, SocialRadarPosts } from './protocols.js';
 export type DiscoveryRecommendationKind = 'groups' | 'people' | 'tags';
+/** What GET /discover/recommendations suggests: members, groups, tags, open-network accounts or World Today stories. */
+export type EntityKind = 'member' | 'group' | 'tag' | 'network_account' | 'story';
+/**
+ * One suggestion. `key` is the entity's id (a uuid), or `<protocol>:<native id>` for an open-network account.
+ * The public display fields depend on the kind: members carry id, username, name, image, bio and
+ * follower_count; groups id, name, slug, image, description and member_count; tags id, name and slug;
+ * open-network accounts protocol, actor, handle, display_name and avatar_url (never a link out); stories id,
+ * headline, kicker, story_kind and edition_date.
+ */
+export interface EntityRecommendation {
+    kind: EntityKind;
+    key: string;
+    /** active: posted in the last 7 days or 4+ times in 30 (for groups, 3+ distinct posters in 30 days); warm: activity in 90 days. */
+    tier: 'active' | 'warm';
+    score: number;
+    /** The entity's share of the requested category, or null for category=all. */
+    share: number | null;
+    last_active_at: string | null;
+    posts_30d: number;
+    /** Distinct posters in 30 days (groups and tags), otherwise null. */
+    authors_30d: number | null;
+    /** Up to three browse categories, largest share first. */
+    categories: Array<{
+        category: string;
+        share: number;
+    }>;
+    [display: string]: unknown;
+}
+export interface EntityRecommendationsParams {
+    kind: EntityKind;
+    /** 'all' (default) or a browse category id. */
+    category?: string;
+    /** 1..50, default 10. */
+    limit?: number;
+    /** A per-session token ([A-Za-z0-9_-], up to 64): the same token keeps the order stable; a new one rotates near-ties. */
+    session?: string;
+    /** Up to 50 keys of the kind to leave out, e.g. open-network accounts the member follows through a connected account. */
+    exclude?: string[];
+}
+export interface EntityRecommendationsResponse {
+    data: EntityRecommendation[];
+    meta: {
+        kind: EntityKind;
+        category: string;
+        as_of: string | null;
+        /** Why the list is empty: serving is off, the key's app is not the one signals are built for, no snapshot yet, the viewer's follows could not be checked, or the key has no app. */
+        reason?: 'disabled' | 'other_app' | 'no_snapshot' | 'viewer_facts_unavailable' | 'no_app';
+        /** Suggestions left out because they are resting for this viewer, and because the viewer follows, joined, blocked or muted them. */
+        resting: number;
+        excluded: number;
+        /** True when the member's own category order lifted suggestions in their first categories. */
+        personalized: boolean;
+    };
+}
+export interface EntityImpressionsInput {
+    kind: EntityKind;
+    /** 1..50 keys of the kind. */
+    keys: string[];
+    /** 'shown' when a suggestion was on screen; 'engaged' on a tap, follow or join. Three showings without a tap rest a suggestion for fourteen days; engaging clears it. */
+    event: 'shown' | 'engaged';
+}
 export interface DiscoveryGroupCandidate {
     id: string;
     name: string;
@@ -161,7 +224,7 @@ export interface DiscoveryFeedPage {
 export declare const GALLERY_MAX_ITEMS = 12;
 /** Per-viewer feed session. Create a new session when user, app, category or
  * source changes. All reads retain existing server authorization/moderation.
- * At most four requests per page; providers fail independently. */
+ * At most four sources per page (a topics network's read walks up to TOPIC_WALK topic pages); providers fail independently. */
 export declare class DiscoveryFeedSession {
     private posts;
     private protocols;
@@ -186,6 +249,15 @@ export declare class DiscoveryFeedSession {
     retryFailed(): void;
     next(): Promise<DiscoveryFeedPage>;
     private read;
+    /**
+     * One read of a topics network: the next topic page that carries posts. A topic the provider no
+     * longer lists (Bluesky rotates its trends between the catalog read and the walk through it) is
+     * that topic's end, not the network's failure; a topic page with nothing in the category is
+     * walked past too, and its continuation kept, so the page reaches a topic that carries posts
+     * instead of spending a round on each empty one. Bounded by TOPIC_WALK reads and TOPIC_WALK_MS;
+     * a walk that stops short has moved the stream on, and the next read continues from there.
+     */
+    private walkTopics;
     private readPage;
     /** Page 0: the top breaking cluster, else the top cluster. Every second later page: the next unused story or viral cluster. */
     private radarCluster;
@@ -201,7 +273,37 @@ export declare class DiscoveryFeedSession {
 export declare class DiscoveryResource {
     private posts;
     private protocols;
-    constructor(posts: PostsResource, protocols: ProtocolsResource);
+    private curator?;
+    private http?;
+    constructor(posts: PostsResource, protocols: ProtocolsResource, curator?: Pick<CuratorResource, "forYou"> | undefined, http?: Pick<HttpClient, "get" | "post"> | undefined);
+    /**
+     * Suggestions for the signed-in viewer from the app's one recommender: active or warm members, groups
+     * with several posters, tags used by several people, open-network accounts or stories, overall or in one
+     * browse category. What the viewer follows, joined, blocked or muted is left out, and so is anything
+     * resting for them. Call `recordImpressions` when suggestions are actually on screen and when one is tapped.
+     */
+    recommendations(params: EntityRecommendationsParams, options?: {
+        retry?: boolean;
+    }): Promise<EntityRecommendationsResponse>;
+    /** Records that suggestions were shown (at most once per half hour counts) or engaged with. */
+    recordImpressions(input: EntityImpressionsInput): Promise<{
+        data: {
+            recorded: number;
+            reason?: 'disabled' | 'other_app' | 'unavailable' | 'no_app';
+        };
+    }>;
+    /**
+     * A For you Discover feed: the member's For You ranking (asked for Discover's surface, with layouts and a
+     * snapshot cursor) in a session's Minds slot. With a category, the session also reads open-network posts
+     * from that category (the member's top one); without, it is Minds only. Never the radar. The page-0
+     * arrangement and when to use which are the app's choice.
+     */
+    createPersonalFeed(options: {
+        networks: SocialNetwork[];
+        learning?: DiscoveryLearning;
+        recommend?: DiscoveryRecommendationSources;
+        category?: string;
+    }): DiscoveryFeedSession;
     createFeed(options: {
         networks: SocialNetwork[];
         category?: string;