@recursiv/sdk 0.7.123 → 0.7.195

package/dist/resources/protocols.d.ts

@@ -1,6 +1,7 @@
 import type { HttpClient } from '../client.js';
 import type { CompassFilterMeta, DiscoveryLayout, PaginatedResponse, PaginationParams, SingleResponse, StoryOutlets } from '../types.js';
 import type { CuratorStoryPostsPage } from './curator.js';
+import type { CategorySurface } from './discovery.js';
 import type { NativeWriteProtocol, SocialProtocolId } from '../social-protocol-ids.js';
 /** Canonical protocol operation names returned by the adapter registry. */
 export declare const PROTOCOL_CAPABILITY_OPERATIONS: readonly ["discover", "stream", "backfill", "search", "resolveIdentity", "fetchProfile", "fetchThread", "publish", "reply", "react", "repost", "follow", "delete", "health", "checkpoint"];
@@ -375,7 +376,7 @@ export interface HostedNostrIdentityProof {
     created_at: number;
     tags: string[][];
 }
-export type NativeNostrPrepareInput = {
+export type NativeNostrPrepareInput = ({
     action: 'publish';
     content: string;
     /** Your own post in this app (sdk.posts) that this note copies, so deleting it can offer this copy. */
@@ -403,6 +404,13 @@ export type NativeNostrPrepareInput = {
 } | {
     action: 'delete';
     postId: string;
+}) & {
+    /**
+     * A key Minds holds (`signing: 'server'`, 0.7.192): `true` once the member approved, and Minds signs the exact event
+     * and sends it in this call (the answer carries `receipt`). Without it a prepare is a preview for every key: nothing
+     * is signed, sent or deleted. Ignored for the member's own key, which they sign on their device as before.
+     */
+    send?: true;
 };
 export type NativeSocialProtocol = 'bluesky' | 'activitypub';
 export interface NativeSocialAccount {
@@ -435,7 +443,7 @@ export type NativeNetwork = 'activitypub' | 'atproto' | 'nostr';
  * for the setup budget (`retryAt`). `off`: the member turned it off (`reason: 'opted_out'`), it is not available to them
  * yet (`not_rolled_out`), or their profile is private (`private_profile`, AT Protocol and Nostr only; `setNetwork`
  * with `enabled: true` turns it on). `needs_action`: the member must act first (`age_band_required`,
- * `needs_verified_email`). `locked`: held off by a rule the member cannot change.
+ * `needs_verified_email`, `needs_atproto_grant`: `grantAtproto`). `locked`: held off by a rule the member cannot change.
  */
 export type NativeNetworkState = 'ready' | 'on' | 'pending' | 'off' | 'error' | 'locked' | 'needs_action';
 export interface NativeNetworkPresence {
@@ -447,8 +455,20 @@ export interface NativeNetworkPresence {
     mode: 'hosted' | 'managed' | 'attached';
     /** The member's address on the network, set up or not, when the server can say it. */
     handle: string | null;
-    /** Which identity a one-tap like, repost, reply or follow uses when the member also linked an outside account. */
+    /**
+     * Which identity a one-tap like, repost, reply or follow without `identity` acts as now: the member's choice
+     * (`setEngageDefault`) when it can act, else `linked` while they have an account there linked before the cutover, else
+     * `native` while their native identity can act, else `linked` when they have a linked account (the fallback). When
+     * nothing can act, their choice, else `native`.
+     */
     engageDefault: 'native' | 'linked';
+    /**
+     * Where engageDefault comes from (0.7.191): the member's choice, their linked account, the default, or the fallback
+     * (the native identity cannot act, so a tap acts as the linked account whatever the member chose).
+     */
+    engageDefaultSource?: 'chosen' | 'linked_account' | 'default' | 'fallback';
+    /** Whether the member linked an outside account on this network (0.7.191; only `networks()` reports it). */
+    linked?: boolean;
     activatedAt: string | null;
     optedOutAt: string | null;
     removePast: boolean;
@@ -470,6 +490,137 @@ export interface SetNativeNetworkInput {
     /** Turning off: also remove what was already shared there (the Settings sheet checks this by default). */
     removePast?: boolean;
 }
+/**
+ * A Minds step-up for "Get my AT Protocol password" (0.7.191): the member's password, or, for an account with no password, the
+ * code from `POST /settings/confirmation-code` with purpose `atproto_password`. Exactly one.
+ */
+export type AtprotoPasswordClaimProof = {
+    password: string;
+} | {
+    emailCode: string;
+};
+/** Where the reset code went: the member's verified email, masked (`o***@example.com`), and the account's handle. */
+export interface AtprotoPasswordClaim {
+    handle: string;
+    sentTo: string;
+}
+/**
+ * What `grantAtproto` answers (0.7.191): the account's handle, and the member's AT Protocol presence after the grant
+ * (set up as "Set up now" would: `on`, unless the member turned the network off).
+ */
+export interface AtprotoGrant {
+    handle: string;
+    presence: NativeNetworkPresence;
+}
+/** Which identity a one-tap action acts as (0.7.191): the member's own on that network, or an outside account they linked. */
+export type EngageIdentity = 'native' | 'linked';
+/** Who acted, on every engage answer. `handle` is the address on the network, null when the server cannot say it. */
+export interface EngageActedAs {
+    network: NativeNetwork;
+    handle: string | null;
+    identity: EngageIdentity;
+}
+/**
+ * What a linked review adds (0.7.191): who acted, and `notice: 'engage_default_linked'` once, the first time a member who
+ * linked an account before acts as it while they also have a native identity there (say so, and link to Settings).
+ */
+export interface EngageLinkedFields {
+    identity?: 'linked';
+    actedAs?: EngageActedAs | null;
+    notice?: 'engage_default_linked';
+}
+/** A native one-tap action the network was sent (200). A `failed` delivery with `retryable` may be tried again. */
+export interface NativeEngageSent {
+    identity: 'native';
+    queued: false;
+    delivery: {
+        state: 'sent';
+    } | {
+        state: 'skipped';
+        code: string;
+    } | {
+        state: 'failed';
+        code: string;
+        retryable: boolean;
+    };
+    actedAs: EngageActedAs;
+}
+/**
+ * A native one-tap action kept while the member's identity there is set up (202). It is sent, in the order the member
+ * took their actions, once the identity is on; if it cannot be by `expiresAt` the member is notified. `retryAt`: when the
+ * setup budget frees, when that is known. List them with `pendingInteractions()`.
+ */
+export interface NativeEngageQueued {
+    identity: 'native';
+    queued: true;
+    interactionId: string;
+    expiresAt: string;
+    retryAt: string | null;
+    actedAs: EngageActedAs;
+}
+/** An engage answer: the native action sent or queued, or the linked review to approve (submit) as before. */
+export type EngageAnswer<Review> = NativeEngageSent | NativeEngageQueued | (Review & EngageLinkedFields & {
+    identity: 'linked';
+});
+/** One one-tap action waiting for the member's native identity (`pendingInteractions()`). */
+export interface PendingNativeInteraction {
+    id: string;
+    network: NativeNetwork;
+    action: string;
+    target: string;
+    state: 'queued';
+    createdAt: string;
+    expiresAt: string;
+}
+/**
+ * A one-tap like, repost or follow (0.7.191). Without `identity` the server decides: the member's choice, their linked
+ * account when they had one, else their native identity. `accountId` names a linked account (identity `linked` only).
+ * `protocol` is a network the API writes to (NativeWriteProtocol): a Farcaster post can be read, not yet engaged with.
+ */
+export interface EngageOneInput<Action extends string> {
+    protocol: NativeWriteProtocol;
+    nativeId: string;
+    clientMutationId: string;
+    action: Action;
+    identity?: EngageIdentity;
+    accountId?: string;
+}
+/**
+ * The step-up the Nostr key actions ask for: the account's password, or, for an account with no password, the code
+ * from `settings.requestConfirmationCode('nostr_key')` (sent to the account's own address). Five tries an hour.
+ */
+export type NostrKeyStepUp = {
+    password: string;
+    emailCode?: never;
+} | {
+    emailCode: string;
+    password?: never;
+};
+/** The member's managed Nostr key, to import into a signer on their device. Minds keeps its copy and keeps signing. */
+export interface ManagedNostrKeyExport {
+    pubkey: string;
+    npub: string;
+    /** The private key (NIP-19). Show it to the member alone, once; never log, store or send it anywhere. */
+    nsec: string;
+    /** Their NIP-05 address, `name@<app host>`. */
+    handle: string;
+}
+/** What the member's signer signs (NIP-07) to show it holds the same key as their Nostr identity. */
+export interface NostrRebindChallenge extends HostedNostrChallenge {
+    /** The identity's key: the signer must sign with this one. */
+    pubkey: string;
+}
+export interface NostrRebindResult {
+    mode: 'attached';
+    pubkey: string;
+}
+/** Minds deleted its copy of the key: from now on every Nostr action is signed on the member's device. */
+export interface ManagedNostrCopyDeleted {
+    deleted: true;
+    mode: 'attached';
+    pubkey: string;
+    signing: 'device';
+}
 export interface SocialSourceRef {
     /**
      * 0.7.87: any SOCIAL_PROTOCOL_IDS network, Farcaster (an FID, or a `<fid>:0x<hash>` CastId) before its reader serves a
@@ -1034,12 +1185,28 @@ export interface NativeNostrPrepared {
         textTruncated: boolean;
         relay: string;
     };
+    /**
+     * A key Minds holds (0.7.192): there is nothing to sign or submit. Without `send` this is the preview to show the
+     * member (nothing was signed or sent); prepare again with `send: true` once they approve. With `send: true`, Minds
+     * signed `event` and sent it in this call, and `receipt` says what the relay did.
+     */
+    signing?: 'server';
+    receipt?: NativeNostrReceipt;
 }
 export interface NativeNostrAccount {
     enabled: boolean;
     identity: HostedProtocolIdentity | null;
     capabilities: Array<'publish_original_text' | 'request_own_post_deletion' | 'reply_text_note' | 'publish_linked_text' | 'quote' | 'like' | 'unlike' | 'repost' | 'unrepost' | 'follow' | 'unfollow'>;
-    signing?: 'client';
+    /**
+     * Who signs (0.7.192). `client`: the member's own key, on their device (NIP-07): prepare, sign the exact event, submit.
+     * `server`: a key Minds holds for the member (`mode: 'managed'`): Minds signs. A prepare is a preview, and a prepare
+     * with `send: true` signs and sends in the same call (answering the `receipt`); a like, repost or follow review needs
+     * no `event` on submit, and the one-tap `engage*` methods with `identity: 'native'` act as it. `enabled` then follows
+     * the member's Nostr presence: false, with no capabilities, while Nostr is not rolled out to them. For either key,
+     * `like`, `repost` and `follow` (and their undos) are listed only while the app's review route for them is on.
+     */
+    signing?: 'client' | 'server';
+    mode?: 'managed';
 }
 export interface NativeNostrPostState {
     postId: string;
@@ -1188,6 +1355,19 @@ export interface SocialProfilePage {
     items: SocialProfile[];
     cursor: string | null;
 }
+/**
+ * One person a Nostr post's text names (SocialPost.mentions, 0.7.143): at most eight a post, in the order the text first
+ * names them, each only when the server holds their signed metadata, it neither hides nor withholds them, and neither the
+ * app's moderation nor the member's own blocks and mutes hide them (anyone else stays as the text writes them). Show `@displayName` in place of each of `references`, the exact `nostr:`
+ * references in `text` naming this person (at most eight). `handle` is the NIP-05 name their domain confirmed, else
+ * their npub; `pubkey` (hex) opens their profile (`protocol: 'nostr'`, `actor: pubkey`).
+ */
+export interface SocialMention {
+    pubkey: string;
+    displayName: string;
+    handle: string;
+    references: string[];
+}
 /** Public source data read on demand; never a canonical Minds post ID. */
 export interface SocialPost {
     protocol: string;
@@ -1240,6 +1420,8 @@ export interface SocialPost {
         width?: number;
         height?: number;
         sensitive?: true;
+        /** A video's length in whole seconds, where the source declares it (PeerTube; server 0.7.155). */
+        durationSec?: number;
     }>;
     hasAdditionalContent: boolean;
     /**
@@ -1248,6 +1430,11 @@ export interface SocialPost {
      * (a Mastodon sensitive flag or content warning, a Bluesky label, a Nostr content-warning) is never returned at all.
      */
     sensitive?: boolean;
+    /**
+     * Nostr (0.7.143): the people the text names with NIP-27 references (`nostr:npub1…`, `nostr:nprofile1…`) that the server
+     * can name (SocialMention). Absent when it names nobody the server can name, and on an older server.
+     */
+    mentions?: SocialMention[];
     /** At most one independently filtered quoted post. */
     quote?: {
         state: 'available';
@@ -1267,6 +1454,14 @@ export interface SocialPost {
     authorOptOut?: true;
     /** A bridge (Bridgy Fed, Mostr, a NIP-48 proxy tag) made this post from one on another network (SocialBridge). Present only on a copy read live. */
     bridge?: SocialBridge;
+    /**
+     * The Fediverse software that published the post, where the server knows it (0.7.155): `peertube` for a PeerTube
+     * video read off its own instance. Its `author` is the video's channel (follow it as any Fediverse account) and its
+     * one `media` entry is the video's stream, a progressive MP4 (never an HLS playlist: a plain video element plays it)
+     * with the poster on the API's media proxy. Label it as the Fediverse, from PeerTube; play it in place, never open
+     * `sourceUrl`.
+     */
+    software?: 'peertube';
 }
 export interface SocialPostSearch {
     items: SocialPost[];
@@ -1539,6 +1734,37 @@ export interface SocialRadar {
         compass_filter?: CompassFilterMeta;
     };
 }
+/**
+ * A category's surface for a signed-out visitor (`getSharedCategorySurface`, 0.7.165; GET /protocols/public/:projectId/category):
+ * the category's stories, its open-network posts and its clips, the three sections a member's `discovery.category()` reads
+ * from the same server cache, never people or groups. Every visitor floor runs again on each read: stories lose tier-1,
+ * held and blocked-instance members and show media only from outlets and members marked `visitorMedia`; network posts
+ * keep their pictures (with their `width` and `height`) only where cleared for visitors (`visitorMedia: true`), lose a
+ * post marked sensitive or on a blocked instance, and pass the safety and term floors; clips are the anonymous floor's
+ * (never NSFW). A section that is short or failed says why in `reason` (`timeout`, `error`, `off`).
+ */
+export interface SharedCategorySurface extends Omit<CategorySurface, 'people' | 'groups'> {
+    /**
+     * Present when `compass` named a filtering choice: what Hide politics left out of the three sections together (stories
+     * by their `political` mark and theme, network posts and clips by their category, words and author), with
+     * `basis: 'flags'` until the operator serves visitors the full filter; or `status: 'unavailable'` for a side or Mix,
+     * which no section can apply (the sections are Everything's).
+     */
+    meta?: {
+        compass_filter?: CompassFilterMeta;
+    };
+}
+export interface SharedCategorySurfaceParams {
+    /** A browse category the app serves (a network catalog's `categories`); any other is a 400 `categories_unavailable`. */
+    category: string;
+    /**
+     * A visitor's Politics choice: `all` or `hide`; a side or Mix only where the app's catalog lists `compass_sides` for
+     * visitors (`sharedNetworks`: the operator serves them the full filter), and it is a 400 `invalid_input` everywhere else.
+     * No section carries a placement, so an accepted side or Mix answers Everything's sections with
+     * `meta.compass_filter.status: 'unavailable'`, as the radar, the trends, the viral read and Watch answer it.
+     */
+    compass?: string;
+}
 export interface SocialRadarParams {
     category?: string;
     limit?: number;
@@ -1794,24 +2020,71 @@ export interface ViralReadResponse {
 export interface SocialReadOptions {
     retry?: boolean;
 }
+/**
+ * `protocol: 'all'`: every network's reviewed famous accounts (AT Protocol, the Fediverse, Nostr) in one ranking, then
+ * the provider-ranked ones. A network's own list (`protocol: 'bluesky'` and the rest) leads with that network's famous
+ * accounts too.
+ */
+export type SocialPopularProfilesProtocol = 'all' | 'bluesky' | 'activitypub' | 'nostr' | (string & {});
+export interface SocialPopularProfilesParams {
+    protocol: SocialPopularProfilesProtocol;
+    /** 1 to 50; the server's default is 25. */
+    limit?: number;
+    /** The previous page's `cursor`. A `protocol: 'all'` cursor holds its list across an hourly refresh for a few hours, then is refused (start again). */
+    cursor?: string;
+    /** `protocol: 'all'` only: one of the page's `categories` ('news', 'tech', 'sports' ...). */
+    category?: string;
+    /** The member's Politics choice, as Discover sends it: `hide` (Hide politics) leaves out political accounts; any other choice is the default mix. */
+    compass?: string;
+}
+/** One popular account: the profile, the member's Minds subscription, and on `protocol: 'all'` its catalog category. */
+export interface SocialPopularProfile extends SocialProfile {
+    /** `protocol: 'all'` only: the account's category in the reviewed catalog, null for a provider-ranked account. */
+    category?: string | null;
+}
 /** Provider-ranked accounts. `source` says whether this page is the app's hourly index snapshot or a live read. */
 export interface SocialPopularProfiles {
-    items: SocialProfile[];
+    items: SocialPopularProfile[];
     cursor: string | null;
+    /** `protocol: 'all'` only: the categories `category` accepts, best known first. */
+    categories?: string[];
     provenance: {
+        /**
+         * Who ranked the list: the network's provider, or, when the reviewed famous accounts lead it (`famous_accounts`),
+         * the ranking in plain words (`fame and recent activity`, URL `urn:famous-accounts`, not a page): no company name,
+         * so an app can show it as is.
+         */
         provider: {
             name: string;
             url: string;
         };
-        /** The provider's own ranking label, never a Minds popularity score. */
+        /**
+         * The ranker's own label: the provider's (`suggested_users` ...), or `famous_accounts` when the platform's reviewed
+         * catalog leads the list (always on `protocol: 'all'`); never a Minds popularity score.
+         */
         ranking: string;
         fetchedAt: string;
         coverage: 'provider_ranked_window';
+        /**
+         * `famous_accounts` on a network's list (0.7.151): the provider ranking its other accounts come from, with that
+         * provider's own label and read time. Absent when the provider ranked the whole list.
+         */
+        sources?: SocialPopularProfilesSource[];
         source: 'index' | 'live';
         /** Provider read time of the served snapshot; null for live reads. */
         snapshotAt: string | null;
     };
 }
+/** A provider ranking a platform-ranked list drew accounts from: its own label and read time. */
+export interface SocialPopularProfilesSource {
+    provider: {
+        name: string;
+        url: string;
+    };
+    ranking: string;
+    fetchedAt: string;
+    coverage: 'provider_ranked_window';
+}
 export interface SocialConversation {
     focus: SocialPost;
     /** Oldest available ancestor first, ending with the immediate parent. */
@@ -1967,6 +2240,13 @@ export declare class ProtocolsResource {
      * failure throws. Cacheable for a minute by a shared cache.
      */
     getSharedViral(projectId: string, params?: ViralReadParams, options?: SocialReadOptions): Promise<SingleResponse<ViralReadResponse>>;
+    /**
+     * 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: string, params: SharedCategorySurfaceParams, options?: SocialReadOptions): Promise<SingleResponse<SharedCategorySurface>>;
     publicNetworks(): Promise<SingleResponse<SocialNetwork[]>>;
     /** Query the live public network. It does not import users or posts. */
     searchPublicPosts(params: SearchPublicPostsParams): Promise<SingleResponse<SocialPostSearch>>;
@@ -2070,12 +2350,12 @@ export declare class ProtocolsResource {
      * no items; a 401 or 403 always throws (a session or key failure is never reported as off).
      */
     getPublicViral(params?: ViralReadParams, options?: SocialReadOptions): Promise<SingleResponse<ViralReadResponse>>;
-    /** Provider-ranked public accounts with explicit provenance; served from the app's index when a fresh snapshot exists. */
-    getPublicPopularProfiles(params: {
-        protocol: string;
-        limit?: number;
-        cursor?: string;
-    }): Promise<SingleResponse<SocialPopularProfiles>>;
+    /**
+     * 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: SocialPopularProfilesParams): Promise<SingleResponse<SocialPopularProfiles>>;
     /** Read this connected account's current native following; never infer it from a public count. */
     nativeFollowState(input: NativeFollowSourceInput): Promise<SingleResponse<NativeFollowState>>;
     /**
@@ -2085,7 +2365,7 @@ export declare class ProtocolsResource {
      */
     nativeFollowStates(input: Omit<NativeFollowSourceInput, 'accountId'>): Promise<SingleResponse<NativeFollowStates>>;
     /** Prepare a follow/unfollow for explicit approval. Preserve the mutation ID after a lost response. */
-    prepareNativeFollow(input: NativeFollowPrepareInput): Promise<SingleResponse<NativeFollowReview>>;
+    prepareNativeFollow(input: NativeFollowPrepareInput): Promise<SingleResponse<NativeFollowReview & EngageLinkedFields>>;
     /** Submit one approved action. Only Nostr supplies a public signed event. Automatic retries are disabled. */
     submitNativeFollow(id: string, input: {
         approve: true;
@@ -2096,7 +2376,7 @@ export declare class ProtocolsResource {
     /** Read this connected account's current native like; never infer it from a public count. */
     nativeLikeState(input: NativeLikeSourceInput): Promise<SingleResponse<NativeLikeState>>;
     /** Prepare a like/unlike for explicit approval. Preserve the mutation ID after a lost response. */
-    prepareNativeLike(input: NativeLikePrepareInput): Promise<SingleResponse<NativeLikeReview>>;
+    prepareNativeLike(input: NativeLikePrepareInput): Promise<SingleResponse<NativeLikeReview & EngageLinkedFields>>;
     /** Submit one approved action. Only Nostr supplies a public signed event. Automatic retries are disabled. */
     submitNativeLike(id: string, input: {
         approve: true;
@@ -2107,7 +2387,7 @@ export declare class ProtocolsResource {
     /** Read this connected account's current native repost; never infer it from a public count. */
     nativeRepostState(input: NativeRepostSourceInput): Promise<SingleResponse<NativeRepostState>>;
     /** Prepare a repost/unrepost for explicit approval. Preserve the mutation ID after a lost response. */
-    prepareNativeRepost(input: NativeRepostPrepareInput): Promise<SingleResponse<NativeRepostReview>>;
+    prepareNativeRepost(input: NativeRepostPrepareInput): Promise<SingleResponse<NativeRepostReview & EngageLinkedFields>>;
     /** Submit one approved action. Only Nostr supplies a public signed event. Automatic retries are disabled. */
     submitNativeRepost(id: string, input: {
         approve: true;
@@ -2116,7 +2396,7 @@ export declare class ProtocolsResource {
     /** Reconcile the saved action without sending another native write. */
     nativeRepostStatus(id: string): Promise<SingleResponse<NativeRepostReview>>;
     /** Prepare exact public text, reviewed images and an optional native quote for selected connected Bluesky/ActivityPub accounts. */
-    prepareNativePost(input: NativePostPrepareInput): Promise<SingleResponse<NativePostBatch>>;
+    prepareNativePost(input: NativePostPrepareInput): Promise<SingleResponse<NativePostBatch & EngageLinkedFields>>;
     /** Explicitly approve selected deliveries; never auto-retry an uncertain write. */
     submitNativePost(id: string, input: {
         approve: true;
@@ -2159,7 +2439,7 @@ export declare class ProtocolsResource {
         }>;
     }>>;
     /** Prepare one exact shared reply preview. Keep the mutation ID across uncertain responses. */
-    prepareNativeReply(input: NativeReplyPrepareInput): Promise<SingleResponse<NativeReplyBatch>>;
+    prepareNativeReply(input: NativeReplyPrepareInput): Promise<SingleResponse<NativeReplyBatch & EngageLinkedFields>>;
     /** Send only explicitly approved delivery IDs from this preview. Repeated submissions reconcile; they do not replay a write. */
     submitNativeReply(id: string, input: {
         approve: true;
@@ -2279,6 +2559,113 @@ export declare class ProtocolsResource {
      * `age_band_required`. Needs `users:write`.
      */
     setNetwork(network: NativeNetwork, input: SetNativeNetworkInput): Promise<SingleResponse<NativeNetworkActivation | NativeNetworkOff>>;
+    /**
+     * 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: NativeNetwork, engageDefault: EngageIdentity): Promise<SingleResponse<{
+        network: NativeNetwork;
+        engageDefault: EngageIdentity;
+        presence: NativeNetworkPresence | null;
+    }>>;
+    /**
+     * "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: AtprotoPasswordClaimProof): Promise<SingleResponse<AtprotoPasswordClaim>>;
+    /**
+     * "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: {
+        password: string;
+    }): Promise<SingleResponse<AtprotoGrant>>;
+    /** The member's one-tap actions waiting for their native identity to be set up, oldest first (0.7.191). Needs `users:read`. */
+    pendingInteractions(): Promise<SingleResponse<{
+        interactions: PendingNativeInteraction[];
+    }>>;
+    /**
+     * 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: EngageOneInput<'like' | 'unlike'>): Promise<SingleResponse<EngageAnswer<NativeLikeReview>>>;
+    /** One-tap repost or unrepost (0.7.191); answers as `engageLike` does (linked: submit with `submitNativeRepost`). */
+    engageRepost(input: EngageOneInput<'repost' | 'unrepost'>): Promise<SingleResponse<EngageAnswer<NativeRepostReview>>>;
+    /** One-tap follow or unfollow (0.7.191); answers as `engageLike` does (linked: submit with `submitNativeFollow`). */
+    engageFollow(input: EngageOneInput<'follow' | 'unfollow'>): Promise<SingleResponse<EngageAnswer<NativeFollowReview>>>;
+    /**
+     * 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: {
+        clientMutationId: string;
+        text: string;
+        parent: {
+            protocol: NativeWriteProtocol;
+            nativeId: string;
+            readRef?: string;
+        };
+        media?: NativeMediaInput[];
+        identity?: EngageIdentity;
+        accountIds?: string[];
+    }): Promise<SingleResponse<EngageAnswer<NativeReplyBatch>>>;
+    /**
+     * 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: {
+        clientMutationId: string;
+        text: string;
+        quote: {
+            protocol: NativeWriteProtocol;
+            nativeId: string;
+        };
+        media?: NativeMediaInput[];
+        identity?: EngageIdentity;
+        accountIds?: string[];
+    }): Promise<SingleResponse<EngageAnswer<NativePostBatch>>>;
+    /**
+     * 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: NostrKeyStepUp): Promise<SingleResponse<ManagedNostrKeyExport>>;
+    /** Step 2a: a single-use challenge for the member's signer to sign with the same key (NIP-07, never published). */
+    nostrRebindChallenge(): Promise<SingleResponse<NostrRebindChallenge>>;
+    /**
+     * 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: HostedNostrIdentityProof): Promise<SingleResponse<NostrRebindResult>>;
+    /**
+     * 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: NostrKeyStepUp): Promise<SingleResponse<ManagedNostrCopyDeleted>>;
     /** Current Minds-hosted ActivityPub state for this app user; never provisions. */
     federationIdentity(): Promise<SingleResponse<FederationIdentityView>>;
     /** Explicit opt-in; the platform provisions once and never rotates keys or re-enables a disabled identity on retry. */
@@ -2332,9 +2719,11 @@ export declare 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: CreateHostedIdentityInput): Promise<SingleResponse<CreatedHostedProtocolIdentity>>;
     disconnectHostedIdentity(id: string): Promise<SingleResponse<{