@recursiv/sdk 0.7.123 → 0.7.195

package/dist/resources/protocols.js

@@ -28,7 +28,22 @@ export const PROTOCOL_ADAPTER_MATURITIES = Object.freeze([
     'beta',
     'stable',
 ]);
+function nostrStepUpBody(stepUp) {
+    const password = typeof stepUp?.password === 'string' ? stepUp.password : '';
+    const emailCode = typeof stepUp?.emailCode === 'string' ? stepUp.emailCode.trim() : '';
+    if (Boolean(password) === Boolean(emailCode)) {
+        throw new ValidationError({ type: 'validation_error', code: 'invalid_input', message: 'Send the account password, or the emailed nostr_key code, not both' });
+    }
+    return password ? { password } : { email_code: emailCode };
+}
 const NATIVE_NETWORKS = ['activitypub', 'atproto', 'nostr'];
+function engageOneBody(input) {
+    if (input.identity !== undefined && input.identity !== 'native' && input.identity !== 'linked') {
+        throw new ValidationError({ type: 'validation_error', code: 'invalid_input', message: 'identity must be native or linked' });
+    }
+    return { clientMutationId: input.clientMutationId, protocol: input.protocol, nativeId: input.nativeId, action: input.action,
+        ...(input.identity !== undefined ? { identity: input.identity } : {}), ...(input.accountId !== undefined ? { accountId: input.accountId } : {}) };
+}
 function nativeNetworkPath(network) {
     if (!NATIVE_NETWORKS.includes(network)) {
         throw new ValidationError({ type: 'validation_error', code: 'invalid_network', message: 'network must be activitypub, atproto or nostr' });
@@ -201,6 +216,15 @@ export class ProtocolsResource {
             throw error;
         }
     }
+    /**
+     * A category's stories, open-network posts and clips for a signed-out visitor, in one keyless read (SharedCategorySurface).
+     * The answer is the same for every visitor of the app, category and Politics choice, and the URL carries nothing else,
+     * so a shared cache may keep it for 30 s. Only `category` and `compass` are sent: the server refuses any other
+     * parameter. An API that predates the route answers 401 `missing_api_key` (it falls through to the keyed routes) or 404.
+     */
+    getSharedCategorySurface(projectId, params, options) {
+        return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/category`, { category: params.category, ...(params.compass !== undefined ? { compass: params.compass } : {}) }, ...readOptions(options));
+    }
     publicNetworks() {
         return this.client.get('/protocols/social/networks');
     }
@@ -315,9 +339,14 @@ export class ProtocolsResource {
     async getPublicViral(params = {}, options) {
         return viralRead(await this.client.get('/protocols/social/viral', viralQuery(params), ...readOptions(options)));
     }
-    /** Provider-ranked public accounts with explicit provenance; served from the app's index when a fresh snapshot exists. */
+    /**
+     * Popular public accounts with explicit provenance; served from the app's index when a fresh snapshot exists.
+     * `protocol: 'all'` reads the famous accounts of every network in one list, paged for infinite scroll, optionally
+     * narrowed to a `category`; `compass: 'hide'` leaves political accounts out of any list.
+     */
     getPublicPopularProfiles(params) {
-        return this.client.get('/protocols/social/popular-profiles', { protocol: params.protocol, limit: params.limit, cursor: params.cursor });
+        return this.client.get('/protocols/social/popular-profiles', { protocol: params.protocol, limit: params.limit, cursor: params.cursor,
+            ...(params.category !== undefined ? { category: params.category } : {}), ...(params.compass !== undefined ? { compass: params.compass } : {}) });
     }
     /** Read this connected account's current native following; never infer it from a public count. */
     nativeFollowState(input) {
@@ -550,6 +579,122 @@ export class ProtocolsResource {
         const body = input.enabled ? { enabled: true } : { enabled: false, ...(input.removePast !== undefined ? { remove_past: input.removePast } : {}) };
         return this.client.put(nativeNetworkPath(network), body);
     }
+    /**
+     * Which identity a one-tap action uses on a network when the member also linked an outside account there (0.7.191).
+     * `linked` needs a linked account (409 `linked_account_required`); `native` needs the network on, ready or pending
+     * (409 `native_network_off`) and a network that can send a tap as the member's identity (503
+     * `native_network_unavailable`, reason `adapter_missing`, otherwise), and sets the identity up now when that is what the
+     * choice needs. Needs `users:write`.
+     */
+    setEngageDefault(network, engageDefault) {
+        if (engageDefault !== 'native' && engageDefault !== 'linked') {
+            throw new ValidationError({ type: 'validation_error', code: 'invalid_input', message: 'engageDefault must be native or linked' });
+        }
+        return this.client.put(`${nativeNetworkPath(network)}/engage-default`, { engage_default: engageDefault });
+    }
+    /**
+     * "Get my AT Protocol password" (0.7.191): the PDS emails a reset code to the member's verified address, the one their hosted AT
+     * Protocol account uses; Minds never holds or shows that password (it keeps only a revocable app password, which the
+     * member can revoke from any AT Protocol app). Needs a step-up (403 `step_up_required` / `step_up_failed`). Other
+     * refusals: 404 `no_identity`, 409 `needs_verified_email` or `email_changed`, 429 `rate_limited`. Needs `users:write`.
+     * Never auto-retried.
+     */
+    claimAtprotoPassword(proof) {
+        const body = 'password' in proof ? { password: proof.password } : { email_code: proof.emailCode };
+        return this.client.post(`${nativeNetworkPath('atproto')}/claim-password`, body, { retry: false });
+    }
+    /**
+     * "Let Minds act as your AT Protocol account" (0.7.191): the way back when AT Protocol reads `needs_action` with reason
+     * `needs_atproto_grant` (an account made before Minds ran it natively) or `error` with `app_password_revoked`. The member
+     * enters their AT Protocol account's password once (the main one, which `claimAtprotoPassword` lets them set, or a
+     * non-privileged app password they made); Minds keeps only a new revocable app password and drops the password given.
+     * Refusals: 403 `password_failed`, 400 `privileged_app_password` (one that can read direct messages), 409
+     * `identity_mismatch`, 404 `no_identity`, 429 `rate_limited`. Needs `users:write`. Never auto-retried.
+     */
+    grantAtproto(input) {
+        return this.client.post(`${nativeNetworkPath('atproto')}/grant`, { password: input.password }, { retry: false });
+    }
+    /** The member's one-tap actions waiting for their native identity to be set up, oldest first (0.7.191). Needs `users:read`. */
+    pendingInteractions() {
+        return this.client.get('/protocols/interactions/pending');
+    }
+    /**
+     * One-tap like or unlike (0.7.191). A native answer is sent (`NativeEngageSent`) or queued (`NativeEngageQueued`, 202)
+     * while the identity is set up; a linked answer is the review to submit with `submitNativeLike`, as before. Refusals:
+     * 409 `native_network_off` (with `reason`), 409 `linked_account_required`, 429 `too_many_pending`, and 503
+     * `native_network_unavailable` with reason `adapter_missing` while the network cannot send a tap as the member's identity
+     * (a linked account acts instead when there is one; nothing is set up or queued). Keep
+     * `clientMutationId` across retries: a retried tap is never sent twice, and once it expired unsent the retry answers
+     * `delivery: { state: 'failed', code: 'interaction_expired' }` (a new tap takes a new id). The same id on a different
+     * action, target or words is 409 `client_mutation_reused`. A tap whose identity went off before it was sent answers
+     * `delivery: { state: 'failed', code: 'native_network_off' }`. Never auto-retried.
+     */
+    engageLike(input) {
+        return this.client.post('/protocols/social/likes/prepare', engageOneBody(input), { retry: false });
+    }
+    /** One-tap repost or unrepost (0.7.191); answers as `engageLike` does (linked: submit with `submitNativeRepost`). */
+    engageRepost(input) {
+        return this.client.post('/protocols/social/reposts/prepare', engageOneBody(input), { retry: false });
+    }
+    /** One-tap follow or unfollow (0.7.191); answers as `engageLike` does (linked: submit with `submitNativeFollow`). */
+    engageFollow(input) {
+        return this.client.post('/protocols/social/follows/prepare', engageOneBody(input), { retry: false });
+    }
+    /**
+     * A reply as the member's own identity on the parent's network, or (identity `linked`, or `accountIds`) the shared
+     * reply review as `prepareNativeReply` (0.7.191). Answers as `engageLike` does. `media` takes only the member's own
+     * Minds uploads, native or linked (400 `invalid_reply` otherwise; 422 `media_unsupported` for a GIF with other images
+     * on ActivityPub).
+     */
+    engageReply(input) {
+        return this.client.post('/protocols/social/replies/prepare', { clientMutationId: input.clientMutationId, text: input.text,
+            parent: { protocol: input.parent.protocol, nativeId: input.parent.nativeId, ...(input.parent.readRef !== undefined ? { readRef: input.parent.readRef } : {}) },
+            ...(input.media !== undefined ? { media: nativeMediaInput(input.media) } : {}),
+            ...(input.identity !== undefined ? { identity: input.identity } : {}),
+            ...(input.accountIds !== undefined ? { accountIds: input.accountIds } : {}) }, { retry: false });
+    }
+    /**
+     * A quote of a post as the member's own identity on its network, or (identity `linked`, or `accountIds`) the post
+     * review as `prepareNativePost` (0.7.191). A post with no quote is never native: the member's posts in the app reach
+     * their networks on their own (409 `native_post_from_app`). Answers as `engageLike` does.
+     */
+    engageQuote(input) {
+        return this.client.post('/protocols/social/posts/prepare', { clientMutationId: input.clientMutationId, text: input.text,
+            quote: { protocol: input.quote.protocol, nativeId: input.quote.nativeId },
+            ...(input.media !== undefined ? { media: nativeMediaInput(input.media) } : {}),
+            ...(input.identity !== undefined ? { identity: input.identity } : {}),
+            ...(input.accountIds !== undefined ? { accountIds: input.accountIds } : {}) }, { retry: false });
+    }
+    /**
+     * Takes the member's managed Nostr key home, step 1: the key as an `nsec`, after a step-up (403 `step_up_required`
+     * or `step_up_failed`, 429 `rate_limited`, 404 `no_managed_key`). Minds keeps its copy. Never retried. Needs
+     * `users:write`.
+     */
+    exportNostrKey(stepUp) {
+        return this.client.post('/protocols/networks/nostr/export', nostrStepUpBody(stepUp), { retry: false });
+    }
+    /** Step 2a: a single-use challenge for the member's signer to sign with the same key (NIP-07, never published). */
+    nostrRebindChallenge() {
+        return this.client.post('/protocols/networks/nostr/rebind-challenge', {});
+    }
+    /**
+     * Step 2b: the signed challenge. A signature from the identity's own key sets the mode to `attached` (409
+     * `rebind_mismatch` for another key; 400 `invalid_proof`, `expired_proof` or `used_proof`). Minds still holds its copy.
+     */
+    rebindNostrKey(event) {
+        return this.client.post('/protocols/networks/nostr/rebind', { event }, { retry: false });
+    }
+    /**
+     * Step 3: after a step-up, and only once rebound (409 `rebind_required`), Minds deletes its encrypted copy of the
+     * key. First it signs, with the copy, a takedown for everything it published with the key, kept so a post deletion,
+     * "Remove what I already shared" or the account's deletion still takes Minds' notes down (409 `too_many_published`
+     * when there is too much: the copy is kept). The NIP-05 address keeps the same key; every later Nostr action is a
+     * signing request for the member's device. Not undoable by Minds: make sure their signer holds the key first. Never
+     * retried.
+     */
+    deleteManagedNostrCopy(stepUp) {
+        return this.client.post('/protocols/networks/nostr/delete-managed-copy', nostrStepUpBody(stepUp), { retry: false });
+    }
     /** Current Minds-hosted ActivityPub state for this app user; never provisions. */
     federationIdentity() {
         return this.client.get('/protocols/social/federation/identity');
@@ -577,7 +722,7 @@ export class ProtocolsResource {
                     source: { protocol: input.source.protocol, nativeId: input.source.nativeId,
                         ...(input.source.readRef !== undefined ? { readRef: input.source.readRef } : {}) } }
                     : { action: input.action, postId: input.postId };
-        return this.client.post(`/protocols/social/nostr/${encodeURIComponent(id)}/prepare`, body, { retry: false });
+        return this.client.post(`/protocols/social/nostr/${encodeURIComponent(id)}/prepare`, input.send === true ? { ...body, send: true } : body, { retry: false });
     }
     /** Pass only the public signed event. After a timeout, read the prepared postId (delete) or eventId (publish/reply/linked_post).
      * Any user-selected retry keeps the same intent/event. */
@@ -644,9 +789,11 @@ export class ProtocolsResource {
      *
      * Failures to expect: `handle_unavailable` (409, taken or reserved; choose
      * another), `identity_conflict` (409, the member already has one),
-     * `creation_in_progress` (409), and the operator-side 503s
-     * `handle_dns_unavailable`, `handle_unresolvable`, `handle_unverified` and
-     * `hosted_server_unavailable`, which succeed unchanged once the operator is done.
+     * `creation_in_progress` (409), `outbound_refused` (403, the server's one
+     * outbound guard said no before the PDS was asked anything; nothing was
+     * created), and the operator-side 503s `handle_dns_unavailable`,
+     * `handle_unresolvable`, `handle_unverified` and `hosted_server_unavailable`,
+     * which succeed unchanged once the operator is done.
      */
     createHostedIdentity(input) {
         const { protocol, handle, email } = input;

package/dist/resources/reports.d.ts

@@ -1,10 +1,11 @@
 import type { HttpClient } from '../client.js';
 import type { PaginatedResponse, SingleResponse } from '../types.js';
-export type ReportTargetType = 'post' | 'user' | 'community' | 'message' | 'source_actor' | 'source_post';
+export type ReportTargetType = 'post' | 'user' | 'community' | 'message' | 'sealed_answer' | 'source_actor' | 'source_post';
 export type ReportStatus = 'pending' | 'in_review' | 'escalated' | 'resolved' | 'dismissed';
 export interface CreateReportInput {
     /** External sources require protocols.reportSource so evidence is verified. */
     target_type: Exclude<ReportTargetType, 'source_actor' | 'source_post'>;
+    /** For sealed_answer, the authenticated project key's project id; it does not accuse the reporter. Requires supporting API. */
     target_id: string;
     reason: string;
     details?: string;
@@ -32,9 +33,13 @@ export declare class ReportsResource {
     private client;
     constructor(client: HttpClient);
     /**
-     * Submit a content report. Targets a post, user, community, or message
+     * Submit a content report. Targets a post, user, community, message, or Sealed answer
      * by ID, with a short reason and optional free-text details. Reporter
      * is the authenticated user.
+     * A sealed_answer targets the key's own project and needs posts:write on a human-owned,
+     * non-agent project key. This intake does not recheck live app membership; the Sealed
+     * gateway's report route does. Review applies no account enforcement.
+     * Deploy supporting API before client adoption.
      *
      * Sent once, never retried automatically: past the member's report budget
      * the server answers 429 (`RateLimitError`, `retryAfter` = seconds until
@@ -42,6 +47,10 @@ export declare class ReportsResource {
      */
     create(input: CreateReportInput): Promise<SingleResponse<{
         success: true;
+        id?: string;
+        existing?: boolean;
+        /** Sealed answers: false when a join kept the reason but the selected exchange did not fit in full. */
+        details_kept?: boolean;
     }>>;
     /** List recent reports in the caller's project/network (admin only). */
     list(): Promise<PaginatedResponse<ReportRecord>>;

package/dist/resources/reports.js

@@ -4,9 +4,13 @@ export class ReportsResource {
         this.client = client;
     }
     /**
-     * Submit a content report. Targets a post, user, community, or message
+     * Submit a content report. Targets a post, user, community, message, or Sealed answer
      * by ID, with a short reason and optional free-text details. Reporter
      * is the authenticated user.
+     * A sealed_answer targets the key's own project and needs posts:write on a human-owned,
+     * non-agent project key. This intake does not recheck live app membership; the Sealed
+     * gateway's report route does. Review applies no account enforcement.
+     * Deploy supporting API before client adoption.
      *
      * Sent once, never retried automatically: past the member's report budget
      * the server answers 429 (`RateLimitError`, `retryAfter` = seconds until

package/dist/resources/search.d.ts

@@ -35,9 +35,35 @@ export interface SearchLadder {
     pending: number;
     unavailable: string[];
 }
-/** A post as a search lists it: `via` says how the ladder found it (absent from servers before 0.7.79). */
+/**
+ * What a search post's picture is (server 0.7.162, picture-facts-v1: Jev's background read of pictures every floor
+ * cleared, cached 30 days). Layout hints only, never a safety signal: absent until the picture is judged, when the
+ * server's switch is off, or on servers before 0.7.162, and a client keeps its own layout then.
+ */
+export interface SearchPicture {
+    /** `text_graphic`: a screenshot, headline card, table, chart, poster or infographic. `other`: a meme or anything else. */
+    kind: 'photo' | 'illustration' | 'text_graphic' | 'other';
+    /** Most of what it says is written text: show it whole (contain), not cropped, and do not lead with it. */
+    textHeavy: boolean;
+    /** How good a big tile it makes, 0 (unusable) to 3 (striking). */
+    tileQuality: number;
+    /** Where its main subject is, as fractions of the width (`x`) and height (`y`) from the top left: a crop's object position. */
+    focal?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Whether the picture itself shows what was searched (0.7.190, search-picture-subject-v1, cached 7 days per query and
+     * picture): on a visitor's `deep` stage only, for the page's top pictures. Absent unless the operator turned on
+     * `SEARCH_PICTURE_SUBJECT` (with picture facts), and until that query's picture is judged. A layout hint (make a big
+     * tile of it when `true`), never a reason to hide a result and never a safety signal.
+     */
+    showsQuery?: boolean;
+}
+/** A post as a search lists it: `via` says how the ladder found it (absent from servers before 0.7.79); `picture`: SearchPicture. */
 export type SearchPost = Post & {
     via?: SearchVia;
+    picture?: SearchPicture;
 };
 /**
  * A visitor's search tabs (tRPC `publicDiscovery.search`, read keyless through the app's public client). `media` (server
@@ -62,12 +88,50 @@ export interface PublicSearchPage<T = Record<string, unknown>> {
     };
     /** The `media` tab only: what the web has for the words. Absent where the app does not get it (`ladder.unavailable` names `media`). */
     media?: SearchMedia;
+    /**
+     * A posts tab's deep stage, page 1 only (server 0.7.137): searches related to what the words mean, best first, for
+     * related-topic chips ("hockey": NHL, Stanley Cup). Absent when the server has none in time, and from older servers.
+     */
+    related_queries?: Array<{
+        query: string;
+    }>;
+    /**
+     * The page's clips in lead order (server 0.7.173): its posts' clips, the open networks' and the `media` tab's videos,
+     * the most about the words first (`SearchVideoLeadEntry`). The `videos` tab's `items` already come in this order.
+     * Absent with no clip, from older servers, or when the operator turned the lead order off.
+     */
+    video_lead?: SearchVideoLeadEntry[];
+}
+/** Where a clip in a search's `video_lead` came from: a Minds member's post, an open-network post, PeerTube, or the web. */
+export type SearchVideoLeadSource = 'minds' | 'open_network' | 'peertube' | 'web';
+/**
+ * One clip of a search answer in lead order (server 0.7.173). The order: `on_subject` (`on`: about the words, `loose`: it
+ * mentions them, `off`: the popular tail), then freshness (within a day, a week, 30 days, a year, older, undated last),
+ * then a Minds member's clip before any other, then the newer. Play the first entry as the lead. `section` and `index`
+ * point at the item in the answer (`items` on a visitor's page); `ref` is the Minds post id, the open-network post's
+ * `sourceUrl` or the media item's `url`. A client merging two answers' entries sorts by the same rules.
+ */
+export interface SearchVideoLeadEntry {
+    section: 'top_posts' | 'latest_posts' | 'open_network' | 'media' | 'items';
+    index: number;
+    ref: string;
+    source: SearchVideoLeadSource;
+    on_subject: 'on' | 'loose' | 'off';
+    /** ISO 8601, when the clip is dated. */
+    published_at: string | null;
 }
 /** The kinds of a search's media items, in the order the server lists them. */
 export declare const SEARCH_MEDIA_KINDS: readonly ["about", "video", "article", "image", "audio"];
 export type SearchMediaKind = (typeof SEARCH_MEDIA_KINDS)[number];
-/** Where a media item was found. */
-export type SearchMediaSource = 'brave' | 'wikipedia' | 'peertube' | 'openverse';
+/**
+ * Where a media item was found. `eventregistry` (0.7.133): a news article from the thousands the server's news lanes
+ * read each day (Event Registry and outlet feeds), matched by its headline: show its headline, `description` (a short
+ * excerpt), `publisher` (the outlet), `published_at`, `thumbnail` and link to `url`, never more of the article.
+ * `youtube` (0.7.181): a video the YouTube Data API found for the words; it always has YouTube's player as `embed`: play
+ * it in place by YouTube's player rules (no autoplay with sound, nothing drawn over it, YouTube named as the source)
+ * rather than opening `url`.
+ */
+export type SearchMediaSource = 'brave' | 'wikipedia' | 'peertube' | 'openverse' | 'eventregistry' | 'youtube';
 /**
  * How a video may play in place: YouTube's own player for `id` (use youtube-nocookie.com and follow its player rules:
  * at least 200x200, nothing drawn over it, YouTube shown as the source), or a PeerTube instance's own embed page.
@@ -106,8 +170,20 @@ export interface SearchMediaItem {
      * Visitors and members on safe defaults are never served such an item.
      */
     sensitive?: true;
+    /**
+     * The same PeerTube video as a native Fediverse post (0.7.155, `SocialPost.software: 'peertube'`): show the post, which
+     * plays in place from its channel, and never open `url`. Present only on a PeerTube video the server could read off its
+     * own instance; the item's other fields stay for an app that does not read it.
+     */
+    post?: SocialPost;
 }
-export type SearchMediaProvider = 'brave_web' | 'brave_images' | 'wikipedia' | 'peertube' | 'openverse_images' | 'openverse_audio';
+/**
+ * The reads behind the media section. `news_index` (0.7.133): today's articles about the words from those the server's
+ * news lanes already read; `eventregistry`: a live per-query Event Registry read, where the server has one; `youtube`
+ * (0.7.181): YouTube's videos for the words, asked only when the web's own videos about them are thin or the words name
+ * sport or music (`skipped` otherwise), within the server's daily YouTube quota (`budget` past it).
+ */
+export type SearchMediaProvider = 'brave_web' | 'brave_images' | 'wikipedia' | 'peertube' | 'openverse_images' | 'openverse_audio' | 'news_index' | 'eventregistry' | 'youtube';
 /**
  * What each provider did for this answer; `timeout`: it is still reading, ask again shortly for more; `budget`: a
  * spending limit held it back (the day's Brave calls, or this caller's own calls a day or fresh answers an hour, past
@@ -226,6 +302,14 @@ export interface SearchRelated {
         slug: string;
         count: number;
     }>;
+    /**
+     * Searches related to the query's subject, best first, for related-topic chips ("hockey": NHL, Stanley Cup, ice hockey):
+     * from the server's understanding of the query (server 0.7.137), so a query whose posts carry no topic still has them.
+     * Absent when the server has none for the query, and from older servers.
+     */
+    queries?: Array<{
+        query: string;
+    }>;
 }
 /** One blended search answer. Only answered sections are present; an answered section may be empty. */
 export interface SearchAnswer {
@@ -285,6 +369,12 @@ export interface SearchAnswer {
     few_results: boolean;
     /** The search ladder's account of the answer (server 0.7.79): present when the server ran the ladder. */
     ladder?: SearchLadder;
+    /**
+     * Every clip the answer holds (Top's and Latest's Minds clips, the open networks', the media section's videos) in the
+     * order to lead and play them (server 0.7.173, `SearchVideoLeadEntry`): the most about the words first, then the
+     * freshest, a Minds member's clip winning a tie. Absent with no clip, from older servers, or when turned off.
+     */
+    video_lead?: SearchVideoLeadEntry[];
 }
 export interface SearchResponse {
     data: SearchAnswer;

package/dist/resources/settings.d.ts

@@ -1,10 +1,19 @@
 import type { HttpClient } from '../client.js';
 import type { ChangePasswordInput, ConfirmationCodePurpose, ConfirmationCodeSent, DeletionStatus, DisableAccountInput, LoginHistoryEntry, PaginatedResponse, RequestEmailChangeInput, RevokeOtherSessionsInput, RevokeOtherSessionsResult, Session, SingleResponse, SuccessResponse, UpdateAppearanceInput, UpdateContentPreferencesInput, UpdateNotificationChannelsInput, UpdatePrivacyInput, UserPreferences } from '../types.js';
+import type { MemberExperience, UpdateMemberExperienceInput } from './member-experience.js';
 export declare class SettingsResource {
     private client;
     constructor(client: HttpClient);
     /** Get user preferences */
     getPreferences(): Promise<SingleResponse<UserPreferences>>;
+    /** Read your explicit goals and category starting point in this app; requires your own project-bound key. */
+    getExperience(): Promise<SingleResponse<MemberExperience>>;
+    /** Save explicit choices at the current version. This changes the saved starting point, not whole-feed ranking. */
+    updateExperience(input: UpdateMemberExperienceInput): Promise<SingleResponse<MemberExperience>>;
+    /** Restore the previous choices if this version is still current; a stale Undo is refused. */
+    undoExperience(input: {
+        version: number;
+    }): Promise<SingleResponse<MemberExperience>>;
     /**
      * Download a portable ZIP containing the caller's profile, posts, social
      * graph, authored messages, account activity, preferences, and fetchable
@@ -50,8 +59,9 @@ export declare class SettingsResource {
      * Email a six-digit confirmation code to the account's current address.
      * Only for accounts with no password (`profiles.me().has_password === false`);
      * a password account answers `password_required`. Send the code as
-     * `email_code` to `requestEmailChange`, or as `emailCode` to the
-     * `auth.*TwoFactor` methods.
+     * `email_code` to `requestEmailChange`, as `emailCode` to the
+     * `auth.*TwoFactor` methods, or (purpose `nostr_key`) as `emailCode` to
+     * `protocols.exportNostrKey` and `protocols.deleteManagedNostrCopy`.
      */
     requestConfirmationCode(purpose: ConfirmationCodePurpose): Promise<SingleResponse<ConfirmationCodeSent>>;
     /**

package/dist/resources/settings.js

@@ -8,6 +8,18 @@ export class SettingsResource {
     getPreferences() {
         return this.client.get('/settings/preferences');
     }
+    /** Read your explicit goals and category starting point in this app; requires your own project-bound key. */
+    getExperience() {
+        return this.client.get('/settings/preferences/experience');
+    }
+    /** Save explicit choices at the current version. This changes the saved starting point, not whole-feed ranking. */
+    updateExperience(input) {
+        return this.client.patch('/settings/preferences/experience', input);
+    }
+    /** Restore the previous choices if this version is still current; a stale Undo is refused. */
+    undoExperience(input) {
+        return this.client.post('/settings/preferences/experience/undo', input);
+    }
     /**
      * Download a portable ZIP containing the caller's profile, posts, social
      * graph, authored messages, account activity, preferences, and fetchable
@@ -87,8 +99,9 @@ export class SettingsResource {
      * Email a six-digit confirmation code to the account's current address.
      * Only for accounts with no password (`profiles.me().has_password === false`);
      * a password account answers `password_required`. Send the code as
-     * `email_code` to `requestEmailChange`, or as `emailCode` to the
-     * `auth.*TwoFactor` methods.
+     * `email_code` to `requestEmailChange`, as `emailCode` to the
+     * `auth.*TwoFactor` methods, or (purpose `nostr_key`) as `emailCode` to
+     * `protocols.exportNostrKey` and `protocols.deleteManagedNostrCopy`.
      */
     requestConfirmationCode(purpose) {
         return this.client.post('/settings/confirmation-code', { purpose });

package/dist/types.d.ts

@@ -184,6 +184,19 @@ export interface UserSummary {
      * servers older than this field and from reads that do not label accounts.
      */
     is_nsfw?: boolean;
+    /**
+     * An account the operator vouches for: draw the verified badge. Carried by a
+     * post's author. An app that draws one mark next to a name draws verified
+     * before `founder` before the plan mark. Absent from servers older than this
+     * field and from reads that do not mark accounts.
+     */
+    verified?: boolean;
+    /** The account's Plus plan is live. Absent from reads that do not mark accounts. */
+    plus?: boolean;
+    /** The account's Pro plan is live. Absent from reads that do not mark accounts. */
+    pro?: boolean;
+    /** A founding member. Absent from reads that do not mark accounts. */
+    founder?: boolean;
 }
 export interface User extends UserSummary {
     bio: string | null;
@@ -1378,6 +1391,13 @@ export interface AgentChatResult {
 export interface AgentConversation {
     id: string;
     type: string;
+    /**
+     * The conversation's own name (a group's, the Asks thread's), else, for a one-to-one chat, its title: the first 60
+     * characters of the first message the agent did not send, looked for in the chat's first 20 messages, made by the
+     * server with no model call and gone when that message is. Null when no such message is among the first 20 (before
+     * anyone but the agent has written in it, for one); absent from a server that predates it.
+     */
+    name?: string | null;
     members: {
         id: string;
         name: string;
@@ -1404,6 +1424,11 @@ export interface AgentConversationMessage {
     } | null;
     created_at: string;
 }
+/** A new chat with the caller's own personal agent, as `agents.createConversation` returns it. */
+export interface CreatedAgentConversation extends AgentConversation {
+    /** False when the member's empty chat with the agent in this app was handed back instead of a second blank one. */
+    created: boolean;
+}
 export interface CreateTagInput {
     name: string;
     description?: string;
@@ -1760,7 +1785,7 @@ export interface RequestEmailChangeInput {
     email_code?: string;
 }
 /** What a confirmation code is for. A code for one purpose never confirms another. */
-export type ConfirmationCodePurpose = 'email_change' | 'two_factor';
+export type ConfirmationCodePurpose = 'email_change' | 'two_factor' | 'nostr_key';
 export interface ConfirmationCodeSent {
     success: true;
     purpose: ConfirmationCodePurpose;