@sublay/js 7.7.0 → 7.8.0

package/dist/index.d.mts

@@ -184,14 +184,182 @@ interface SignInResponse {
 }
 declare function signIn(client: SublayHttpClient, data: SignInProps): Promise<SignInResponse>;
 
+/**
+ * Every push event type — the full app-notification type set plus the chat
+ * `message` event (push-only). Mirrors the server's `PUSH_EVENT_TYPES` exactly
+ * (server `src/constants/push/pushEvents.ts`); these are the only names a
+ * `disabledTypes` set may contain.
+ */
+declare const PUSH_EVENT_TYPES: readonly ["entity-comment", "comment-reply", "entity-mention", "comment-mention", "entity-reaction", "comment-reaction", "entity-reaction-milestone-specific", "entity-reaction-milestone-total", "comment-reaction-milestone-specific", "comment-reaction-milestone-total", "new-follow", "connection-request", "connection-accepted", "space-membership-approved", "event-invite", "event-updated", "event-cancelled", "message"];
+type PushEventType = (typeof PUSH_EVENT_TYPES)[number];
+/**
+ * The four conversation-mute duration choices. Send the CHOICE, never a raw
+ * timestamp — the server resolves it and represents "forever" via the explicit
+ * `mutedForever` signal on the returned member. Mirrors the server's
+ * `MUTE_DURATIONS` (server `src/helpers/push/muteDuration.ts`).
+ */
+declare const MUTE_DURATIONS: readonly ["8h", "24h", "1w", "forever"];
+type MuteDuration = (typeof MUTE_DURATIONS)[number];
+/** Response of read/update notification preferences. */
+interface NotificationPreferences {
+    disabledTypes: PushEventType[];
+}
+/**
+ * A Web Push subscription in its SERIALIZED form — the JSON the server reads,
+ * not the live browser object.
+ *
+ * A `PushSubscription` straight from `PushManager.subscribe()` does NOT satisfy
+ * this type. It exposes its keys only through `getKey(name)`; there is no `keys`
+ * property to read, so it is not assignable here under strict TypeScript, and
+ * passing one through a cast sends a body the server rejects.
+ *
+ * To produce a value of this type:
+ *
+ * 1. **Serialize** the subscription with `subscription.toJSON()`.
+ * 2. **Confirm** `endpoint`, `keys.p256dh` and `keys.auth` are all present —
+ *    `PushSubscriptionJSON` types every one of them as optional, while the
+ *    server requires all three as non-empty strings and 400s otherwise.
+ *
+ * ```ts
+ * const json = subscription.toJSON();
+ * if (!json.endpoint || !json.keys?.p256dh || !json.keys?.auth) {
+ *   throw new Error("Incomplete Web Push subscription");
+ * }
+ * const webPushSubscription: WebPushSubscription = {
+ *   endpoint: json.endpoint,
+ *   keys: { p256dh: json.keys.p256dh, auth: json.keys.auth },
+ * };
+ * ```
+ *
+ * Mirrors the server's `webPushSubscriptionSchema`
+ * (server `src/v7/validation/push-notifications/push-notifications.schema.ts`).
+ */
+interface WebPushSubscription {
+    endpoint: string;
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+}
+/**
+ * Identifies one physical device. Mirrors the server's device-identifier body
+ * exactly (server `src/v7/validation/push-notifications/push-notifications.schema.ts`):
+ * a provider token for `ios`/`android`, a Web Push subscription for `web`. The
+ * union encodes the server's own cross-check — it rejects the same
+ * combinations the server's `superRefine` rejects.
+ *
+ * Passed to `auth.signOut` to unbind that device's push binding in the same
+ * transaction as the sign-out.
+ */
+type PushDeviceIdentifier = {
+    platform: "ios" | "android";
+    token: string;
+} | {
+    platform: "web";
+    subscription: WebPushSubscription;
+};
+
 interface SignOutProps {
     /**
      * Defaults to the SDK's stored refresh token (SDK-managed mode). Pass it
      * explicitly in host-managed mode, where the SDK holds no refresh token.
      */
     refreshToken?: string;
+    /**
+     * Optional. When supplied — and the project has the `push` bundle — the
+     * server deletes this user's push binding for that device in the SAME
+     * transaction as the token-family destroy: signing out unbinds the device's
+     * push, or nothing happens at all.
+     *
+     * **Needs a refresh token to have any effect.** The unbind is scoped to the
+     * `sub` of the refresh token, which is what stops one account removing
+     * another account's binding on a shared device — so with no token there is no
+     * user to scope it to and the server answers `204` before it ever looks at
+     * `pushDevice`. When none can be resolved the field is DROPPED from the
+     * request rather than sent into that silent no-op, the sign-out proceeds
+     * normally, and the returned `pushUnbindSkipped` says so. Watch for it in
+     * **host-managed mode**: such a client is built with `getToken` and no
+     * `initialTokens`, and its `setTokens` is inert, so it starts with no refresh
+     * token and can never acquire one. Pass `refreshToken` explicitly alongside
+     * `pushDevice` there.
+     *
+     * If the unbind fails the request fails (HTTP 500, code
+     * `auth/device-deregistration-failed` or `auth/sign-out-failed`) and NOTHING
+     * is committed — the session survives so the caller can retry, and this call
+     * rethrows WITHOUT clearing the SDK's local tokens, so the credential that
+     * retry needs is still there.
+     *
+     * That is the ONLY failure that leaves you signed in. Every other one — a
+     * `429` from the rate limiter or a quota gate, a `423`, a `503`, a `400` on
+     * the body, a dropped connection — never touched a push binding, so it
+     * clears the local tokens and RESOLVES: a user must always be able to sign
+     * out. See `UNBIND_FAILURE_CODES`.
+     *
+     * Omit it and the request is byte-identical to before this field existed.
+     */
+    pushDevice?: PushDeviceIdentifier;
 }
