@sublay/js 7.7.1 → 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 {
@@ -3244,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;
     /**
@@ -3873,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 RemoveWorkspaceMemberFromSubtreeResponse, type SkippedWorkspace, type SpaceReputationContextParams, type SpaceReputationUserParams, SublayClient, type TableAccessor, type TableQuery, type TableRow, type UpdateNotificationPreferencesProps, type UserSearchParams, 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 };
+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 };

package/dist/index.d.ts

@@ -58,7 +58,8 @@ export type { SpaceReputationContextParams, SpaceReputationUserParams, } from ".
 export type { UserSearchParams } from "./interfaces/UserSearch";
 export type { Workspace, WorkspaceMember, WorkspaceInvitation, WorkspaceCapability, WorkspaceInvitationStatus, WorkspaceAuthorityReason, WorkspaceAuthorityReasonDetail, WorkspaceRosterReason, WorkspaceRosterEntry, WorkspaceRosterResponse, WorkspaceRosterCountsResponse, WorkspaceStandingUser, WorkspaceMemberStanding, WorkspaceAuthority, RemoveWorkspaceMemberFromSubtreeResponse, SkippedWorkspace, } from "./interfaces/Workspace";
 export { PUSH_EVENT_TYPES, MUTE_DURATIONS } from "./interfaces/Push";
-export type { PushEventType, MuteDuration, NotificationPreferences, } from "./interfaces/Push";
+export type { PushEventType, MuteDuration, NotificationPreferences, PushDeviceIdentifier, WebPushSubscription, } from "./interfaces/Push";
+export type { SignOutResult, PushUnbindSkipReason, } from "./modules/auth/signOut";
 export type { UpdateNotificationPreferencesProps } from "./modules/push/updateNotificationPreferences";
 export type { MuteConversationProps, MuteConversationResponse, } from "./modules/chat/muteConversation";
 export type { TableAccessor, TableRow, TableQuery, DbFilter, DbFilterOperator, BulkDeleteProps, DeleteResult, BulkDeleteResult, } from "./interfaces/Table";

package/dist/index.js

@@ -212,13 +212,54 @@ async function signIn(client, data) {
 }
 
 // src/modules/auth/signOut.ts
+var PUSH_UNBIND_STATUS_UNKNOWN_CODE = "auth/push-unbind-status-unknown";
+var UNBIND_FAILURE_CODES = [
+  "auth/device-deregistration-failed",
+  "auth/sign-out-failed"
+];
+function isUnbindFailure(error) {
+  const code = error?.response?.data?.code;
+  return typeof code === "string" && UNBIND_FAILURE_CODES.includes(code);
+}
 async function signOut(client, data) {
   const refreshToken = data?.refreshToken ?? client.getRefreshToken();
-  await client.projectInstance.post(
-    "/auth/sign-out",
-    refreshToken ? { refreshToken } : {}
-  );
+  const localUnbindSkipped = Boolean(data?.pushDevice) && !refreshToken;
+  const body = refreshToken ? { refreshToken } : {};
+  if (data?.pushDevice && !localUnbindSkipped) body.pushDevice = data.pushDevice;
+  let response;
+  try {
+    response = await client.projectInstance.post(
+      "/auth/sign-out",
+      body
+    );
+  } catch (error) {
+    if (isUnbindFailure(error)) throw error;
+    console.warn(
+      "signOut: the server sign-out did not complete, so the session may still be live on the server until its refresh token expires. Signing out locally anyway \u2014 a user must always be able to sign out; only a refused push unbind keeps the local session, because that is the one failure that leaves a binding to retry against.",
+      error
+    );
+  }
   client.clearTokens();
+  const serverUnbindSkipped = typeof response?.data === "object" && response.data !== null && response.data.code === PUSH_UNBIND_STATUS_UNKNOWN_CODE;
+  if (localUnbindSkipped) {
+    console.warn(
+      "signOut: signed out, but the push unbind was SKIPPED \u2014 `pushDevice` was supplied and no refresh token could be resolved (none stored and none provided). The unbind is scoped to the refresh token's subject, so the server would have unbound nothing. This device keeps receiving that account's notifications until something else removes the binding. Pass `refreshToken` alongside `pushDevice` \u2014 required in host-managed mode, where the SDK stores no refresh token."
+    );
+    return {
+      pushUnbindSkipped: true,
+      pushUnbindSkipReason: "no-refresh-token"
+    };
+  }
+  if (serverUnbindSkipped) {
+    console.warn(
+      "signOut: signed out, but the push unbind was SKIPPED \u2014 the server could not determine whether this project has push devices, so it did not attempt one. This device may still be bound to that account and can keep receiving its notifications. The sign-out itself committed, so there is no credential left to retry with: the binding clears when that account next registers on this device, or when the server prunes the token as undeliverable."
+    );
+    return {
+      pushUnbindSkipped: true,
+      pushUnbindSkipReason: "push-unbind-status-unknown"
+    };
+  }
+  return { pushUnbindSkipped: false };
 }
 
 // src/modules/auth/requestNewAccessToken.ts
@@ -266,7 +307,11 @@ async function resetPassword(client, data) {
 async function changePassword(client, data) {
   const response = await client.projectInstance.post(
     "/auth/change-password",
-    data
+    {
+      password: data.password,
+      newPassword: data.newPassword,
+      ...data.pushDevice ? { pushDevice: data.pushDevice } : {}
+    }
   );
   return response.data;
 }

package/dist/index.mjs

@@ -180,13 +180,54 @@ async function signIn(client, data) {
 }
 
 // src/modules/auth/signOut.ts
+var PUSH_UNBIND_STATUS_UNKNOWN_CODE = "auth/push-unbind-status-unknown";
+var UNBIND_FAILURE_CODES = [
+  "auth/device-deregistration-failed",
+  "auth/sign-out-failed"
+];
+function isUnbindFailure(error) {
+  const code = error?.response?.data?.code;
+  return typeof code === "string" && UNBIND_FAILURE_CODES.includes(code);
+}
 async function signOut(client, data) {
   const refreshToken = data?.refreshToken ?? client.getRefreshToken();
-  await client.projectInstance.post(
-    "/auth/sign-out",
-    refreshToken ? { refreshToken } : {}
-  );
+  const localUnbindSkipped = Boolean(data?.pushDevice) && !refreshToken;
+  const body = refreshToken ? { refreshToken } : {};
+  if (data?.pushDevice && !localUnbindSkipped) body.pushDevice = data.pushDevice;
+  let response;
+  try {
+    response = await client.projectInstance.post(
+      "/auth/sign-out",
+      body
+    );
+  } catch (error) {
+    if (isUnbindFailure(error)) throw error;
+    console.warn(
+      "signOut: the server sign-out did not complete, so the session may still be live on the server until its refresh token expires. Signing out locally anyway \u2014 a user must always be able to sign out; only a refused push unbind keeps the local session, because that is the one failure that leaves a binding to retry against.",
+      error
+    );
+  }
   client.clearTokens();
+  const serverUnbindSkipped = typeof response?.data === "object" && response.data !== null && response.data.code === PUSH_UNBIND_STATUS_UNKNOWN_CODE;
+  if (localUnbindSkipped) {
+    console.warn(
+      "signOut: signed out, but the push unbind was SKIPPED \u2014 `pushDevice` was supplied and no refresh token could be resolved (none stored and none provided). The unbind is scoped to the refresh token's subject, so the server would have unbound nothing. This device keeps receiving that account's notifications until something else removes the binding. Pass `refreshToken` alongside `pushDevice` \u2014 required in host-managed mode, where the SDK stores no refresh token."
+    );
+    return {
+      pushUnbindSkipped: true,
+      pushUnbindSkipReason: "no-refresh-token"
+    };
+  }
+  if (serverUnbindSkipped) {
+    console.warn(
+      "signOut: signed out, but the push unbind was SKIPPED \u2014 the server could not determine whether this project has push devices, so it did not attempt one. This device may still be bound to that account and can keep receiving its notifications. The sign-out itself committed, so there is no credential left to retry with: the binding clears when that account next registers on this device, or when the server prunes the token as undeliverable."
+    );
+    return {
+      pushUnbindSkipped: true,
+      pushUnbindSkipReason: "push-unbind-status-unknown"
+    };
+  }
+  return { pushUnbindSkipped: false };
 }
 
 // src/modules/auth/requestNewAccessToken.ts
@@ -234,7 +275,11 @@ async function resetPassword(client, data) {
 async function changePassword(client, data) {
   const response = await client.projectInstance.post(
     "/auth/change-password",
-    data
+    {
+      password: data.password,
+      newPassword: data.newPassword,
+      ...data.pushDevice ? { pushDevice: data.pushDevice } : {}
+    }
   );
   return response.data;
 }

package/dist/interfaces/Push.d.ts

@@ -18,3 +18,57 @@ export type MuteDuration = (typeof MUTE_DURATIONS)[number];
 export 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`).
+ */
+export 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.
+ */
+export type PushDeviceIdentifier = {
+    platform: "ios" | "android";
+    token: string;
+} | {
+    platform: "web";
+    subscription: WebPushSubscription;
+};

package/dist/modules/auth/changePassword.d.ts

@@ -1,11 +1,34 @@
 import { SublayHttpClient } from "../../core/client";
+import { PushDeviceIdentifier } from "../../interfaces/Push";
 export 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;
 }
 export 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.
+ */
 export declare function changePassword(client: SublayHttpClient, data: ChangePasswordProps): Promise<ChangePasswordResponse>;

package/dist/modules/auth/signOut.d.ts

@@ -1,9 +1,103 @@
 import { SublayHttpClient } from "../../core/client";
+import { PushDeviceIdentifier } from "../../interfaces/Push";
 export 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;
+}
+/**
+ * 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.
+ */
+export type PushUnbindSkipReason = "no-refresh-token" | "push-unbind-status-unknown";
+export 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;
 }
-export declare function signOut(client: SublayHttpClient, data?: SignOutProps): Promise<void>;
+export declare function signOut(client: SublayHttpClient, data?: SignOutProps): Promise<SignOutResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sublay/js",
-  "version": "7.7.1",
+  "version": "7.8.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [