@recursiv/sdk 0.7.50 → 0.7.51

package/dist/resources/protocols.d.ts

@@ -248,6 +248,8 @@ export interface HostedNostrIdentityProof {
 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. */
+    crossPostOf?: string;
 } | {
     action: 'reply';
     content: string;
@@ -292,12 +294,27 @@ export interface SocialSourceRef {
     kind: 'actor' | 'post';
     nativeId: string;
 }
+/**
+ * How a controlled source last looked when Minds observed it on its network: the latest public
+ * observation, not a copy saved with the control. Null when it was never observed or has aged out.
+ */
+export interface SocialSourceControlDisplay {
+    handle: string | null;
+    displayName: string | null;
+    /** Null when the source, or a hidden post's author, is under an active app moderation action. */
+    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;
+    observedAt: string;
+}
 export interface SocialSourceControl {
     id: string;
     source: SocialSourceRef;
     control: 'block' | 'mute' | 'hide';
     scope: 'minds';
     createdAt: string;
+    /** Present on servers that label controls; null when the source has no recent observation. */
+    display?: SocialSourceControlDisplay | null;
 }
 export type SocialSourceControlChange = Omit<SocialSourceControl, 'id' | 'createdAt'> & {
     enabled: boolean;
@@ -377,6 +394,32 @@ export interface NativeFollowState extends NativeFollowReceipt {
     /** An earlier connection or another target profile has an unresolved attempt. Read again to reconcile; do not prepare a new write. */
     pendingActionBlocked: boolean;
 }
+/** One connected account on the source's network, as the account lists describe it. */
+export interface NativeFollowAccount {
+    id: string;
+    protocol: SocialSourceRef['protocol'];
+    nativeId: string;
+    handle: string;
+    serverUrl: string;
+    /** Includes `follow`/`unfollow` only when this account may follow here; otherwise offer a reconnect. */
+    capabilities: string[];
+}
+/** Every connected account's relationship with one source, from one read. */
+export interface NativeFollowStates {
+    protocol: SocialSourceRef['protocol'];
+    nativeId: string;
+    /** False when native follows are off for this app; accounts are still listed, and no state is read. */
+    enabled: boolean;
+    accounts: Array<{
+        account: NativeFollowAccount;
+        /** Null when the account cannot follow, follows are off, or its read failed (see `error`). */
+        state: NativeFollowState | null;
+        error: {
+            code: string;
+            message: string;
+        } | null;
+    }>;
+}
 export interface NativeFollowReview {
     id: string;
     clientMutationId: string;
@@ -624,6 +667,12 @@ export interface NativePostPrepareInput {
         protocol: 'bluesky';
         nativeId: string;
     };
+    /**
+     * Your own post in this app (sdk.posts, same app) that this publication copies. The server links
+     * them in the same write, so `nativePostHistory({ crossPostOf })` can list every copy when the post
+     * is deleted. Any other post answers not_found.
+     */
+    crossPostOf?: string;
 }
 export interface NativePostBatch {
     id: string;
@@ -643,14 +692,42 @@ export interface NativePostBatch {
         };
     }>;
 }
+export interface NativeDelegatedPostHistoryItem {
+    id: string;
+    createdAt: string;
+    text: string;
+    textTruncated: boolean;
+    deliveries: Array<Omit<NativePostBatch['deliveries'][number], 'text' | 'wireText' | 'maxCharacters'>>;
+    /** The post in this app this publication copies, when it was prepared with crossPostOf. */
+    crossPostOf?: string;
+}
+/**
+ * An original Nostr note the member signed in this app. Reopen it with
+ * `getNativeNostrPost(identityId, eventId)` and delete it with the Nostr signing flow
+ * (`prepareNativeNostr(identityId, { action: 'delete', postId: eventId })`), not the
+ * delegated removal methods. `receipt.state` becomes 'deletion_requested' once a
+ * deletion request is confirmed on the relay.
+ */
+export interface NativeNostrPostHistoryItem {
+    type: 'nostr';
+    id: string;
+    createdAt: string;
+    text: string;
+    textTruncated: boolean;
+    identityId: string;
+    pubkey: string;
+    relay: string;
+    eventId: string;
+    action: 'publish';
+    receipt: NativeNostrReceipt;
+    checkedAt: string | null;
+    lastReadBack: NativeNostrReceipt['readBack'];
+    /** The post in this app this note copies, when it was prepared with crossPostOf. */
+    crossPostOf?: string;
+}
 export interface NativePostHistory {
-    items: Array<{
-        id: string;
-        createdAt: string;
-        text: string;
-        textTruncated: boolean;
-        deliveries: Array<Omit<NativePostBatch['deliveries'][number], 'text' | 'wireText' | 'maxCharacters'>>;
-    }>;
+    /** Delegated Bluesky/ActivityPub posts and client-signed Nostr originals, newest first. */
+    items: Array<NativeDelegatedPostHistoryItem | NativeNostrPostHistoryItem>;
     cursor: string | null;
 }
 export interface NativeSocialCallbackInput {
@@ -712,6 +789,8 @@ export interface NativeNostrPrepared {
     relay: string;
     expiresAt: string;
     postId?: string;
+    /** The post in this app this note will be linked to on submit. */
+    crossPostOf?: string;
     parent?: {
         protocol: 'nostr';
         nativeId: string;
@@ -764,6 +843,21 @@ export interface NativeNostrReceipt {
     readBack: 'found' | 'absent' | 'unavailable';
     reason?: 'blocked' | 'rate_limited' | 'restricted' | 'invalid' | 'relay_error';
 }
+/**
+ * Ask the app's own PDS to issue a Bluesky account. Only the label is sent: the
+ * app decides the domain (`alice` becomes `alice.pds.minds.com` on a test lane,
+ * `alice.minds.com` once handles move).
+ */
+export interface CreateHostedIdentityInput {
+    protocol: 'atproto';
+    /** One lowercase label of 3 to 18 characters (the PDS's own bounds): letters, digits and inner hyphens. */
+    handle: string;
+    email: string;
+}
+/** The new identity, with the member's password: returned this once and stored nowhere. */
+export interface CreatedHostedProtocolIdentity extends HostedProtocolIdentity {
+    password: string;
+}
 export type ConnectHostedIdentityInput = {
     protocol: 'atproto';
     identifier: string; /** Prefer a native app password. Used once, never stored. */
@@ -940,6 +1034,16 @@ export interface SocialTrend {
     /** A real image-bearing post from this topic, filtered by current source controls. */
     preview?: SocialPost;
 }
+/**
+ * Present only on category pages of a feed the app's open-network source index serves (ActivityPub
+ * and Nostr): the provider's posts come first, then posts the index judged into the category. The
+ * page's `cursor` (it starts with `idx:`) carries both positions; pass it back unchanged like any other cursor.
+ */
+export interface SocialTrendSourceIndex {
+    /** Posts on this page that came from the index rather than the provider's ranking. */
+    served: number;
+    coverage: 'source_index';
+}
 export type SocialTrends = SocialTrendProvenance & ({
     kind: 'topics';
     items: SocialTrend[];
@@ -948,6 +1052,10 @@ export type SocialTrends = SocialTrendProvenance & ({
     kind: 'posts';
     items: SocialPost[];
     cursor: string | null;
+    sourceIndex?: SocialTrendSourceIndex;
+    safetyFilter?: {
+        withheld: number;
+    };
 });
 export interface SocialTrendFeed extends SocialTrendProvenance {
     trend: SocialTrend;
@@ -1057,6 +1165,18 @@ export interface SocialRadarPosts {
     builtAt: string | null;
     items: SocialPost[];
 }
+/**
+ * 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).
+ */
+export interface SocialRadarStory {
+    id: string;
+    builtAt: string | null;
+    status: 'live' | 'aged_out' | 'unknown';
+    cluster: SocialRadarCluster | null;
+    items: SocialPost[];
+}
 /** Read options for callers that hold their own deadline, such as a discovery page. */
 export interface SocialReadOptions {
     retry?: boolean;
@@ -1155,6 +1275,14 @@ export declare class ProtocolsResource {
     }): Promise<SingleResponse<SocialTrendFeed>>;
     /** Breaking and viral stories clustered across outlets, open networks and Minds, through the same public-only app boundary. */
     getSharedRadar(projectId: string, params?: SocialRadarParams): Promise<SingleResponse<SocialRadar>>;
+    /** One radar story's social member posts without a key, so a signed-out story card can show the posts it counts. */
+    getSharedRadarPosts(projectId: string, params: {
+        cluster: string;
+    }): Promise<SingleResponse<SocialRadarPosts>>;
+    /** One radar story by id with its posts, without a key: a story page or shared link in one call. */
+    getSharedRadarStory(projectId: string, params: {
+        cluster: string;
+    }): Promise<SingleResponse<SocialRadarStory>>;
     publicNetworks(): Promise<SingleResponse<SocialNetwork[]>>;
     /** Query the live public network. It does not import users or posts. */
     searchPublicPosts(params: SearchPublicPostsParams): Promise<SingleResponse<SocialPostSearch>>;
@@ -1210,6 +1338,10 @@ export declare class ProtocolsResource {
     getPublicRadarPosts(params: {
         cluster: string;
     }, options?: SocialReadOptions): Promise<SingleResponse<SocialRadarPosts>>;
+    /** One radar story by id with its posts under the app's own key; `status` tells an aged-out story from an unknown one. */
+    getPublicRadarStory(params: {
+        cluster: string;
+    }, options?: SocialReadOptions): Promise<SingleResponse<SocialRadarStory>>;
     /** Provider-ranked public accounts with explicit provenance; served from the app's index when a fresh snapshot exists. */
     getPublicPopularProfiles(params: {
         protocol: string;
@@ -1218,6 +1350,12 @@ export declare class ProtocolsResource {
     }): Promise<SingleResponse<SocialPopularProfiles>>;
     /** Read this connected account's current native following; never infer it from a public count. */
     nativeFollowState(input: NativeFollowSourceInput): Promise<SingleResponse<NativeFollowState>>;
+    /**
+     * The viewer's connected accounts on a source's network and each one's follow state, in one read,
+     * so a profile's Follow control is ready after one round trip instead of listing accounts first.
+     * Resume any `pendingActionId` with `nativeFollowStatus`; never start a duplicate action.
+     */
+    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>>;
     /** Submit one approved action. Only Nostr supplies a public signed event. Automatic retries are disabled. */
@@ -1263,10 +1401,17 @@ export declare class ProtocolsResource {
     }>>;
     /** Read the signed-in owner's saved publication review and durable receipts. */
     nativePostStatus(id: string): Promise<SingleResponse<NativePostBatch>>;
-    /** Page the current app user's standalone publication history. This never sends. */
+    /**
+     * Page the current app user's standalone publication history. This never sends.
+     * Items are delegated Bluesky/ActivityPub posts and client-signed Nostr originals (`type: 'nostr'`,
+     * no `deliveries`); the server lists the Nostr ones only for clients that ask, as this method does.
+     * With `crossPostOf`, only the network copies of that post in this app: delete each with
+     * prepareNativePostRemoval/removeNativePost, or the Nostr signing flow for a `type: 'nostr'` item.
+     */
     nativePostHistory(params?: {
         limit?: number;
         cursor?: string;
+        crossPostOf?: string;
     }): Promise<SingleResponse<NativePostHistory>>;
     /** Review the current own posts before approving removal. */
     prepareNativePostRemoval(id: string, input: {
@@ -1325,11 +1470,17 @@ export declare class ProtocolsResource {
     nativeSocialAccounts(): Promise<SingleResponse<{
         enabled: boolean;
         accounts: NativeSocialAccount[];
+        /** Protocols this app can connect with `redirect: 'native'`. Empty when no native callback is configured. */
+        nativeRedirects?: NativeSocialProtocol[];
     }>>;
-    /** Private source controls in this app, with bounded pagination. */
+    /**
+     * Private source controls in this app, with bounded pagination. Pass `control` to list only
+     * blocks, mutes or hidden posts; each item may carry a `display` label for the settings list.
+     */
     sourceControls(params?: {
         limit?: number;
         cursor?: string;
+        control?: SocialSourceControl['control'];
     }): Promise<SingleResponse<{
         enabled: boolean;
         items: SocialSourceControl[];
@@ -1356,13 +1507,22 @@ export declare class ProtocolsResource {
         existing: boolean;
         scope: 'minds';
     }>>;
-    /** Open the returned authorization URL in the user's browser; never submit passwords or tokens. */
+    /**
+     * Open the returned authorization URL in the user's browser; never submit passwords or tokens.
+     * In a native app pass `redirect: 'native'` (when `nativeSocialAccounts().nativeRedirects` lists the
+     * protocol) and open an in-app auth session on `callbackUrl`, e.g. expo-web-browser's
+     * `openAuthSessionAsync(authorizationUrl, callbackUrl)`; then pass the returned `state`, `code`,
+     * `iss` or `error` query values to `finishNativeSocialConnection`.
+     */
     startNativeSocialConnection(input: {
         protocol: NativeSocialProtocol;
         identifier: string;
+        redirect?: 'web' | 'native';
     }): Promise<SingleResponse<{
         protocol: NativeSocialProtocol;
         authorizationUrl: string;
+        /** Where the provider returns: the app's web callback, or its operator-configured native callback. */
+        callbackUrl: string;
     }>>;
     /** Complete a single-use callback with the same signed-in app user. Remove its query from browser history; do not log codes. */
     finishNativeSocialConnection(input: NativeSocialCallbackInput): Promise<SingleResponse<NativeSocialAccount>>;
@@ -1414,6 +1574,21 @@ export declare class ProtocolsResource {
     /** Request a short-lived, single-use proof bound to this app, account and relay. */
     hostedNostrChallenge(): Promise<SingleResponse<HostedNostrChallenge>>;
     connectHostedIdentity(input: ConnectHostedIdentityInput): Promise<SingleResponse<HostedProtocolIdentity>>;
+    /**
+     * Create a Bluesky account for the signed-in member on the app's own PDS.
+     *
+     * The response carries the member's password exactly once; show it to them and
+     * keep it nowhere. The server either finishes the account or removes it again,
+     * so a failure leaves nothing half made. Never retried automatically: a replay
+     * after a lost response could not return the password a second time.
+     *
+     * 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.
+     */
+    createHostedIdentity(input: CreateHostedIdentityInput): Promise<SingleResponse<CreatedHostedProtocolIdentity>>;
     disconnectHostedIdentity(id: string): Promise<SingleResponse<{
         disconnected: true;
     }>>;

package/dist/resources/protocols.js

@@ -103,6 +103,14 @@ export class ProtocolsResource {
     getSharedRadar(projectId, params = {}) {
         return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/radar`, radarQuery(params));
     }
+    /** One radar story's social member posts without a key, so a signed-out story card can show the posts it counts. */
+    getSharedRadarPosts(projectId, params) {
+        return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/radar/posts`, { cluster: params.cluster });
+    }
+    /** One radar story by id with its posts, without a key: a story page or shared link in one call. */
+    getSharedRadarStory(projectId, params) {
+        return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/radar/story`, { cluster: params.cluster });
+    }
     publicNetworks() {
         return this.client.get('/protocols/social/networks');
     }
@@ -161,6 +169,10 @@ export class ProtocolsResource {
     getPublicRadarPosts(params, options) {
         return this.client.get('/protocols/social/radar/posts', { cluster: params.cluster }, ...readOptions(options));
     }
+    /** One radar story by id with its posts under the app's own key; `status` tells an aged-out story from an unknown one. */
+    getPublicRadarStory(params, options) {
+        return this.client.get('/protocols/social/radar/story', { cluster: params.cluster }, ...readOptions(options));
+    }
     /** Provider-ranked public accounts with explicit provenance; served from the app's index when a fresh snapshot exists. */
     getPublicPopularProfiles(params) {
         return this.client.get('/protocols/social/popular-profiles', { protocol: params.protocol, limit: params.limit, cursor: params.cursor });
@@ -169,6 +181,14 @@ export class ProtocolsResource {
     nativeFollowState(input) {
         return this.client.get('/protocols/social/follows/state', { accountId: input.accountId, protocol: input.protocol, nativeId: input.nativeId });
     }
+    /**
+     * The viewer's connected accounts on a source's network and each one's follow state, in one read,
+     * so a profile's Follow control is ready after one round trip instead of listing accounts first.
+     * Resume any `pendingActionId` with `nativeFollowStatus`; never start a duplicate action.
+     */
+    nativeFollowStates(input) {
+        return this.client.get('/protocols/social/follows/states', { protocol: input.protocol, nativeId: input.nativeId });
+    }
     /** Prepare a follow/unfollow for explicit approval. Preserve the mutation ID after a lost response. */
     prepareNativeFollow(input) {
         return this.client.post('/protocols/social/follows/prepare', { clientMutationId: input.clientMutationId, accountId: input.accountId,
@@ -236,7 +256,8 @@ export class ProtocolsResource {
         return this.client.post('/protocols/social/posts/prepare', { clientMutationId: input.clientMutationId,
             text: input.text, accountIds: input.accountIds,
             ...(input.quote ? { quote: { protocol: input.quote.protocol, nativeId: input.quote.nativeId } } : {}),
-            ...(input.media !== undefined ? { media: nativeMediaInput(input.media) } : {}) }, { retry: false });
+            ...(input.media !== undefined ? { media: nativeMediaInput(input.media) } : {}),
+            ...(input.crossPostOf !== undefined ? { crossPostOf: input.crossPostOf } : {}) }, { retry: false });
     }
     /** Explicitly approve selected deliveries; never auto-retry an uncertain write. */
     submitNativePost(id, input) {
@@ -248,9 +269,16 @@ export class ProtocolsResource {
         hostedIdentityPath(id);
         return this.client.get(`/protocols/social/posts/${encodeURIComponent(id)}`);
     }
-    /** Page the current app user's standalone publication history. This never sends. */
+    /**
+     * Page the current app user's standalone publication history. This never sends.
+     * Items are delegated Bluesky/ActivityPub posts and client-signed Nostr originals (`type: 'nostr'`,
+     * no `deliveries`); the server lists the Nostr ones only for clients that ask, as this method does.
+     * With `crossPostOf`, only the network copies of that post in this app: delete each with
+     * prepareNativePostRemoval/removeNativePost, or the Nostr signing flow for a `type: 'nostr'` item.
+     */
     nativePostHistory(params = {}) {
-        return this.client.get('/protocols/social/posts', { limit: params.limit, cursor: params.cursor });
+        return this.client.get('/protocols/social/posts', { limit: params.limit, cursor: params.cursor,
+            ...(params.crossPostOf !== undefined ? { crossPostOf: params.crossPostOf } : {}), include: 'nostr' });
     }
     /** Review the current own posts before approving removal. */
     prepareNativePostRemoval(id, input) {
@@ -300,9 +328,13 @@ export class ProtocolsResource {
     nativeSocialAccounts() {
         return this.client.get('/protocols/social/accounts');
     }
-    /** Private source controls in this app, with bounded pagination. */
+    /**
+     * Private source controls in this app, with bounded pagination. Pass `control` to list only
+     * blocks, mutes or hidden posts; each item may carry a `display` label for the settings list.
+     */
     sourceControls(params = {}) {
-        return this.client.get('/protocols/social/controls', { limit: params.limit, cursor: params.cursor });
+        return this.client.get('/protocols/social/controls', { limit: params.limit, cursor: params.cursor,
+            ...(params.control ? { control: params.control } : {}) });
     }
     /** Block/mute an actor or hide a post in Minds. This does not impersonate a native network block. */
     async setSourceControl(input) {
@@ -328,9 +360,17 @@ export class ProtocolsResource {
         return this.client.post('/protocols/social/reports', { source: { protocol: input.source.protocol, kind: input.source.kind, nativeId: input.source.nativeId },
             readRef: input.readRef, ...(input.accountId ? { accountId: input.accountId } : {}), reason: input.reason, details: input.details, scope: input.scope }, { retry: false });
     }
-    /** Open the returned authorization URL in the user's browser; never submit passwords or tokens. */
+    /**
+     * Open the returned authorization URL in the user's browser; never submit passwords or tokens.
+     * In a native app pass `redirect: 'native'` (when `nativeSocialAccounts().nativeRedirects` lists the
+     * protocol) and open an in-app auth session on `callbackUrl`, e.g. expo-web-browser's
+     * `openAuthSessionAsync(authorizationUrl, callbackUrl)`; then pass the returned `state`, `code`,
+     * `iss` or `error` query values to `finishNativeSocialConnection`.
+     */
     startNativeSocialConnection(input) {
-        return this.client.post('/protocols/social/oauth/start', { protocol: input.protocol, identifier: input.identifier }, { retry: false });
+        return this.client.post('/protocols/social/oauth/start', { protocol: input.protocol, identifier: input.identifier,
+            // Only the choice between operator-configured callbacks is sent; a callback URL never is.
+            ...(input.redirect === 'native' ? { redirect: 'native' } : {}) }, { retry: false });
     }
     /** Complete a single-use callback with the same signed-in app user. Remove its query from browser history; do not log codes. */
     finishNativeSocialConnection(input) {
@@ -362,7 +402,8 @@ export class ProtocolsResource {
     /** Prepare an exact event for review. A timeout never automatically creates another signing request. */
     prepareNativeNostr(id, input) {
         hostedIdentityPath(id);
-        const body = input.action === 'publish' ? { action: input.action, content: input.content }
+        const body = input.action === 'publish' ? { action: input.action, content: input.content,
+            ...(input.crossPostOf !== undefined ? { crossPostOf: input.crossPostOf } : {}) }
             : input.action === 'reply' ? { action: input.action, content: input.content, parentId: input.parentId }
                 : input.action === 'linked_post' ? { action: input.action, content: input.content,
                     source: { protocol: input.source.protocol, nativeId: input.source.nativeId,
@@ -425,6 +466,24 @@ export class ProtocolsResource {
     connectHostedIdentity(input) {
         return this.client.post('/protocols/identities', input);
     }
+    /**
+     * Create a Bluesky account for the signed-in member on the app's own PDS.
+     *
+     * The response carries the member's password exactly once; show it to them and
+     * keep it nowhere. The server either finishes the account or removes it again,
+     * so a failure leaves nothing half made. Never retried automatically: a replay
+     * after a lost response could not return the password a second time.
+     *
+     * 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.
+     */
+    createHostedIdentity(input) {
+        const { protocol, handle, email } = input;
+        return this.client.post('/protocols/identities/create', { protocol, handle, email }, { retry: false });
+    }
     async disconnectHostedIdentity(id) {
         return this.client.delete(hostedIdentityPath(id));
     }

package/dist/resources/settings.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { ChangePasswordInput, DeletionStatus, LoginHistoryEntry, PaginatedResponse, RequestEmailChangeInput, Session, SingleResponse, SuccessResponse, UpdateAppearanceInput, UpdateContentPreferencesInput, UpdateNotificationChannelsInput, UpdatePrivacyInput, UserPreferences } from '../types.js';
+import type { ChangePasswordInput, ConfirmationCodePurpose, ConfirmationCodeSent, DeletionStatus, LoginHistoryEntry, PaginatedResponse, RequestEmailChangeInput, RevokeOtherSessionsInput, RevokeOtherSessionsResult, Session, SingleResponse, SuccessResponse, UpdateAppearanceInput, UpdateContentPreferencesInput, UpdateNotificationChannelsInput, UpdatePrivacyInput, UserPreferences } from '../types.js';
 export declare class SettingsResource {
     private client;
     constructor(client: HttpClient);
@@ -29,11 +29,33 @@ export declare class SettingsResource {
     listSessions(): Promise<SingleResponse<Session[]>>;
     /** Revoke a specific session */
     revokeSession(sessionId: string): Promise<SuccessResponse>;
-    /** Revoke all sessions */
+    /**
+     * Revoke every session AND every API key of the account, including the key
+     * this client uses: after it resolves, this client is signed out too. For
+     * "sign out of all other devices", use `revokeOtherSessions`.
+     */
     revokeAllSessions(): Promise<SuccessResponse>;
+    /**
+     * Sign out of all other devices. Revokes every Better Auth session and the
+     * account's other API keys, and keeps this device: the calling key always
+     * survives, and so does the session named by `keep_session_token`. An
+     * app-bound key only revokes that app's keys.
+     */
+    revokeOtherSessions(input?: RevokeOtherSessionsInput): Promise<SingleResponse<RevokeOtherSessionsResult>>;
     /** Change password */
     changePassword(input: ChangePasswordInput): Promise<SuccessResponse>;
-    /** Request email change */
+    /**
+     * 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.
+     */
+    requestConfirmationCode(purpose: ConfirmationCodePurpose): Promise<SingleResponse<ConfirmationCodeSent>>;
+    /**
+     * Request email change. Confirm with `password`, or with `email_code` for an
+     * account that has no password.
+     */
     requestEmailChange(input: RequestEmailChangeInput): Promise<SingleResponse<{
         success: true;
         token?: string;

package/dist/resources/settings.js

@@ -59,16 +59,42 @@ export class SettingsResource {
     revokeSession(sessionId) {
         return this.client.delete(`/settings/sessions/${sessionId}`);
     }
-    /** Revoke all sessions */
+    /**
+     * Revoke every session AND every API key of the account, including the key
+     * this client uses: after it resolves, this client is signed out too. For
+     * "sign out of all other devices", use `revokeOtherSessions`.
+     */
     revokeAllSessions() {
         return this.client.delete('/settings/sessions');
     }
+    /**
+     * Sign out of all other devices. Revokes every Better Auth session and the
+     * account's other API keys, and keeps this device: the calling key always
+     * survives, and so does the session named by `keep_session_token`. An
+     * app-bound key only revokes that app's keys.
+     */
+    revokeOtherSessions(input = {}) {
+        return this.client.post('/settings/sessions/revoke-others', input);
+    }
     // ── Account Security ──
     /** Change password */
     changePassword(input) {
         return this.client.put('/settings/password', input);
     }
-    /** Request email change */
+    /**
+     * 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.
+     */
+    requestConfirmationCode(purpose) {
+        return this.client.post('/settings/confirmation-code', { purpose });
+    }
+    /**
+     * Request email change. Confirm with `password`, or with `email_code` for an
+     * account that has no password.
+     */
     requestEmailChange(input) {
         return this.client.post('/settings/email-change', input);
     }

package/dist/resources/video.d.ts

@@ -27,6 +27,17 @@ export interface VideoPlaybackToken {
     token: string;
     expires: number;
 }
+/** Whether the caller may publish video in this app, and how much storage is left. */
+export interface VideoEntitlement {
+    allowed: boolean;
+    /** The caller's active app-subscription tier ('free' when none, canceled or past due). */
+    tier: string;
+    /** Why video is not allowed: a tier without video, or a used-up quota. */
+    reason?: 'tier' | 'quota';
+    quotaSeconds: number;
+    usedSeconds: number;
+    remainingSeconds: number;
+}
 /**
  * Video primitive. Upload is gated by the caller's paid tier + storage quota
  * (so apps stay profitable); viewing is open with a signed playback URL.
@@ -34,6 +45,14 @@ export interface VideoPlaybackToken {
 export declare class VideoResource {
     private client;
     constructor(client: HttpClient);
+    /**
+     * The check `createUpload` runs, without starting an upload: lets a composer
+     * gate or explain video before the member picks a file. Needs an app-bound
+     * key with `uploads:write`.
+     */
+    entitlement(): Promise<{
+        data: VideoEntitlement;
+    }>;
     /** Begin an upload. Returns Bunny direct-upload creds + the playbackId to attach to a post. */
     createUpload(input?: {
         title?: string;

package/dist/resources/video.js

@@ -7,6 +7,14 @@ export class VideoResource {
     constructor(client) {
         this.client = client;
     }
+    /**
+     * The check `createUpload` runs, without starting an upload: lets a composer
+     * gate or explain video before the member picks a file. Needs an app-bound
+     * key with `uploads:write`.
+     */
+    entitlement() {
+        return this.client.get('/video/entitlement');
+    }
     /** Begin an upload. Returns Bunny direct-upload creds + the playbackId to attach to a post. */
     createUpload(input) {
         return this.client.post('/video/create-upload', input ?? {});

package/dist/resources/wallet.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { SingleResponse } from '../types.js';
+import type { PaginatedResponse, SingleResponse } from '../types.js';
 interface WalletInfo {
     configured: boolean;
     address: string | null;
@@ -37,6 +37,39 @@ export interface PayoutState {
     payouts_enabled: boolean;
     country: string | null;
 }
+/** A wallet the user linked and (optionally) verified. */
+export interface LinkedTokenWallet {
+    chain: string;
+    address: string;
+    verified_at: string | null;
+}
+/** The user's MINDS token balance from the off-chain ledger. */
+export interface TokenBalance {
+    /** Signed wei as a decimal string: it exceeds Number.MAX_SAFE_INTEGER, never parse it as a number. */
+    offchain_wei: string;
+    /** The same balance in MINDS, rounded to 6 decimal places. Display only. */
+    offchain_minds: number;
+    /** How many off-chain ledger entries make up the balance. */
+    entries: number;
+    linked_wallets: LinkedTokenWallet[];
+    base_wallet_address: string | null;
+}
+/** One token ledger movement. */
+export interface TokenLedgerEntry {
+    id: string;
+    category: string | null;
+    /** Signed wei as a decimal string. */
+    amount_wei: string;
+    amount_minds: number;
+    asset: string;
+    settlement: string;
+    tx_hash: string | null;
+    counterparty_user_id: string | null;
+    subject_type: string | null;
+    subject_id: string | null;
+    status: string;
+    occurred_at: string;
+}
 export declare class WalletResource {
     private client;
     constructor(client: HttpClient);
@@ -44,6 +77,13 @@ export declare class WalletResource {
     getMyWallet(): Promise<SingleResponse<WalletInfo>>;
     /** Get wallet balance for the current user */
     getBalance(): Promise<SingleResponse<WalletBalance>>;
+    /** The current user's MINDS token balance (off-chain ledger) and linked wallets. */
+    getTokenBalance(): Promise<SingleResponse<TokenBalance>>;
+    /** The current user's token ledger, newest first (limit up to 200, default 50). */
+    getTokenLedger(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<PaginatedResponse<TokenLedgerEntry>>;
     /** USD payout eligibility for the current app user (Stripe Connect). */
     getPayouts(): Promise<SingleResponse<PayoutState>>;
     /** Start or resume payout onboarding. Open the returned URL in a browser. */