-declare function signOut(client: SublayHttpClient, data?: SignOutProps): Promise<void>;
+/**
+ * Why the unbind did not happen. Present only when `pushUnbindSkipped` is
+ * `true`, and it exists because THE TWO SKIPS ARE RECOVERED DIFFERENTLY — a
+ * caller that cannot tell them apart can only ever pick the wrong remedy for
+ * one of them:
+ *
+ * - `no-refresh-token` — this SDK never asked. Nothing was destroyed either:
+ *   with no token the server has no session to end, so the account, its
+ *   credential and its binding are all still there. **Retryable**: re-issue
+ *   the sign-out with an explicit `refreshToken` and the unbind happens.
+ * - `push-unbind-status-unknown` — the server was asked and could not answer.
+ *   The sign-out itself DID commit, so the credential that would have driven a
+ *   retry is gone; re-issuing achieves nothing. The binding clears when that
+ *   account next registers on this device, or when the server prunes the token
+ *   as undeliverable.
+ */
+type PushUnbindSkipReason = "no-refresh-token" | "push-unbind-status-unknown";
+interface SignOutResult {
+    /**
+     * `true` whenever a `pushDevice` was supplied and the unbind did NOT happen,
+     * so this device's push binding for that account may still be live. Either
+     * the SDK declined to ask (no refresh token to scope the unbind to) or the
+     * server could not answer whether a binding exists; `pushUnbindSkipReason`
+     * says which, and the two are recovered differently.
+     *
+     * `false` means NO SKIP WAS REPORTED — by this SDK or by the server. It is
+     * not a promise that no skip happened, and the difference is not academic:
+     * the server declines the unbind for several reasons it answers with a plain
+     * `204`, and every one of them reads `false` here.
+     *
+     *   - The refresh token is authentic but expired beyond the server's unbind
+     *     window (90 days past `exp`), so there is no subject to scope the unbind
+     *     to. Reachable from this SDK by passing an old `refreshToken` explicitly
+     *     alongside `pushDevice`.
+     *   - The refresh token is malformed or fails signature verification.
+     *   - The project has no `push` bundle, so no binding can exist.
+     *   - The unbind ran and matched zero rows — the binding was already gone, or
+     *     was never registered under this device key.
+     *
+     * The server logs each of those under its own reason; only the case where it
+     * could not determine whether a binding exists is reported in the response,
+     * because that is the one where the binding may still be LIVE and nobody
+     * looked. The rest either prove there was nothing to remove or leave a device
+     * key the server cannot attribute to a user, and neither gives the caller
+     * anything to act on beyond what it already knows.
+     *
+     * A request that failed short of an unbind attempt reads `false` too — a
+     * gate's `429` or `423`, a `503`, a `400`, a dropped connection. Those clear
+     * the local tokens and resolve rather than reject (see `UNBIND_FAILURE_CODES`
+     * for why), and none of them is a REPORTED skip; they are logged with a
+     * warning instead.
+     *
+     * The sign-out itself is unaffected by the flag in both directions: a user
+     * must always be able to sign out, so a skipped unbind never fails the call
+     * and never leaves the local tokens in place.
+     */
+    pushUnbindSkipped: boolean;
+    /** Set only when `pushUnbindSkipped` is `true`. See `PushUnbindSkipReason`. */
+    pushUnbindSkipReason?: PushUnbindSkipReason;
+}
+declare function signOut(client: SublayHttpClient, data?: SignOutProps): Promise<SignOutResult>;
 
 interface RequestNewAccessTokenProps {
     /** Defaults to the SDK's stored refresh token (SDK-managed mode). */
@@ -234,11 +402,33 @@ interface ChangePasswordProps {
     /** The user's current password (verified before the change). */
     password: string;
     newPassword: string;
+    /**
+     * Optional. The physical device making this call.
+     *
+     * A password change also deletes every push binding the user holds, so an
+     * intruder's device stops receiving notification content. Naming this device
+     * keeps ITS binding — nothing re-binds a device from its live session, so
+     * without this the handset the user just changed their password on goes
+     * quiet until the app cold-starts or switches accounts.
+     *
+     * Same value passed to `push.register` / `auth.signOut`. Omit it and every
+     * binding for the user goes, this device included.
+     */
+    pushDevice?: PushDeviceIdentifier;
 }
 interface ChangePasswordResponse {
     success: boolean;
     message: string;
 }
+/**
+ * Change the signed-in user's password.
+ *
+ * Ends every OTHER session for that user — every other device must sign in
+ * again with the new password — while the session making this call survives.
+ * The server identifies that session from the access token this request is
+ * already authenticated with, so nothing about the caller's session has to be
+ * sent.
+ */
 declare function changePassword(client: SublayHttpClient, data: ChangePasswordProps): Promise<ChangePasswordResponse>;
 
 interface SetPasswordProps {
@@ -1607,7 +1797,10 @@ declare function fetchCommentByForeignId(client: SublayHttpClient, data: FetchCo
 
 interface UpdateCommentProps {
     commentId: string;
-    content: string;
+    /** New text content. Cannot be empty. Omit to leave the content untouched. */
+    content?: string;
+    /** Replaces the comment's metadata wholesale (not merged). */
+    metadata?: Record<string, any>;
 }
 declare function updateComment(client: SublayHttpClient, data: UpdateCommentProps): Promise<Comment>;
 
@@ -1749,6 +1942,12 @@ interface FetchUserSpacesProps {
     include?: string;
     role?: string;
     all?: "true" | "false";
+    /**
+     * Membership status to list. Defaults to `"active"` (spaces the user is in);
+     * `"pending"` returns join requests awaiting approval, `"banned"` the spaces
+     * they were removed from.
+     */
+    status?: "active" | "pending" | "banned";
 }
 declare function fetchUserSpaces(client: SublayHttpClient, data: FetchUserSpacesProps): Promise<UserSpacesResponse>;
 
@@ -2229,7 +2428,7 @@ declare function removeEntityFromCollection(client: SublayHttpClient, data: Remo
 
 interface UpdateCollectionProps {
     collectionId: string;
-    name?: string;
+    name: string;
 }
 declare function updateCollection(client: SublayHttpClient, data: UpdateCollectionProps): Promise<Collection>;
 
@@ -2612,7 +2811,13 @@ declare namespace AppNotifications {
   export { AppNotifications_countUnreadNotifications as countUnreadNotifications, AppNotifications_fetchNotifications as fetchNotifications, AppNotifications_markAllNotificationsAsRead as markAllNotificationsAsRead, AppNotifications_markNotificationAsRead as markNotificationAsRead };
 }
 
-type ReportTargetType = "entity" | "comment";
+type ReportTargetType = "entity" | "comment" | "message";
+/**
+ * The reasons the API accepts on a report. Server-enforced — anything outside
+ * this set is rejected with `report/invalid-body`. Use `other` plus `details`
+ * for anything the taxonomy doesn't cover.
+ */
+type ReportReason = "spam" | "inappropriateContent" | "harassment" | "misinformation" | "hateSpeech" | "violence" | "illegalActivity" | "selfHarm" | "other";
 type ReportStatus = "pending" | "on-hold" | "escalated" | "dismissed" | "actioned";
 interface UserReport {
     id: string;
@@ -2645,7 +2850,7 @@ interface CreateReportResponse {
 interface CreateReportProps {
     targetType: ReportTargetType;
     targetId: string;
-    reason: string;
+    reason: ReportReason;
     details?: string;
 }
 declare function createReport(client: SublayHttpClient, data: CreateReportProps): Promise<CreateReportResponse>;
@@ -3229,27 +3434,6 @@ declare function markAsRead(client: SublayHttpClient, data: MarkAsReadProps): Pr
     message: string;
 }>;
 
-/**
- * Every push event type — the full app-notification type set plus the chat
- * `message` event (push-only). Mirrors the server's `PUSH_EVENT_TYPES` exactly
- * (server `src/constants/push/pushEvents.ts`); these are the only names a
- * `disabledTypes` set may contain.
- */
-declare const PUSH_EVENT_TYPES: readonly ["entity-comment", "comment-reply", "entity-mention", "comment-mention", "entity-reaction", "comment-reaction", "entity-reaction-milestone-specific", "entity-reaction-milestone-total", "comment-reaction-milestone-specific", "comment-reaction-milestone-total", "new-follow", "connection-request", "connection-accepted", "space-membership-approved", "event-invite", "event-updated", "event-cancelled", "message"];
-type PushEventType = (typeof PUSH_EVENT_TYPES)[number];
-/**
- * The four conversation-mute duration choices. Send the CHOICE, never a raw
- * timestamp — the server resolves it and represents "forever" via the explicit
- * `mutedForever` signal on the returned member. Mirrors the server's
- * `MUTE_DURATIONS` (server `src/helpers/push/muteDuration.ts`).
- */
-declare const MUTE_DURATIONS: readonly ["8h", "24h", "1w", "forever"];
-type MuteDuration = (typeof MUTE_DURATIONS)[number];
-/** Response of read/update notification preferences. */
-interface NotificationPreferences {
-    disabledTypes: PushEventType[];
-}
-
 interface MuteConversationProps {
     conversationId: string;
     /**
@@ -3271,18 +3455,6 @@ interface MuteConversationResponse {
  */
 declare function muteConversation(client: SublayHttpClient, data: MuteConversationProps): Promise<MuteConversationResponse>;
 
-interface ReportMessageProps {
-    conversationId: string;
-    messageId: string;
-    reason: string;
-    details?: string;
-}
-interface ReportMessageResponse {
-    message: string;
-    code: string;
-}
-declare function reportMessage(client: SublayHttpClient, data: ReportMessageProps): Promise<ReportMessageResponse>;
-
 declare const Chat_addMember: typeof addMember;
 declare const Chat_changeMemberRole: typeof changeMemberRole;
 declare const Chat_createDirectConversation: typeof createDirectConversation;
@@ -3301,12 +3473,11 @@ declare const Chat_listReactions: typeof listReactions;
 declare const Chat_markAsRead: typeof markAsRead;
 declare const Chat_muteConversation: typeof muteConversation;
 declare const Chat_removeMember: typeof removeMember;
-declare const Chat_reportMessage: typeof reportMessage;
 declare const Chat_sendMessage: typeof sendMessage;
 declare const Chat_toggleReaction: typeof toggleReaction;
 declare const Chat_updateConversation: typeof updateConversation;
 declare namespace Chat {
-  export { Chat_addMember as addMember, Chat_changeMemberRole as changeMemberRole, Chat_createDirectConversation as createDirectConversation, Chat_createGroupConversation as createGroupConversation, Chat_deleteConversation as deleteConversation, Chat_deleteMessage as deleteMessage, Chat_editMessage as editMessage, Chat_getConversation as getConversation, Chat_getMessage as getMessage, Chat_getUnreadCount as getUnreadCount, Chat_leaveConversation as leaveConversation, Chat_listConversations as listConversations, Chat_listMembers as listMembers, Chat_listMessages as listMessages, Chat_listReactions as listReactions, Chat_markAsRead as markAsRead, Chat_muteConversation as muteConversation, Chat_removeMember as removeMember, Chat_reportMessage as reportMessage, Chat_sendMessage as sendMessage, Chat_toggleReaction as toggleReaction, Chat_updateConversation as updateConversation };
+  export { Chat_addMember as addMember, Chat_changeMemberRole as changeMemberRole, Chat_createDirectConversation as createDirectConversation, Chat_createGroupConversation as createGroupConversation, Chat_deleteConversation as deleteConversation, Chat_deleteMessage as deleteMessage, Chat_editMessage as editMessage, Chat_getConversation as getConversation, Chat_getMessage as getMessage, Chat_getUnreadCount as getUnreadCount, Chat_leaveConversation as leaveConversation, Chat_listConversations as listConversations, Chat_listMembers as listMembers, Chat_listMessages as listMessages, Chat_listReactions as listReactions, Chat_markAsRead as markAsRead, Chat_muteConversation as muteConversation, Chat_removeMember as removeMember, Chat_sendMessage as sendMessage, Chat_toggleReaction as toggleReaction, Chat_updateConversation as updateConversation };
 }
 
 /**
@@ -3352,6 +3523,13 @@ declare namespace Push {
 type WorkspaceCapability = "view" | "invite" | "remove-member" | "edit-member-access" | "edit-member-profile" | "create-sub-workspace" | "edit-workspace";
 type WorkspaceInvitationStatus = "pending" | "accepted" | "declined" | "revoked";
 type WorkspaceAuthorityReason = "owner" | "ancestor-owner" | "member" | "reach-holder";
+type WorkspaceAuthorityReasonDetail = {
+    type: "owner" | "member";
+    viaWorkspaceId?: never;
+} | {
+    type: "ancestor-owner" | "reach-holder";
+    viaWorkspaceId: string;
+};
 interface Workspace {
     id: string;
     name: string;
@@ -3364,6 +3542,18 @@ interface Workspace {
     updatedAt: string;
     memberCount?: number;
 }
+interface WorkspaceMember {
+    id: string;
+    workspaceId: string;
+    userId: string;
+    capabilities: WorkspaceCapability[];
+    permissions: string[];
+    rank: number;
+    title: string | null;
+    metadata: Record<string, any>;
+    joinedAt: string;
+    createdAt: string;
+}
 interface WorkspaceInvitation {
     id: string;
     workspaceId: string;
@@ -3408,12 +3598,66 @@ interface WorkspaceRosterCountsResponse {
     total: number;
     distinctUsers: number;
 }
+/**
+ * The `user` carried by a standing read. Normally the full user record, but the
+ * server falls back to `{ id }` alone when the user row is gone (a deleted user
+ * with a lingering membership row is a reachable case), so every field except
+ * `id` may be absent.
+ */
+type WorkspaceStandingUser = Pick<User, "id"> & Partial<Omit<User, "id">>;
+interface WorkspaceMemberStanding {
+    user: WorkspaceStandingUser;
+    reasons: WorkspaceAuthorityReasonDetail[];
+    capabilities?: WorkspaceCapability[];
+    permissions?: string[];
+    rank?: number | null;
+    title: string | null;
+    metadata: Record<string, any>;
+}
 interface WorkspaceAuthority {
-    reasons: WorkspaceAuthorityReason[];
+    reasons: WorkspaceAuthorityReasonDetail[];
     capabilities: WorkspaceCapability[];
     permissions: string[];
     rank: number | null;
 }
+/**
+ * One descendant the subtree sweep did NOT clear, where the target user still
+ * holds a direct membership.
+ *
+ * `id` / `name` are masked TOGETHER: an entry the acting user may see carries
+ * both, and one they may not carries `null` for both — the sweep reports THAT a
+ * membership survived without disclosing the existence or name of a sealed
+ * sub-workspace the actor has no authority over (the same sealing fence the
+ * descendant roster read applies). Modelled as a discriminated union so a
+ * `null` check on `id` narrows `name` too.
+ */
+type SkippedWorkspace = {
+    id: string;
+    name: string;
+    /** Why it was skipped. `out-of-reach`: the actor's authority does not extend there. */
+    reason: "out-of-reach";
+} | {
+    id: null;
+    name: null;
+    /** Why it was skipped. `out-of-reach`: the actor's authority does not extend there. */
+    reason: "out-of-reach";
+};
+interface RemoveWorkspaceMemberFromSubtreeResponse {
+    removedCount: number;
+    removed: {
+        workspaceId: string;
+        userId: string;
+    }[];
+    /**
+     * How many descendant memberships the target RETAINED because the sweep could
+     * not reach them. Always `0` for an owner / ancestor-owner / privileged key.
+     * A non-zero value means the offboarding is PARTIAL — never conclude a user is
+     * fully removed from `removedCount` alone.
+     */
+    skippedCount: number;
+    /** One entry per retained membership; `skippedCount === skipped.length`. */
+    skipped: SkippedWorkspace[];
+}
 
 interface CreateWorkspaceProps {
     name: string;
@@ -3443,7 +3687,57 @@ interface FetchManyWorkspacesProps {
  */
 declare function fetchManyWorkspaces(client: SublayHttpClient, data?: FetchManyWorkspacesProps): Promise<PaginatedResponse<Workspace>>;
 
-interface FetchMembersProps {
+interface UpdateWorkspaceProps {
+    workspaceId: string;
+    name?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Edit a workspace's name / metadata. Requires the `edit-workspace` capability
+ * (or ownership). The actor is the bearer-token user — no `userId` is sent.
+ */
+declare function updateWorkspace(client: SublayHttpClient, data: UpdateWorkspaceProps): Promise<Workspace>;
+
+interface UpdateWorkspaceInheritFlagProps {
+    workspaceId: string;
+    inheritsFromParent: boolean;
+}
+/**
+ * Flip whether capabilities held on an ancestor "reach" into this workspace.
+ * Owner-only in both directions (own owner or an ancestor owner), and blocked
+ * (403 `workspace/inherit-enforced`) when the project enforces its default.
+ * The actor is the bearer-token user — no `userId` is sent.
+ */
+declare function updateWorkspaceInheritFlag(client: SublayHttpClient, data: UpdateWorkspaceInheritFlagProps): Promise<Workspace>;
+
+interface DeleteWorkspaceProps {
+    workspaceId: string;
+}
+interface DeleteWorkspaceResponse {
+    message: string;
+}
+/**
+ * Owner-only delete (own owner or an ancestor owner). Cascades the whole
+ * subtree transactionally. The actor is the bearer-token user — no `userId`
+ * body is sent.
+ */
+declare function deleteWorkspace(client: SublayHttpClient, data: DeleteWorkspaceProps): Promise<DeleteWorkspaceResponse>;
+
+interface TransferWorkspaceOwnershipProps {
+    workspaceId: string;
+    newOwnerId: string;
+    previousOwnerDisposition?: "demote" | "remove";
+    previousOwnerRank?: number;
+    previousOwnerCapabilities?: WorkspaceCapability[];
+}
+/**
+ * Hand the workspace to a new owner. Owner-only (own owner or an ancestor
+ * owner). The actor is the bearer-token user — no `userId` is sent;
+ * `newOwnerId` addresses the TARGET, not the actor.
+ */
+declare function transferWorkspaceOwnership(client: SublayHttpClient, data: TransferWorkspaceOwnershipProps): Promise<Workspace>;
+
+interface FetchWorkspaceMembersProps {
     workspaceId: string;
     include?: string;
     countOnly?: boolean;
@@ -3453,9 +3747,73 @@ interface FetchMembersProps {
  * array. Always returned in full (never paginated). With `countOnly=true` the
  * shape is `WorkspaceRosterCountsResponse` instead. Actor from the token.
  */
-declare function fetchMembers(client: SublayHttpClient, data: FetchMembersProps): Promise<WorkspaceRosterResponse | WorkspaceRosterCountsResponse>;
+declare function fetchWorkspaceMembers(client: SublayHttpClient, data: FetchWorkspaceMembersProps): Promise<WorkspaceRosterResponse | WorkspaceRosterCountsResponse>;
 
-interface CreateInviteProps {
+interface FetchWorkspaceMemberStandingProps {
+    workspaceId: string;
+    targetUserId: string;
+}
+/**
+ * Read one user's resolved standing on a workspace (`reasons`, `capabilities`,
+ * `permissions`, `rank`, `title`, `metadata`).
+ */
+declare function fetchWorkspaceMemberStanding(client: SublayHttpClient, data: FetchWorkspaceMemberStandingProps): Promise<WorkspaceMemberStanding>;
+
+interface UpdateWorkspaceMemberProps {
+    workspaceId: string;
+    targetUserId: string;
+    capabilities?: WorkspaceCapability[];
+    permissions?: string[];
+    rank?: number;
+    title?: string | null;
+    metadata?: Record<string, any>;
+}
+/**
+ * Edit a member's grant / profile. Powerful fields need `edit-member-access`
+ * plus rank + no-escalation rules; cosmetic fields need only
+ * `edit-member-profile`. No `userId` is sent — the actor comes from the token.
+ */
+declare function updateWorkspaceMember(client: SublayHttpClient, data: UpdateWorkspaceMemberProps): Promise<WorkspaceMember>;
+
+interface RemoveWorkspaceMemberProps {
+    workspaceId: string;
+    targetUserId: string;
+}
+/**
+ * Remove a member from this workspace. Requires the `remove-member` capability
+ * and is rank-bounded. The workspace owner cannot be removed (409
+ * `workspace/sole-owner`) — transfer ownership first. No `userId` body is sent;
+ * the actor comes from the token.
+ */
+declare function removeWorkspaceMember(client: SublayHttpClient, data: RemoveWorkspaceMemberProps): Promise<void>;
+
+interface LeaveWorkspaceProps {
+    workspaceId: string;
+}
+/**
+ * The bearer-token user leaves this workspace — removes THEIR OWN direct
+ * membership on THIS node only (owning a child is unaffected). An owner cannot
+ * leave (409 `workspace/sole-owner`); transfer or delete first. No `userId` is
+ * sent — the server derives the leaver from the token.
+ */
+declare function leaveWorkspace(client: SublayHttpClient, data: LeaveWorkspaceProps): Promise<void>;
+
+interface RemoveWorkspaceMemberFromSubtreeProps {
+    workspaceId: string;
+    targetUserId: string;
+}
+/**
+ * Removes the target user's direct memberships on this workspace and every
+ * descendant. Requires `remove-member` (rank-bounded per node). Blocks (409
+ * `workspace/owns-descendants`) with a report if the user OWNS any descendant
+ * workspace — transfer or delete those first. The actor comes from the token.
+ *
+ * A NON-owner's sweep can be PARTIAL: it stops at sealed sub-workspaces. Check
+ * `skippedCount` / `skipped` before treating the user as fully offboarded.
+ */
+declare function removeWorkspaceMemberFromSubtree(client: SublayHttpClient, data: RemoveWorkspaceMemberFromSubtreeProps): Promise<RemoveWorkspaceMemberFromSubtreeResponse>;
+
+interface CreateWorkspaceInviteProps {
     workspaceId: string;
     email?: string;
     userId?: string;
@@ -3469,12 +3827,52 @@ interface CreateInviteProps {
  * Create an invitation (requires the `invite` capability on the workspace). The
  * inviter is the bearer-token user.
  */
-declare function createInvite(client: SublayHttpClient, data: CreateInviteProps): Promise<WorkspaceInvitation>;
+declare function createWorkspaceInvite(client: SublayHttpClient, data: CreateWorkspaceInviteProps): Promise<WorkspaceInvitation>;
+
+interface FetchWorkspaceInvitesProps {
+    workspaceId: string;
+}
+interface FetchWorkspaceInvitesResponse {
+    data: WorkspaceInvitation[];
+}
+/**
+ * List a workspace's LIVE pending invites (`status='pending' AND expiresAt >
+ * now`). Requires the `invite` capability (or owner). Always returned in full —
+ * this list is deliberately unpaginated.
+ *
+ * This is the OUTBOX read — invites this workspace ISSUED. For the invites
+ * addressed TO the caller, use `fetchMyWorkspaceInvites`.
+ */
+declare function fetchWorkspaceInvites(client: SublayHttpClient, data: FetchWorkspaceInvitesProps): Promise<FetchWorkspaceInvitesResponse>;
+
+interface RevokeWorkspaceInviteProps {
+    workspaceId: string;
+    inviteId: string;
+}
+interface RevokeWorkspaceInviteResponse {
+    success: boolean;
+}
+/**
+ * Revoke a pending invitation. Requires the `invite` capability (or owner).
+ * Note the verb-suffixed POST route — this is not a `DELETE`.
+ */
+declare function revokeWorkspaceInvite(client: SublayHttpClient, data: RevokeWorkspaceInviteProps): Promise<RevokeWorkspaceInviteResponse>;
 
-interface AcceptInviteProps {
+interface ResendWorkspaceInviteProps {
+    workspaceId: string;
     inviteId: string;
 }
-interface AcceptInviteResponse {
+/**
+ * Resend / refresh a pending invitation (valid on any `pending` invite, even one
+ * past `expiresAt` — resets a 14-day expiry and resends the email). A terminal
+ * invite (accepted/declined/revoked) → 409. Requires `invite` (or owner).
+ */
+declare function resendWorkspaceInvite(client: SublayHttpClient, data: ResendWorkspaceInviteProps): Promise<WorkspaceInvitation>;
+
+interface AcceptWorkspaceInviteProps {
+    inviteId: string;
+}
+interface AcceptWorkspaceInviteResponse {
     success: boolean;
     workspaceId: string;
 }
@@ -3482,31 +3880,37 @@ interface AcceptInviteResponse {
  * Accept an invitation — identity-matched to the bearer-token user + verified
  * email required. Non-secret id. Idempotent when already a member/owner.
  */
-declare function acceptInvite(client: SublayHttpClient, data: AcceptInviteProps): Promise<AcceptInviteResponse>;
+declare function acceptWorkspaceInvite(client: SublayHttpClient, data: AcceptWorkspaceInviteProps): Promise<AcceptWorkspaceInviteResponse>;
 
-interface DeclineInviteProps {
+interface DeclineWorkspaceInviteProps {
     inviteId: string;
 }
-interface DeclineInviteResponse {
+interface DeclineWorkspaceInviteResponse {
     success: boolean;
 }
 /**
- * Decline an invitation — identity-matched to the bearer-token user (not
- * verification-gated).
+ * Decline an invitation — identity-matched to the bearer-token user, and
+ * verified-email-gated (the same gate as accept, so an unverified squatter on
+ * someone else's address cannot burn their invite). An unverified decline
+ * returns `403 workspace/email-not-verified`.
  */
-declare function declineInvite(client: SublayHttpClient, data: DeclineInviteProps): Promise<DeclineInviteResponse>;
+declare function declineWorkspaceInvite(client: SublayHttpClient, data: DeclineWorkspaceInviteProps): Promise<DeclineWorkspaceInviteResponse>;
 
-interface FetchMyInvitesResponse {
+interface FetchMyWorkspaceInvitesResponse {
     data: WorkspaceInvitation[];
 }
 /**
  * The bearer-token user's LIVE pending invites (`status='pending' AND expiresAt
  * > now`), matched by `userId` from the token. Surfacing is NOT
- * verification-gated (the verified check applies only at accept).
+ * verification-gated (the verified check applies when the user ACTS on an
+ * invite — accept or decline).
+ *
+ * This is the INBOX read — invites addressed TO the caller. For the invites a
+ * workspace has ISSUED, use `fetchWorkspaceInvites`.
  */
-declare function fetchMyInvites(client: SublayHttpClient): Promise<FetchMyInvitesResponse>;
+declare function fetchMyWorkspaceInvites(client: SublayHttpClient): Promise<FetchMyWorkspaceInvitesResponse>;
 
-interface GetAuthorityProps {
+interface FetchWorkspaceAuthorityProps {
     workspaceId: string;
 }
 /**
@@ -3514,19 +3918,31 @@ interface GetAuthorityProps {
  * (`{ reasons, capabilities, permissions, rank }`) on the workspace. A
  * permission check is a one-line `.includes()` on the result.
  */
-declare function getAuthority(client: SublayHttpClient, data: GetAuthorityProps): Promise<WorkspaceAuthority>;
+declare function fetchWorkspaceAuthority(client: SublayHttpClient, data: FetchWorkspaceAuthorityProps): Promise<WorkspaceAuthority>;
 
-declare const Workspaces_acceptInvite: typeof acceptInvite;
-declare const Workspaces_createInvite: typeof createInvite;
+declare const Workspaces_acceptWorkspaceInvite: typeof acceptWorkspaceInvite;
 declare const Workspaces_createWorkspace: typeof createWorkspace;
-declare const Workspaces_declineInvite: typeof declineInvite;
+declare const Workspaces_createWorkspaceInvite: typeof createWorkspaceInvite;
+declare const Workspaces_declineWorkspaceInvite: typeof declineWorkspaceInvite;
+declare const Workspaces_deleteWorkspace: typeof deleteWorkspace;
 declare const Workspaces_fetchManyWorkspaces: typeof fetchManyWorkspaces;
-declare const Workspaces_fetchMembers: typeof fetchMembers;
-declare const Workspaces_fetchMyInvites: typeof fetchMyInvites;
+declare const Workspaces_fetchMyWorkspaceInvites: typeof fetchMyWorkspaceInvites;
 declare const Workspaces_fetchWorkspace: typeof fetchWorkspace;
-declare const Workspaces_getAuthority: typeof getAuthority;
+declare const Workspaces_fetchWorkspaceAuthority: typeof fetchWorkspaceAuthority;
+declare const Workspaces_fetchWorkspaceInvites: typeof fetchWorkspaceInvites;
+declare const Workspaces_fetchWorkspaceMemberStanding: typeof fetchWorkspaceMemberStanding;
+declare const Workspaces_fetchWorkspaceMembers: typeof fetchWorkspaceMembers;
+declare const Workspaces_leaveWorkspace: typeof leaveWorkspace;
+declare const Workspaces_removeWorkspaceMember: typeof removeWorkspaceMember;
+declare const Workspaces_removeWorkspaceMemberFromSubtree: typeof removeWorkspaceMemberFromSubtree;
+declare const Workspaces_resendWorkspaceInvite: typeof resendWorkspaceInvite;
+declare const Workspaces_revokeWorkspaceInvite: typeof revokeWorkspaceInvite;
+declare const Workspaces_transferWorkspaceOwnership: typeof transferWorkspaceOwnership;
+declare const Workspaces_updateWorkspace: typeof updateWorkspace;
+declare const Workspaces_updateWorkspaceInheritFlag: typeof updateWorkspaceInheritFlag;
+declare const Workspaces_updateWorkspaceMember: typeof updateWorkspaceMember;
 declare namespace Workspaces {
-  export { Workspaces_acceptInvite as acceptInvite, Workspaces_createInvite as createInvite, Workspaces_createWorkspace as createWorkspace, Workspaces_declineInvite as declineInvite, Workspaces_fetchManyWorkspaces as fetchManyWorkspaces, Workspaces_fetchMembers as fetchMembers, Workspaces_fetchMyInvites as fetchMyInvites, Workspaces_fetchWorkspace as fetchWorkspace, Workspaces_getAuthority as getAuthority };
+  export { Workspaces_acceptWorkspaceInvite as acceptWorkspaceInvite, Workspaces_createWorkspace as createWorkspace, Workspaces_createWorkspaceInvite as createWorkspaceInvite, Workspaces_declineWorkspaceInvite as declineWorkspaceInvite, Workspaces_deleteWorkspace as deleteWorkspace, Workspaces_fetchManyWorkspaces as fetchManyWorkspaces, Workspaces_fetchMyWorkspaceInvites as fetchMyWorkspaceInvites, Workspaces_fetchWorkspace as fetchWorkspace, Workspaces_fetchWorkspaceAuthority as fetchWorkspaceAuthority, Workspaces_fetchWorkspaceInvites as fetchWorkspaceInvites, Workspaces_fetchWorkspaceMemberStanding as fetchWorkspaceMemberStanding, Workspaces_fetchWorkspaceMembers as fetchWorkspaceMembers, Workspaces_leaveWorkspace as leaveWorkspace, Workspaces_removeWorkspaceMember as removeWorkspaceMember, Workspaces_removeWorkspaceMemberFromSubtree as removeWorkspaceMemberFromSubtree, Workspaces_resendWorkspaceInvite as resendWorkspaceInvite, Workspaces_revokeWorkspaceInvite as revokeWorkspaceInvite, Workspaces_transferWorkspaceOwnership as transferWorkspaceOwnership, Workspaces_updateWorkspace as updateWorkspace, Workspaces_updateWorkspaceInheritFlag as updateWorkspaceInheritFlag, Workspaces_updateWorkspaceMember as updateWorkspaceMember };
 }
 
 /**
@@ -3626,4 +4042,4 @@ declare class SublayClient {
     clearTokens(): void;
 }
 
-export { type AuthTokens, type BulkDeleteProps, type BulkDeleteResult, type ClientConfig, type DbFilter, type DbFilterOperator, type DeleteResult, MUTE_DURATIONS, type MuteConversationProps, type MuteConversationResponse, type MuteDuration, type NotificationPreferences, PUSH_EVENT_TYPES, type PaginatedResponse, type PaginationMetadata, type PushEventType, type SpaceReputationContextParams, type SpaceReputationUserParams, SublayClient, type TableAccessor, type TableQuery, type TableRow, type UpdateNotificationPreferencesProps, type UserSearchParams, type Workspace, type WorkspaceAuthority, type WorkspaceAuthorityReason, type WorkspaceCapability, type WorkspaceInvitation, type WorkspaceInvitationStatus, type WorkspaceRosterCountsResponse, type WorkspaceRosterEntry, type WorkspaceRosterReason, type WorkspaceRosterResponse };
+export { type AuthTokens, type BulkDeleteProps, type BulkDeleteResult, type ClientConfig, type DbFilter, type DbFilterOperator, type DeleteResult, MUTE_DURATIONS, type MuteConversationProps, type MuteConversationResponse, type MuteDuration, type NotificationPreferences, PUSH_EVENT_TYPES, type PaginatedResponse, type PaginationMetadata, type PushDeviceIdentifier, type PushEventType, type PushUnbindSkipReason, type RemoveWorkspaceMemberFromSubtreeResponse, type SignOutResult, type SkippedWorkspace, type SpaceReputationContextParams, type SpaceReputationUserParams, SublayClient, type TableAccessor, type TableQuery, type TableRow, type UpdateNotificationPreferencesProps, type UserSearchParams, type WebPushSubscription, type Workspace, type WorkspaceAuthority, type WorkspaceAuthorityReason, type WorkspaceAuthorityReasonDetail, type WorkspaceCapability, type WorkspaceInvitation, type WorkspaceInvitationStatus, type WorkspaceMember, type WorkspaceMemberStanding, type WorkspaceRosterCountsResponse, type WorkspaceRosterEntry, type WorkspaceRosterReason, type WorkspaceRosterResponse, type WorkspaceStandingUser };