@recursiv/sdk 0.7.51 → 0.7.53

package/dist/resources/protocols.d.ts

@@ -305,6 +305,8 @@ export interface SocialSourceControlDisplay {
     avatarUrl: string | null;
     /** A hidden post's text, at most 140 characters; null for accounts, deleted posts, and moderated posts or authors. */
     excerpt: string | null;
+    /** A hidden ActivityPub post's public reader id, for the conversation read; absent for accounts, other networks and posts observed without one. */
+    readRef?: string;
     observedAt: string;
 }
 export interface SocialSourceControl {
@@ -641,6 +643,8 @@ export interface NativeReplyBatch {
             authorHandle: string;
             text: string;
             textTruncated?: boolean;
+            /** An ActivityPub parent's public reader id, when the reply was prepared with one: pass it to the conversation read. */
+            readRef?: string;
         };
         text: string;
         wireText: string;
@@ -742,7 +746,7 @@ export interface NativeDelegatedReplyHistoryItem {
     createdAt: string;
     text: string;
     textTruncated: boolean;
-    source: Pick<NativeReplyBatch['deliveries'][number]['parent'], 'protocol' | 'nativeId' | 'sourceUrl'>;
+    source: Pick<NativeReplyBatch['deliveries'][number]['parent'], 'protocol' | 'nativeId' | 'sourceUrl' | 'readRef'>;
     deliveries: Array<Pick<NativeReplyBatch['deliveries'][number], 'id' | 'protocol' | 'kind' | 'state' | 'attemptedAt' | 'account' | 'recoverable' | 'replacedBy'> & {
         removalReceipt: NativeReplyRemovalReceipt | null;
     }>;
@@ -751,10 +755,12 @@ export interface NativeNostrReplyResult {
     id: string;
     createdAt: string;
     text: string;
+    /** `readRef`: a linked ActivityPub source's public reader id, for the conversation read (replies saved before it existed have none). */
     source: {
         protocol: SocialSourceRef['protocol'];
         nativeId: string;
         sourceUrl: string;
+        readRef?: string;
     };
     identityId: string;
     pubkey: string;
@@ -962,6 +968,12 @@ export interface SocialPost {
     replyCount: number | null;
     likeCount: number | null;
     repostCount: number | null;
+    /**
+     * When the counts were read from the source network. Present only on a post a category feed served
+     * from the open-network index, whose copy can be older than the page (the server refreshes counts
+     * older than 15 minutes when the provider answers in time). Absent: the counts are from this read.
+     */
+    countsObservedAt?: string;
     /** Pixel dimensions when the source declares them (Bluesky aspect ratio, Mastodon attachment meta), so a card can take the clip's shape before it loads. */
     media: Array<{
         type: 'image' | 'video';
@@ -1165,17 +1177,46 @@ export interface SocialRadarPosts {
     builtAt: string | null;
     items: SocialPost[];
 }
+/** A story that has left the radar, as the radar's story archive keeps it (up to 30 days after it was last on the radar). */
+export interface SocialRadarStoryArchive {
+    /** The story as the radar last published it. Articles keep their headline and link; a post is a member by reference only (no `title`). */
+    cluster: Pick<SocialRadarCluster, 'id' | 'label' | 'kind' | 'seed' | 'theme' | 'sources' | 'laneMix'> & {
+        members: Array<Pick<SocialRadarMember, 'kind' | 'key' | 'url' | 'publishedAt' | 'outlet'> & {
+            title?: string;
+        }>;
+    };
+    /** Its open-network posts the app's source index still holds and its source controls and safety floor admit today, in member order. */
+    items: SocialPost[];
+    /** A World Today story's dek: an outlet's own sentence, or the editor model's. */
+    summary: {
+        text: string;
+        origin: 'outlet' | 'editor';
+    } | null;
+    /** The first and the last radar build that published it. */
+    firstSeenAt: string;
+    lastSeenAt: string;
+    /** The index holds none of its open-network posts any more (retention or deletion), so none are listed. */
+    postsExpired: boolean;
+}
 /**
  * One radar story by id, with its social member posts.
- * `live`: on the current radar (`cluster` and `items` present). `aged_out`: on one of the last six
- * radars but not this one. `unknown`: not seen in that window (never existed, or aged out long ago).
+ * `live`: on the current radar (`cluster` and `items` present). `aged_out`: not on this radar, but
+ * held by the story archive (`archive`, and the live story it continues as in `successor`) or seen on
+ * one of the last six radars (`archive` null). `unknown`: in neither (never existed, or left longer ago
+ * than the archive keeps stories). A server without the story archive leaves `archive` and `successor` out.
  */
 export interface SocialRadarStory {
     id: string;
     builtAt: string | null;
     status: 'live' | 'aged_out' | 'unknown';
     cluster: SocialRadarCluster | null;
+    /** The live story's posts; empty otherwise (an archived story's are in `archive.items`). */
     items: SocialPost[];
+    archive?: SocialRadarStoryArchive | null;
+    successor?: {
+        id: string;
+        label: string;
+    } | null;
 }
 /** Read options for callers that hold their own deadline, such as a discovery page. */
 export interface SocialReadOptions {
@@ -1255,7 +1296,10 @@ export declare class ProtocolsResource {
         limit?: number;
         cursor?: string;
     }): Promise<SingleResponse<SocialAuthorFeed>>;
-    /** Public, app-moderated discovery without account authority. Enrichment uses cached judgments only. */
+    /**
+     * Public, app-moderated discovery without account authority. Enrichment uses cached judgments only.
+     * Every page, previews included, gets the safety floor; `discovery` only asks for a layout.
+     */
     getSharedTrends(projectId: string, params: {
         protocol: string;
         limit?: number;
@@ -1264,7 +1308,7 @@ export declare class ProtocolsResource {
         category?: string;
         discovery?: boolean;
     }): Promise<SingleResponse<SocialTrends>>;
-    /** Open a provider-listed topic through the same public-only app boundary. */
+    /** Open a provider-listed topic through the same public-only app boundary, with the same safety floor. */
     getSharedTrendFeed(projectId: string, params: {
         protocol: string;
         topic: string;
@@ -1314,7 +1358,10 @@ export declare class ProtocolsResource {
         post: string;
         readRef?: string;
     }): Promise<SingleResponse<SocialConversation>>;
-    /** Current provider-ranked topics or posts, with explicit source and coverage. Does not ingest content. */
+    /**
+     * Current provider-ranked topics or posts, with explicit source and coverage. Does not ingest content.
+     * Every page, previews included, gets the safety floor; `discovery` only asks for a layout.
+     */
     getPublicTrends(params: {
         protocol: string;
         limit?: number;
@@ -1323,7 +1370,7 @@ export declare class ProtocolsResource {
         category?: string;
         discovery?: boolean;
     }, options?: SocialReadOptions): Promise<SingleResponse<SocialTrends>>;
-    /** Open a topic currently listed by the provider. Use its nativeId as topic and preserve the opaque cursor. */
+    /** Open a topic currently listed by the provider. Use its nativeId as topic and preserve the opaque cursor. Screened like `getPublicTrends`. */
     getPublicTrendFeed(params: {
         protocol: string;
         topic: string;

package/dist/resources/protocols.js

@@ -89,12 +89,15 @@ export class ProtocolsResource {
         return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/author-feed`, { protocol: params.protocol, actor: params.actor,
             limit: params.limit, cursor: params.cursor });
     }
-    /** Public, app-moderated discovery without account authority. Enrichment uses cached judgments only. */
+    /**
+     * Public, app-moderated discovery without account authority. Enrichment uses cached judgments only.
+     * Every page, previews included, gets the safety floor; `discovery` only asks for a layout.
+     */
     getSharedTrends(projectId, params) {
         return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/trends`, { protocol: params.protocol, limit: params.limit, cursor: params.cursor,
             includePreviews: params.includePreviews, category: params.category, discovery: params.discovery });
     }
-    /** Open a provider-listed topic through the same public-only app boundary. */
+    /** Open a provider-listed topic through the same public-only app boundary, with the same safety floor. */
     getSharedTrendFeed(projectId, params) {
         return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/trend-feed`, { protocol: params.protocol, topic: params.topic,
             limit: params.limit, cursor: params.cursor, category: params.category, discovery: params.discovery });
@@ -148,14 +151,17 @@ export class ProtocolsResource {
     getPublicConversation(params) {
         return this.client.get('/protocols/social/conversation', { protocol: params.protocol, post: params.post, readRef: params.readRef });
     }
-    /** Current provider-ranked topics or posts, with explicit source and coverage. Does not ingest content. */
+    /**
+     * Current provider-ranked topics or posts, with explicit source and coverage. Does not ingest content.
+     * Every page, previews included, gets the safety floor; `discovery` only asks for a layout.
+     */
     getPublicTrends(params, options) {
         return this.client.get('/protocols/social/trends', { protocol: params.protocol, limit: params.limit, cursor: params.cursor,
             ...(params.includePreviews !== undefined ? { includePreviews: params.includePreviews } : {}),
             ...(params.category !== undefined ? { category: params.category } : {}),
             ...(params.discovery !== undefined ? { discovery: params.discovery } : {}) }, ...readOptions(options));
     }
-    /** Open a topic currently listed by the provider. Use its nativeId as topic and preserve the opaque cursor. */
+    /** Open a topic currently listed by the provider. Use its nativeId as topic and preserve the opaque cursor. Screened like `getPublicTrends`. */
     getPublicTrendFeed(params, options) {
         return this.client.get('/protocols/social/trend-feed', { protocol: params.protocol, topic: params.topic, limit: params.limit, cursor: params.cursor,
             ...(params.category !== undefined ? { category: params.category } : {}),

package/dist/resources/search.d.ts

@@ -0,0 +1,159 @@
+import type { HttpClient } from '../client.js';
+import type { Post } from '../types.js';
+import type { SocialPost } from './protocols.js';
+/** The sections a blended search can answer, in no particular order (see `SearchAnswer.order`). */
+export declare const SEARCH_SECTIONS: readonly ["top_posts", "latest_posts", "open_network", "people", "groups", "topics", "stories", "related", "trending"];
+export type SearchSection = (typeof SEARCH_SECTIONS)[number];
+/** Why a section is absent: out of time, the server was busy, not available for this app, not allowed for this key, or it failed. */
+export type SearchOmitReason = 'timeout' | 'saturated' | 'unavailable' | 'scope' | 'error';
+export interface SearchParams {
+    q: string;
+    /** Items per section, 1-20 (default 6). */
+    limit?: number;
+    /** Only these sections (default: all). */
+    sections?: readonly SearchSection[];
+    /** For organization-bound keys, as on `posts.search`. */
+    organization_id?: string;
+}
+export interface SearchPerson {
+    id: string;
+    name: string | null;
+    username: string | null;
+    image: string | null;
+    is_ai: boolean;
+    /** The query is this account's handle. */
+    exact: boolean;
+    /** The account's public life, what the ranking read: match x ln(1 + followers + min(posts, 100)). */
+    followers_count: number;
+    posts_count: number;
+    /** Nobody follows it and it never posted: listed after every account with a public life, so a client can fold these under "more handles". */
+    empty: boolean;
+    /** An account the operator vouches for: draw the verified badge. */
+    verified: boolean;
+    /** Membership badges, as every embedded author carries them. */
+    plus: boolean;
+    pro: boolean;
+    founder: boolean;
+}
+export interface SearchGroup {
+    id: string;
+    name: string;
+    slug: string;
+    image: string | null;
+    member_count: number;
+    post_count: number;
+    is_member: boolean;
+}
+export type SearchTopic = {
+    kind: 'tag';
+    id: string;
+    name: string;
+    slug: string;
+} | {
+    kind: 'category';
+    id: string;
+    name: string;
+};
+export interface SearchStory {
+    /** Radar cluster id: open it with `protocols` radar story reads. */
+    id: string;
+    label: string;
+    kind: 'breaking' | 'viral' | 'story';
+    theme: string | null;
+    newest_at: string;
+    sources: Partial<Record<'outlet' | 'hackernews' | 'bluesky' | 'activitypub' | 'nostr' | 'minds', number>>;
+    lead: {
+        type: 'image' | 'video';
+        url: string;
+        poster?: string;
+        width?: number;
+        height?: number;
+    } | null;
+    /** Where the words were found: the story's headline, or only one of its members'. */
+    matched: 'label' | 'member';
+}
+export interface SearchRelated {
+    categories: Array<{
+        id: string;
+        name: string;
+        count: number;
+    }>;
+    tags: Array<{
+        id: string;
+        name: string;
+        slug: string;
+        count: number;
+    }>;
+}
+/** One blended search answer. Only answered sections are present; an answered section may be empty. */
+export interface SearchAnswer {
+    query: string;
+    sections: {
+        /** Relevance x recency x engagement, through the promotion safety floor. `has_more`: page further with `posts.search`. */
+        top_posts?: {
+            items: Post[];
+            has_more: boolean;
+        };
+        /** Newest first, never repeating a top post. `partial`: these are the newest of what was read in time. */
+        latest_posts?: {
+            items: Post[];
+            partial: boolean;
+        };
+        open_network?: {
+            items: SocialPost[];
+            withheld: number;
+        };
+        people?: {
+            items: SearchPerson[];
+        };
+        groups?: {
+            items: SearchGroup[];
+        };
+        topics?: {
+            items: SearchTopic[];
+        };
+        stories?: {
+            items: SearchStory[];
+        };
+        /** Categories and topics around the matches. */
+        related?: SearchRelated;
+        /** Present when the answer is thin or old: what is moving in the nearest category. */
+        trending?: {
+            category: {
+                id: string;
+                name: string;
+            } | null;
+            items: Post[];
+        };
+    };
+    /** Answered, non-empty sections in the order to render them. */
+    order: SearchSection[];
+    /** Sections the server left out, and why; the rest of the answer stands. */
+    omitted: Array<{
+        section: SearchSection;
+        reason: SearchOmitReason;
+    }>;
+    /** Fewer than five matches across Minds and the open networks. */
+    few_results: boolean;
+}
+export interface SearchResponse {
+    data: SearchAnswer;
+    meta: {
+        limit: number;
+        elapsed_ms: number | null;
+    };
+}
+export declare class SearchResource {
+    private client;
+    constructor(client: HttpClient);
+    /**
+     * Blended search (GET /search): the best and newest posts, open-network posts, people, groups, topics,
+     * news stories, and, so a search never dead-ends, related categories and trending posts. Each section
+     * has its own time budget; one that runs out is listed in `omitted` instead of failing the answer.
+     * Needs `posts:read`. People need `users:read`, groups `communities:read`; open network and stories need
+     * `users:read` and the caller's own app key bound to its network, trending that app key. A section the
+     * key cannot have is listed in `omitted` with reason `scope` or `unavailable`.
+     * Servers before this endpoint answer 404: fall back to `posts.search`.
+     */
+    query(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/resources/search.js

@@ -0,0 +1,21 @@
+/** The sections a blended search can answer, in no particular order (see `SearchAnswer.order`). */
+export const SEARCH_SECTIONS = ['top_posts', 'latest_posts', 'open_network', 'people', 'groups', 'topics', 'stories', 'related', 'trending'];
+export class SearchResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Blended search (GET /search): the best and newest posts, open-network posts, people, groups, topics,
+     * news stories, and, so a search never dead-ends, related categories and trending posts. Each section
+     * has its own time budget; one that runs out is listed in `omitted` instead of failing the answer.
+     * Needs `posts:read`. People need `users:read`, groups `communities:read`; open network and stories need
+     * `users:read` and the caller's own app key bound to its network, trending that app key. A section the
+     * key cannot have is listed in `omitted` with reason `scope` or `unavailable`.
+     * Servers before this endpoint answer 404: fall back to `posts.search`.
+     */
+    query(params) {
+        const { sections, ...rest } = params;
+        return this.client.get('/search', { ...rest, ...(sections && sections.length > 0 ? { sections: sections.join(',') } : {}) });
+    }
+}

package/dist/types.d.ts

@@ -123,9 +123,31 @@ export interface MediaItem {
     id: string;
     url: string;
     type: string;
+    /**
+     * Set on a legacy Minds video whose file is known to be gone (the server probes it): leave it out
+     * of Watch and clip queues and show the poster instead. Absent when the file plays or is unjudged.
+     */
+    unplayable?: boolean;
+}
+/** The group a post is in, as every post payload carries it. */
+export interface PostCommunity {
+    id: string;
+    name: string;
+    slug: string;
+    /**
+     * A post in a group that is not public is for the group's members, and is
+     * never boosted: offer Boost only when this is 'public'.
+     */
+    privacy: 'public' | 'private' | 'hidden';
 }
 export interface Post {
+    /** Stored replies a reader can open. */
     reply_count?: number;
+    /**
+     * The comment count a legacy import brought with the post (minds.com). None of those comments are
+     * stored as replies, so it is not in `reply_count`.
+     */
+    reply_count_external?: number;
     id: string;
     /** Original Minds numeric GUID when this row came from the legacy import. */
     legacy_guid?: string | null;
@@ -133,6 +155,8 @@ export interface Post {
     content_format: 'plain' | 'markdown';
     author: UserSummary;
     community_id: string | null;
+    /** The group the post is in (null when it is in none). */
+    community?: PostCommunity | null;
     organization_id: string | null;
     reply_to_id?: string | null;
     /** Present when this post is an X-style repost — the original post is nested. */
@@ -154,10 +178,25 @@ export interface RepostedPost {
     content_format: 'plain' | 'markdown';
     author: UserSummary | null;
     community_id: string | null;
+    /** The group the original is in (null when it is in none): it decides what the repost card offers. */
+    community?: PostCommunity | null;
     organization_id: string | null;
     tags: Tag[];
     reactions_count: number;
     score: number;
+    /** The original's engagement, as the REST payload sends it for the original itself. */
+    upvote_count?: number;
+    downvote_count?: number;
+    /** The viewer's own reaction on the original ('upvote', 'downvote', ...), if any. */
+    user_reaction?: string | null;
+    /** Stored replies a reader can open. */
+    reply_count?: number;
+    /** A legacy import's comment count; none of those comments are stored as replies, so it is not in `reply_count`. */
+    reply_count_external?: number;
+    unique_commenters?: number;
+    reposts_count?: number;
+    /** Id of the viewer's own repost of the original; delete it to undo the repost. */
+    reposted_by_viewer_id?: string | null;
     media: MediaItem[];
     created_at: string;
 }
@@ -178,6 +217,8 @@ export interface PostReply {
     user_reaction?: string | null;
     /** This reply's own reply count, so its sub-thread can be opened. */
     reply_count?: number;
+    /** A legacy import's comment count for this reply; not stored as replies, so not in `reply_count`. */
+    reply_count_external?: number;
     created_at: string;
 }
 export interface ListPostRepliesParams {
@@ -226,7 +267,11 @@ export interface UpdatePostInput {
 }
 export type ReactionType = 'like' | 'heart' | 'fire' | 'laugh' | 'sad' | 'angry' | 'upvote' | 'downvote';
 export interface ListPostsParams extends PaginationParams {
-    /** Public-only feed with a bounded Jev presentation hint. Limit <=25. */
+    /**
+     * Public-only feed with a bounded Jev presentation hint. Limit <=25.
+     * The safety floor does not depend on it: a category page and every app-wide
+     * `sort: 'hot'` or `'score'` read are screened with or without a layout.
+     */
     discovery?: boolean;
     /** Public-only broad category. Requires an enabled app experiment; limit <=25. */
     category?: string;
@@ -239,6 +284,11 @@ export interface ListPostsParams extends PaginationParams {
     audience_user_id?: 'me' | string;
     /** Return only posts the authenticated caller has upvoted. */
     liked?: boolean;
+    /**
+     * Return only the caller's saved posts, newest saved first, each with `bookmarked_at`. Takes only `limit`
+     * (at most 50) and `cursor`; see `posts.bookmarked` / `bookmarks.posts`.
+     */
+    bookmarked?: boolean;
 }
 export interface SearchPostsParams extends PaginationParams {
     q: string;
@@ -247,6 +297,42 @@ export interface SearchPostsParams extends PaginationParams {
     sort?: 'relevance' | 'new';
     since?: string;
     until?: string;
+    /**
+     * The `meta.next_cursor` of the previous page. Later relevance pages are slices of the ranking the
+     * first page kept (ten minutes), so nothing is skipped or repeated while it lives; after that the page
+     * continues past the last post's score boundary. Newest-first pages continue by (created_at, id). A
+     * cursor is bound to its search and sort: another's is refused (400 `invalid_cursor`). Without one,
+     * `offset` counts.
+     */
+    cursor?: string;
+}
+/** A way on from the end of a search: newest first, the open networks, or a topic the matches share. */
+export type SearchFallOverLane = {
+    kind: 'new';
+} | {
+    kind: 'open_network';
+} | {
+    kind: 'tag';
+    id: string;
+    name: string;
+    slug: string;
+};
+/** One page of `posts.search`. */
+export interface SearchPostsResponse extends PaginatedResponse<Post> {
+    /**
+     * On the first relevance page: up to three of the newest matches that are not on the page, newest
+     * first, one per author, for a "Latest" strip above the best matches. Absent when there are none, and on later pages.
+     */
+    latest?: Post[];
+    /**
+     * On the last page (`meta.has_more` false): what exists past the end of this search, so a client
+     * can offer a way on instead of a wall. `new` when newest-first goes deeper than the ranking did;
+     * `open_network` when the caller's app can search the open networks; `tag` for the topic the
+     * page's posts share most. May be empty.
+     */
+    fall_over?: {
+        lanes: SearchFallOverLane[];
+    };
 }
 export type QueryParams = Record<string, unknown>;
 export interface CommunityCreator {
@@ -269,6 +355,8 @@ export interface Community {
     post_count?: number;
     /** Whether the caller is an accepted member. Returned by `list` and `search`. */
     is_member?: boolean;
+    /** The caller's role in the group, or null outside it. Returned by `list` and the detail read; a group's creator reads as its owner. */
+    viewer_role?: 'owner' | 'admin' | 'moderator' | 'member' | null;
     created_at: string;
 }
 /** Filters accepted by the communities directory. */
@@ -277,14 +365,36 @@ export interface ListCommunitiesParams extends PaginationParams {
     member?: boolean;
     /** Restrict personal keys to one organization. Project-bound keys are already scoped. */
     organization_id?: string;
-    /** Server-side directory ordering. With `q`, name matches come first and this breaks ties. */
-    sort?: 'members' | 'active' | 'newest';
+    /**
+     * Server-side ordering. With `q`, name matches come first and this breaks ties. `joined` (with
+     * `member: true`) lists the caller's groups by when they joined, newest first.
+     */
+    sort?: 'members' | 'active' | 'newest' | 'joined';
     /**
      * Case-insensitive text search over name and description, up to 200
      * characters. With `member: true` it searches only the caller's own groups.
      */
     q?: string;
 }
+/** Which join requests to answer at once: named people (at most 100), or the oldest 100 waiting. */
+export type AnswerJoinRequestsInput = {
+    user_ids: string[];
+} | {
+    all: true;
+};
+/** What a many-at-once answer did: how many it answered, who it skipped, and how many still wait. */
+export interface ApprovedJoinRequests {
+    approved: number;
+    /** Named people with no pending request here: already in, already answered, banned, or never asked. */
+    skipped: string[];
+    /** Pending requests left in the group (bans not counted). */
+    remaining: number;
+}
+export interface DeclinedJoinRequests {
+    declined: number;
+    skipped: string[];
+    remaining: number;
+}
 /** The caller's own membership row in a group, if any. */
 export type CommunityMembershipStatus = 'accepted' | 'pending' | 'invited' | 'banned';
 export interface CommunityDetail extends Community {
@@ -366,7 +476,8 @@ export interface CommunityBannedMember {
 }
 export interface CreateCommunityInput {
     name: string;
-    slug: string;
+    /** Optional vanity slug. Omit it for a server-generated collision-resistant default. */
+    slug?: string;
     description?: string;
     privacy?: 'public' | 'private' | 'hidden';
 }
@@ -719,7 +830,8 @@ export interface AgentDetail extends Agent {
 }
 export interface CreateAgentInput {
     name: string;
-    username: string;
+    /** Optional public handle. Omit it for a server-generated collision-resistant default. */
+    username?: string;
     bio?: string;
     model?: string;
     system_prompt?: string;
@@ -856,6 +968,14 @@ export interface Profile {
 /** A row of a followers/following list: the profile plus the caller's relationship with it. */
 export interface FollowListProfile extends Profile, ViewerRelationship {
 }
+/** Paging and search for a follower or following list (profiles.followers / following). */
+export interface FollowListParams {
+    limit?: number;
+    offset?: number;
+    /** Name or handle, matched anywhere in either (at most 200 characters); a blank term lists everyone. */
+    search?: string;
+    [key: string]: unknown;
+}
 /** An account the caller blocked. */
 export interface BlockedProfile extends Profile {
     blocked_at: string;
@@ -895,10 +1015,24 @@ export interface UpdateProfileInput {
     username?: string;
     bio?: string | null;
     image?: string | null;
+    /** The profile banner as an absolute image URL, or null to remove it (PUT /profiles/me has accepted it since #1867). */
+    banner?: string | null;
 }
 export interface SearchProfilesParams extends PaginationParams {
     q: string;
 }
+/** A row of `profiles.search`: the profile plus what the ranking read (match x ln(1 + followers + min(posts, 100))). */
+export interface ProfileSearchResult extends Profile {
+    followers_count: number;
+    posts_count: number;
+    /** Nobody follows it and it never posted: listed after every account with a public life, for a client to fold under "more handles". */
+    empty: boolean;
+    /** An account the operator vouches for: draw the verified badge. */
+    verified: boolean;
+    plus: boolean;
+    pro: boolean;
+    founder: boolean;
+}
 export interface SearchMentionsParams {
     /** What the member typed after `@` (a leading `@` is ignored). */
     q: string;
@@ -1082,6 +1216,13 @@ export interface LoginHistoryEntry {
 }
 export interface RecursivConfig {
     apiKey?: string;
+    /**
+     * Whether to fall back to `RECURSIV_API_KEY` when `apiKey` is omitted.
+     * Defaults to true for backwards compatibility and branded pre-auth flows.
+     * Set to false for public clients that must remain keyless even in a
+     * credentialed server process.
+     */
+    inheritEnvironmentApiKey?: boolean;
     baseUrl?: string;
     timeout?: number;
     maxRetries?: number;