@buildbase/sdk 0.0.68 → 0.0.71

package/dist/react/index.d.ts

@@ -855,6 +855,59 @@ interface IWorkspaceUser {
     role: string;
 }
 
+/** Mirrors the server enum, string-typed so an app can compare without an import. */
+type IWorkspaceInvitationStatus = 'invited' | 'accepted' | 'rejected' | 'expired';
+/**
+ * A workspace invitation: an email address a member invited, before (or
+ * after) the person behind it accepted. A pending row bills a seat until it is
+ * accepted, declined, revoked or expired.
+ */
+interface IWorkspaceInvitation {
+    _id: string;
+    /** The workspace, populated with `name` and `image` on the invitee's list. */
+    workspace: string | Pick<IWorkspace, '_id' | 'name' | 'image'>;
+    email: string;
+    role: string;
+    status: IWorkspaceInvitationStatus;
+    invitedAt: string;
+    /** When last emailed; absent until the first resend. Read `lastSentAt ?? invitedAt`. */
+    lastSentAt?: string;
+    /**
+     * When a resend stops being refused. The server derives it from the last
+     * send and its own cooldown, so a countdown here cannot disagree with the
+     * 429 that enforces it. Null unless the row is pending; absent from a
+     * server older than this field, which `resendCooldownSeconds` reads as
+     * "no cooldown known".
+     */
+    resendAvailableAt?: string | null;
+    /** The inviter, populated with `name`, `email` and `image`; null when their account is gone. */
+    invitedBy: string | (Pick<IUser, '_id' | 'name' | 'email'> & {
+        image?: string;
+    }) | null;
+    /** Null once accepted: the link no longer has anything to expire. */
+    validTill: string | null;
+    acceptedAt?: string;
+    rejectedAt?: string;
+    /** The app URL the emailed link lands on. */
+    landingUrl?: string;
+    clientId?: string;
+}
+/** What the public preview returns for a link token. The email is scrambled. */
+interface IWorkspaceInvitationPreview {
+    id: string;
+    workspaceName: string;
+    inviterName: string;
+    role: string;
+    email: string;
+    expiresAt: string | null;
+    status: IWorkspaceInvitationStatus;
+    /**
+     * False when the organization has switched invitations off, so accepting
+     * cannot succeed. Absent from older servers, which is read as joinable.
+     */
+    joinable?: boolean;
+}
+
 /** Event type constants */
 declare const SDKEvent: {
     readonly UserCreated: "user:created";
@@ -866,6 +919,10 @@ declare const SDKEvent: {
     readonly WorkspaceUserRoleChanged: "workspace:user-role-changed";
     readonly WorkspaceCreated: "workspace:created";
     readonly WorkspaceDeleted: "workspace:deleted";
+    readonly WorkspaceInvitationSent: "workspace:invitation-sent";
+    readonly WorkspaceInvitationAccepted: "workspace:invitation-accepted";
+    readonly WorkspaceInvitationDeclined: "workspace:invitation-declined";
+    readonly WorkspaceInvitationRevoked: "workspace:invitation-revoked";
 };
 type EventType = (typeof SDKEvent)[keyof typeof SDKEvent];
 /**
@@ -907,10 +964,27 @@ interface WorkspaceCreatedEventData {
 interface WorkspaceDeletedEventData {
     workspace: IWorkspace;
 }
+/** An invitation was sent from this client. The invitee may have no account yet. */
+interface WorkspaceInvitationSentEventData {
+    invitation: IWorkspaceInvitation;
+    workspaceId: string;
+}
+/** The signed-in user accepted an invitation; `WorkspaceUserAdded` fires too. */
+interface WorkspaceInvitationAcceptedEventData {
+    invitation: IWorkspaceInvitation;
+    workspace: IWorkspace;
+}
+interface WorkspaceInvitationDeclinedEventData {
+    invitation: IWorkspaceInvitation;
+}
+interface WorkspaceInvitationRevokedEventData {
+    invitationId: string;
+    workspaceId: string;
+}
 /**
  * Union type for all event data
  */
-type EventData = UserCreatedEventData | UserUpdatedEventData | WorkspaceChangedEventData | WorkspaceUpdatedEventData | WorkspaceUserAddedEventData | WorkspaceUserRemovedEventData | WorkspaceUserRoleChangedEventData | WorkspaceCreatedEventData | WorkspaceDeletedEventData;
+type EventData = UserCreatedEventData | UserUpdatedEventData | WorkspaceChangedEventData | WorkspaceUpdatedEventData | WorkspaceUserAddedEventData | WorkspaceUserRemovedEventData | WorkspaceUserRoleChangedEventData | WorkspaceCreatedEventData | WorkspaceDeletedEventData | WorkspaceInvitationSentEventData | WorkspaceInvitationAcceptedEventData | WorkspaceInvitationDeclinedEventData | WorkspaceInvitationRevokedEventData;
 /**
  * Single event callback function
  * Handles all events with conditional logic based on event type
@@ -1290,6 +1364,23 @@ declare class AuthApi extends BaseApi {
      * handling device identity. Returns '' for agent/machine sessions (no device).
      */
     getDeviceToken(sessionId: string, signal?: AbortSignal): Promise<string>;
+    /**
+     * Revoke the session server-side. This is what makes signing out mean
+     * something: dropping the id from storage only hides it from this tab, and
+     * the session stays valid until its TTL, so anyone who still holds the id -
+     * a synced browser profile, a backup, an extension - remains signed in.
+     *
+     * `all: true` revokes every session the user has, which is "sign out
+     * everywhere". Signing out one OTHER session is `SessionsApi.revoke`.
+     *
+     * The endpoint sits ahead of the session gate, so it answers for an id that
+     * has already expired or was never valid, and it is idempotent - calling it
+     * twice is not an error. Failures still throw: the caller decides, and
+     * `signOut` clears local state either way.
+     */
+    logout(sessionId?: string, options?: {
+        all?: boolean;
+    }, signal?: AbortSignal): Promise<void>;
 }
 
 interface IScreenDetail {
@@ -1407,6 +1498,111 @@ declare class DevicesApi extends BaseApi {
     }>;
 }
 
+/**
+ * API client for the signed-in user's notification inbox. Session-authed
+ * (x-session-id) and scoped to the current user by the server: every call
+ * reads or changes only their own items. Extends BaseApi for shared
+ * URL/auth/request handling.
+ *
+ * One item is one notification, however it was delivered: an event sent by
+ * email and push is a single item whose `channels` say what each did.
+ */
+
+type NotificationChannelStatus = 'none' | 'queued' | 'sent' | 'failed' | 'skipped';
+type NotificationSource = 'system' | 'custom' | 'workflow' | 'campaign' | 'console';
+/** How an item was first read: in the inbox, or by clicking its email or push link. */
+type NotificationReadVia = 'inbox' | 'email_click' | 'push_click';
+/** One notification in the signed-in user's inbox. Dates are ISO strings. */
+interface INotificationItem {
+    id: string;
+    /** The workspace it is about, or null for an account notice. */
+    workspaceId: string | null;
+    /** The event slug that sent it. */
+    event: string;
+    source: NotificationSource;
+    title: string;
+    body: string;
+    /** The destination as the app set it, for display. */
+    url: string | null;
+    /**
+     * What to open when the item is clicked: an absolute destination routed
+     * through the server's link check (which also marks the item read), a path
+     * inside the app as it is, or null when there is nothing safe to open.
+     */
+    link: string | null;
+    icon: string | null;
+    channels: {
+        /** An open is recorded but does not read the item; a click does. */
+        email: {
+            status: NotificationChannelStatus;
+            openedAt: string | null;
+            clickedAt: string | null;
+        };
+        push: {
+            status: NotificationChannelStatus;
+            clickedAt: string | null;
+        };
+    };
+    createdAt: string | null;
+    /** The inbox was opened while this was in it. Not the same as read. */
+    seenAt: string | null;
+    readAt: string | null;
+    readVia: NotificationReadVia | null;
+    archivedAt: string | null;
+}
+/**
+ * Which items: one workspace's, `'none'` for the account notices that belong
+ * to no workspace, or omitted for everything.
+ */
+type NotificationScope = string | 'none' | undefined;
+interface NotificationListParams {
+    workspaceId?: NotificationScope;
+    /** Only unread items. */
+    unread?: boolean;
+    /** Include archived items, which the default list leaves out. */
+    archived?: boolean;
+    page?: number;
+    /** At most 100. */
+    limit?: number;
+}
+interface NotificationPage {
+    notifications: INotificationItem[];
+    page: number;
+    limit: number;
+    total: number;
+    hasNextPage: boolean;
+}
+interface NotificationCounts {
+    /** Unread and not archived: the number on the bell. */
+    unread: number;
+    /** Unread and never seen: whether anything is new since the inbox was last opened. */
+    unseen: number;
+}
+declare class NotificationsApi extends BaseApi {
+    constructor(config: Pick<IOsConfig, 'serverUrl' | 'version'> & {
+        sessionId?: string;
+    });
+    /** A page of the current user's items, newest first. */
+    list(params?: NotificationListParams, signal?: AbortSignal): Promise<NotificationPage>;
+    /** Unread and unseen counts, for a badge. */
+    counts(workspaceId?: NotificationScope, signal?: AbortSignal): Promise<NotificationCounts>;
+    /**
+     * Mark one item read. Returns it as it now stands. Sent with `keepalive`,
+     * because it is usually followed at once by opening the item's link, and a
+     * page that navigates away would otherwise cancel it.
+     */
+    markRead(id: string): Promise<INotificationItem>;
+    markUnread(id: string): Promise<INotificationItem>;
+    /** Move an item out of the default list. It stays in history (`archived: true`). */
+    archive(id: string): Promise<INotificationItem>;
+    unarchive(id: string): Promise<INotificationItem>;
+    /** Read everything in scope. */
+    markAllRead(workspaceId?: NotificationScope): Promise<void>;
+    /** The inbox was opened: clears "new" without reading anything. */
+    markSeen(workspaceId?: NotificationScope): Promise<void>;
+    private itemAction;
+}
+
 declare class PushApi extends BaseApi {
     constructor(config: Pick<IBaseApiConfig, 'serverUrl' | 'version' | 'orgId' | 'sessionId'>);
     getVapidPublicKey(): Promise<{
@@ -1576,6 +1772,23 @@ interface NotificationEvent {
         push: boolean;
     };
 }
+/** One event's channels. A channel left out is on. */
+interface NotificationChannelPreference {
+    email?: boolean;
+    push?: boolean;
+}
+/** The workspace's setting for one event: the default, and whether members may change it. */
+interface WorkspaceNotificationDefault extends NotificationChannelPreference {
+    /** Members cannot change this event: the default is what they get. */
+    required?: boolean;
+}
+/** The signed-in member's notification settings in one workspace. */
+interface MyNotificationPreferences {
+    /** The workspace's defaults, by event slug. */
+    defaults: Record<string, WorkspaceNotificationDefault>;
+    /** The member's own choices over them, by event slug. */
+    mine: Record<string, NotificationChannelPreference>;
+}
 declare class WorkspaceApi extends BaseApi {
     constructor(config: IOsConfig & {
         sessionId?: string;
@@ -1599,6 +1812,61 @@ declare class WorkspaceApi extends BaseApi {
         workspace: IWorkspace;
         message: string;
     }>;
+    private fetchInvitation;
+    /** The workspace's invitations, pending first. Needs `MEMBERS_VIEW`. */
+    listInvitations(workspaceId: string, signal?: AbortSignal): Promise<IWorkspaceInvitation[]>;
+    /**
+     * Invite an email address to a workspace. The person need not have an
+     * account: they get a link that lands on the app's own auth redirect URL
+     * (or on `landingUrl`, which must be one of the auth client's allowed
+     * redirect URLs). Needs `MEMBERS_INVITE`. A pending invitation bills a seat.
+     */
+    inviteMember(workspaceId: string, config: {
+        email: string;
+        role: string;
+        landingUrl?: string;
+    }, signal?: AbortSignal): Promise<IWorkspaceInvitation & {
+        message: string;
+    }>;
+    /** Send the same invitation again (five-minute cooldown). Revives an expired one. */
+    resendInvitation(workspaceId: string, invitationId: string, signal?: AbortSignal): Promise<IWorkspaceInvitation & {
+        message: string;
+    }>;
+    /** Withdraw a pending invitation. The invitee is told; the seat is released. */
+    revokeInvitation(workspaceId: string, invitationId: string, signal?: AbortSignal): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /** The signed-in user's own pending invitations, across workspaces. */
+    myInvitations(signal?: AbortSignal): Promise<IWorkspaceInvitation[]>;
+    /**
+     * Accept an invitation addressed to the signed-in user's email.
+     *
+     * Pass the `token` from the invitation link when the user arrived by
+     * following it: the token was mailed to that address and to nowhere else, so
+     * it proves the mailbox and the account does not have to be verified
+     * separately first. Without it, the server requires a verified email, which
+     * is the case when accepting from the in-app list.
+     */
+    acceptInvitation(invitationId: string, options?: {
+        token?: string;
+    }, signal?: AbortSignal): Promise<{
+        invitation: IWorkspaceInvitation;
+        /** Null only when another tab accepted a moment earlier and its membership write is still in flight. */
+        workspace: IWorkspace | null;
+        message: string;
+    }>;
+    /** Decline an invitation addressed to the signed-in user's email. */
+    declineInvitation(invitationId: string, signal?: AbortSignal): Promise<{
+        invitation: IWorkspaceInvitation;
+        message: string;
+    }>;
+    /**
+     * What an invitation link resolves to, before sign-in. Public: keyed by the
+     * link's token, answers with the workspace name, the inviter, the role, the
+     * scrambled address and the status. 404 for an unknown or revoked token.
+     */
+    previewInvitation(token: string, signal?: AbortSignal): Promise<IWorkspaceInvitationPreview>;
     removeUser(workspaceId: string, userId: string, signal?: AbortSignal): Promise<{
         userId: string;
         workspace: IWorkspace;
@@ -1823,17 +2091,24 @@ declare class WorkspaceApi extends BaseApi {
      */
     sendNotification(workspaceId: string, event: string, userId?: string, data?: NotificationData, signal?: AbortSignal): Promise<NotificationResult>;
     getNotificationEvents(workspaceId: string, signal?: AbortSignal): Promise<NotificationEvent[]>;
-    getNotificationPreferences(workspaceId: string, signal?: AbortSignal): Promise<Record<string, {
-        email?: boolean;
-        push?: boolean;
-    }>>;
-    updateNotificationPreferences(workspaceId: string, preferences: Record<string, {
-        email?: boolean;
-        push?: boolean;
-    }>, signal?: AbortSignal): Promise<Record<string, {
-        email?: boolean;
-        push?: boolean;
-    }>>;
+    /** The workspace's defaults for every member. Needs `SETTINGS_VIEW`. */
+    getNotificationPreferences(workspaceId: string, signal?: AbortSignal): Promise<Record<string, WorkspaceNotificationDefault>>;
+    /**
+     * Change the workspace's defaults (and `required`) for every member. Needs
+     * `SETTINGS_EDIT`. Merged per event: send only what changes.
+     */
+    updateNotificationPreferences(workspaceId: string, preferences: Record<string, WorkspaceNotificationDefault>, signal?: AbortSignal): Promise<Record<string, WorkspaceNotificationDefault>>;
+    /** The signed-in member's own settings here, and the defaults they sit over. Any member. */
+    getMyNotificationPreferences(workspaceId: string, signal?: AbortSignal): Promise<MyNotificationPreferences>;
+    /**
+     * Change the signed-in member's own settings. `null` for a channel goes back
+     * to the workspace default. A required event answers 409 with
+     * `code: 'NOTIFICATION_PREFERENCE_REQUIRED'`.
+     */
+    updateMyNotificationPreferences(workspaceId: string, preferences: Record<string, {
+        email?: boolean | null;
+        push?: boolean | null;
+    }>, signal?: AbortSignal): Promise<MyNotificationPreferences>;
     /**
      * Get credit balance for a workspace.
      * @param workspaceId - The workspace ID
@@ -1953,6 +2228,14 @@ declare class EventEmitter {
      * @param role - The role assigned to the user
      */
     emitWorkspaceUserAdded(userId: string, workspace: IWorkspace, role: string): Promise<void>;
+    /** An invitation was sent from this client. */
+    emitWorkspaceInvitationSent(invitation: IWorkspaceInvitation, workspaceId: string): Promise<void>;
+    /** The signed-in user accepted an invitation and joined `workspace`. */
+    emitWorkspaceInvitationAccepted(invitation: IWorkspaceInvitation, workspace: IWorkspace): Promise<void>;
+    /** The signed-in user declined an invitation. */
+    emitWorkspaceInvitationDeclined(invitation: IWorkspaceInvitation): Promise<void>;
+    /** A pending invitation was withdrawn from this client. */
+    emitWorkspaceInvitationRevoked(invitationId: string, workspaceId: string): Promise<void>;
     /**
      * Trigger workspace user removed event
      * @param userId - The ID of the user that was removed
@@ -2839,6 +3122,60 @@ interface SDKMessages {
         memberLimitMessage: string;
         selectRole: string;
         inviteAs: string;
+        invitations: {
+            title: string;
+            pendingCount: string;
+            sent: string;
+            resend: string;
+            resendIn: string;
+            revoke: string;
+            /** Title of the revoke confirmation. */
+            revokeTitle: string;
+            revokeConfirm: string;
+            sentAt: string;
+            expiresAt: string;
+            seatNote: string;
+            formerMember: string;
+            loadFailed: string;
+            resendFailed: string;
+            revokeFailed: string;
+            status: {
+                invited: string;
+                accepted: string;
+                rejected: string;
+                expired: string;
+            };
+        };
+    };
+    invitations: {
+        title: string;
+        description: string;
+        /** The list of the caller's own invitations, above the rows. */
+        listDescription: string;
+        /** Dialog title once the invitee has joined. */
+        titleJoined: string;
+        /** Dialog title for a link that can no longer be used: revoked, expired, switched off. */
+        titleUnavailable: string;
+        sentTo: string;
+        invitedAs: string;
+        accept: string;
+        decline: string;
+        accepted: string;
+        declined: string;
+        expired: string;
+        revoked: string;
+        alreadyAccepted: string;
+        wrongAccount: string;
+        verifyFirst: string;
+        workspaceFull: string;
+        disabled: string;
+        empty: string;
+        signInToAccept: string;
+        dismiss: string;
+        signOut: string;
+        loadFailed: string;
+        acceptFailed: string;
+        declineFailed: string;
     };
     invoices: {
         title: string;
@@ -2952,6 +3289,28 @@ interface SDKMessages {
         failedToDelete: string;
     };
     notifications: {
+        inbox: {
+            title: string;
+            description: string;
+            bellLabel: string;
+            bellUnread: string;
+            filterAll: string;
+            filterUnread: string;
+            markAllRead: string;
+            markRead: string;
+            markUnread: string;
+            archive: string;
+            loadMore: string;
+            empty: string;
+            emptyUnread: string;
+            loadFailed: string;
+            updateFailed: string;
+            channelEmail: string;
+            channelPush: string;
+            opened: string;
+            clicked: string;
+            notDelivered: string;
+        };
         title: string;
         permissionDenied: string;
         notSupported: string;
@@ -2969,6 +3328,13 @@ interface SDKMessages {
         pushDescription: string;
         deviceNote: string;
         prefsSaved: string;
+        prefsSaveFailed: string;
+        yourTitle: string;
+        yourDescription: string;
+        defaultsTitle: string;
+        defaultsDescription: string;
+        requiredLabel: string;
+        requiredHint: string;
         loadingPrefs: string;
         categories: {
             workspace: string;
@@ -3237,6 +3603,97 @@ type Level4 = {
 /** Union of all valid translation key paths (e.g. "settings.titles.profile") */
 type TranslationKey = Level2 | Level3 | Level4;
 
+/**
+ * The error an invitation call throws. A plain `Error` (so every existing
+ * `catch (err) { err.message }` keeps working) carrying the server's fields
+ * as properties, so a screen can act on the shape of the refusal: open the
+ * plan picker on a seat limit, count down a resend cooldown, show which
+ * address the invitation was for.
+ */
+declare const INVITATION_ERROR_CODE: {
+    readonly NOT_FOUND: "INVITATION_NOT_FOUND";
+    readonly EXPIRED: "INVITATION_EXPIRED";
+    readonly ALREADY_HANDLED: "INVITATION_ALREADY_HANDLED";
+    readonly EMAIL_MISMATCH: "INVITATION_EMAIL_MISMATCH";
+    readonly EMAIL_NOT_VERIFIED: "EMAIL_NOT_VERIFIED";
+    readonly INVITES_DISABLED: "WORKSPACE_INVITES_DISABLED";
+    readonly RATE_LIMITED: "INVITATION_RATE_LIMITED";
+    readonly EMAIL_FAILED: "INVITATION_EMAIL_FAILED";
+    readonly SEAT_LIMIT: "SEAT_LIMIT_REACHED";
+    /** The invited or accepting account is blocked. */
+    readonly USER_BLOCKED: "USER_BLOCKED";
+    /**
+     * The organization has no usable email sender, so no invitation can be sent.
+     *
+     * This one is refused by the server's `requireEmailSender` middleware rather
+     * than by the invitation route, so the string is that middleware's
+     * (`EMAIL_SENDER_CODE.NO_SENDER_CONFIGURED`), not an invitation code. Named
+     * after it on purpose: the value is what arrives, and a prettier alias here
+     * would simply never match.
+     */
+    readonly NO_SENDER_CONFIGURED: "NO_SENDER_CONFIGURED";
+};
+type InvitationErrorCode = (typeof INVITATION_ERROR_CODE)[keyof typeof INVITATION_ERROR_CODE];
+interface InvitationErrorFields {
+    /** The HTTP status the server answered with. */
+    status: number;
+    /** A stable code, from the body when the server sent one, else derived from the status. */
+    code: string;
+    /** On a 402: members plus pending invitations, and the ceiling they hit. */
+    currentUserCount?: number;
+    limit?: number;
+    /** On a resend's 429: seconds until the cooldown ends. */
+    retryAfterSeconds?: number;
+    /** On an email mismatch: the invited address, scrambled. */
+    invitedEmail?: string;
+    /** On "already invited": the live invitation, so the caller can offer resend. */
+    invitationId?: string;
+    /** On "already handled": the row's status. */
+    invitationStatus?: string;
+}
+type InvitationError = Error & InvitationErrorFields;
+/** True when an unknown thrown value is an invitation error carrying a status. */
+declare function isInvitationError(err: unknown): err is InvitationError;
+
+/**
+ * The admin's ordering: pending first, then newest first within a status. An
+ * admin should see what lapsed, so nothing is dropped here.
+ */
+declare function sortInvitations(rows: IWorkspaceInvitation[]): IWorkspaceInvitation[];
+/** Pending and not past its expiry: something the invitee can still accept or decline. */
+declare function isInvitationActionable(row: IWorkspaceInvitation, now?: Date): boolean;
+/**
+ * The invitee's list: "a list of things you can act on should contain only
+ * things you can act on". The server already filters, this keeps a stale
+ * client list honest between refreshes.
+ */
+declare function actionableInvitations(rows: IWorkspaceInvitation[], now?: Date): IWorkspaceInvitation[];
+/** Pending, past its expiry, not yet swept: shown as expired by the admin's list. */
+declare function isInvitationLapsed(row: IWorkspaceInvitation, now?: Date): boolean;
+declare function workspaceNameOf(row: IWorkspaceInvitation): string;
+declare function workspaceIdOf(row: IWorkspaceInvitation): string;
+/** The inviter's display name, or null when their account is gone. */
+declare function inviterNameOf(row: IWorkspaceInvitation): string | null;
+/**
+ * Seconds until a row may be resent, zero when it may. The cooldown itself is
+ * the server's rule and stays there: this counts down to the `resendAvailableAt`
+ * the server puts on every pending row, so the button cannot unlock a second
+ * before the endpoint stops answering 429. A row without the field (a server
+ * older than it) reports zero, leaving that 429 as the only authority.
+ */
+declare function resendCooldownSeconds(row: IWorkspaceInvitation, now?: Date): number;
+
+/** Park a token for `orgId`. A malformed token is ignored rather than stored. */
+declare function parkPendingInvite(token: string, orgId: string): void;
+/**
+ * The parked token for `orgId`, or null when there is none, it is older than a
+ * day, or it belongs to another org. Does not clear: the flow clears it on a
+ * terminal answer (accepted, declined, expired, handled), never on a network
+ * error, so a retry stays possible.
+ */
+declare function readPendingInvite(orgId: string, now?: number): string | null;
+declare function clearPendingInvite(): void;
+
 /** Props passed to the custom loadingComponent render function. */
 interface LoadingProps {
     /** Human-readable, locale-aware message describing what's happening */
@@ -3430,6 +3887,8 @@ interface SDKUIConfig {
             remove?: boolean;
             /** Seat usage / seat pricing block above the member list. */
             seatPricing?: boolean;
+            /** The pending-invitations list (with resend and revoke) under the invite form. */
+            invitations?: boolean;
         };
         /** Subscription screen — hide billing actions. */
         subscription?: {
@@ -3757,7 +4216,7 @@ interface SaaSOSProviderProps extends IOsState {
 }
 declare const SaaSOSProvider: React__default.FC<SaaSOSProviderProps>;
 
-interface IProps$2 {
+interface IProps$3 {
     children: React.ReactNode;
     /** Optional component/element to show while auth status is still loading. */
     loadingComponent?: React.ReactNode;
@@ -3791,7 +4250,7 @@ interface IProps$2 {
  * ```
  */
 declare const WhenAuthenticated: {
-    (props: IProps$2): React$1.ReactNode;
+    (props: IProps$3): React$1.ReactNode;
     displayName: string;
 };
 /**
@@ -3839,13 +4298,134 @@ declare const WhenAuthenticated: {
  * ```
  */
 declare const WhenUnauthenticated: {
-    (props: IProps$2): React$1.ReactNode;
+    (props: IProps$3): React$1.ReactNode;
     displayName: string;
 };
 
+interface PendingInvitationsProps {
+    /** Extra classes for the root element. */
+    className?: string;
+    /** Heading text. Defaults to the translated title; set to null to hide. */
+    title?: string | null;
+    /** Sub-heading under the title. Defaults to the translated description; set to null to hide. */
+    description?: string | null;
+    /** Text shown when nothing is waiting. Defaults to the translated label. */
+    emptyLabel?: string;
+    /** Render nothing at all when nothing is waiting (for a host that has its own empty state). */
+    hideWhenEmpty?: boolean;
+    /** Switch to the workspace after accepting. Defaults to `true`. */
+    switchOnAccept?: boolean;
+    /** Called after an invitation is accepted, with the workspace joined. */
+    onAccepted?: (workspace: IWorkspace) => void;
+}
+/**
+ * The signed-in user's pending workspace invitations, with Accept and
+ * Decline. Rendered by default inside the workspace switcher's empty state,
+ * so an invite-only app's new user lands on their invitations rather than on
+ * "No workspaces available"; place it on your own no-workspace screen too.
+ * For a fully custom UI, use `useMyInvitations()`.
+ */
+declare function PendingInvitations({ className, title, description, emptyLabel, hideWhenEmpty, switchOnAccept, onAccepted, }: PendingInvitationsProps): React$1.JSX.Element | null;
+
+interface IProps$2 {
+    children: React__default.ReactNode;
+    /** Optional content while the list resolves. */
+    loadingComponent?: React__default.ReactNode;
+    /** Optional content when nothing is waiting. */
+    fallbackComponent?: React__default.ReactNode;
+}
+/**
+ * Renders children only when the signed-in user has a pending workspace
+ * invitation. The gate for an invite-only app's onboarding: show the
+ * invitations screen when there is something to accept, the empty state
+ * otherwise. Nothing renders while signed out.
+ */
+declare const WhenPendingInvitations: (props: IProps$2) => React__default.ReactNode;
+
+interface UseMyInvitations {
+    /** The invitations the signed-in user can act on: pending and not expired. */
+    invitations: IWorkspaceInvitation[];
+    /** True while the list is loading (false when signed out: there is nothing to load). */
+    loading: boolean;
+    /** Error message from the last list, accept or decline, if any. */
+    error: string | null;
+    /** The invitation id being accepted or declined, or null. */
+    busy: string | null;
+    /** Re-fetch the list. */
+    refresh: () => Promise<void>;
+    /**
+     * Accept: joins the workspace and returns it. Null only when a second tab
+     * accepted the same invitation a moment earlier and its membership write
+     * is still in flight; the workspace list refreshes either way.
+     *
+     * Pass the invitation link's `token` if you built your own landing page from
+     * it: the link proves the address, so an account that has not verified its
+     * email separately is still let in.
+     */
+    accept: (invitationId: string, options?: {
+        token?: string;
+    }) => Promise<IWorkspace | null>;
+    /** Decline. */
+    decline: (invitationId: string) => Promise<void>;
+}
+/**
+ * The invitee's own invitations, across workspaces. Empty (and not loading)
+ * while signed out; fetched once the session is authenticated and shared by
+ * every consumer of the same org (one request per page load, not one per
+ * component). This is the server-side truth the invite link is only a shortcut
+ * to: a user whose link expired, or who signed in from another device, still
+ * sees what is waiting.
+ */
+declare function useMyInvitations(): UseMyInvitations;
+
+interface UseWorkspaceInvitations {
+    /** Every invitation of the workspace, pending first, newest first within a status. */
+    invitations: IWorkspaceInvitation[];
+    /** The rows still pending (and billing a seat). */
+    pendingCount: number;
+    /** True while the list is loading. */
+    loading: boolean;
+    /** Error message from the last list, resend or revoke, if any. */
+    error: string | null;
+    /** The invitation id being resent or revoked, or null. */
+    busy: string | null;
+    /** Re-fetch the list. */
+    refresh: () => Promise<void>;
+    /** Send an invitation again. Throws the invitation error (429 carries `retryAfterSeconds`). */
+    resend: (invitationId: string) => Promise<IWorkspaceInvitation>;
+    /** Withdraw a pending invitation. */
+    revoke: (invitationId: string) => Promise<void>;
+}
+/**
+ * The admin's view of a workspace's invitations: the list, and resend and
+ * revoke on it. Needs `MEMBERS_VIEW` for the list and `MEMBERS_INVITE` for the
+ * actions. Pass `null` to render nothing (no request is made).
+ */
+declare function useWorkspaceInvitations(workspaceId: string | null | undefined): UseWorkspaceInvitations;
+
+/** What `signOut` accepts. */
+interface SignOutOptions {
+    /** Revoke every session this user has, on every device, not just this one. */
+    everywhere?: boolean;
+}
+/**
+ * What `signOut` will actually be handed.
+ *
+ * `onClick={signOut}` is the documented pattern (README), and React hands an
+ * event to it. An all-optional options type is not assignable from an event, so
+ * typing the parameter as `SignOutOptions` alone would turn every one of those
+ * call sites into a compile error - a code change demanded in exchange for a
+ * security fix, which is how a security fix goes unadopted. So the event shape
+ * is accepted and ignored. `{ nativeEvent }` rather than React's own type
+ * because this module has no reason to import React.
+ */
+type SignOutArg = SignOutOptions | {
+    nativeEvent: unknown;
+} | undefined;
+
 declare function useSaaSAuth(): {
     signIn: (returnUrl?: string) => Promise<void>;
-    signOut: () => Promise<void>;
+    signOut: (options?: SignOutArg) => Promise<void>;
     openWorkspaceSettings: (section?: WorkspaceSettingsSection) => void;
     openCreditStore: () => void;
     openPlanPicker: () => void;
@@ -4308,6 +4888,117 @@ interface SessionsProps {
  */
 declare function Sessions({ className, title, description, showSignOut, signOutLabel, emptyLabel, }: SessionsProps): React$1.JSX.Element;
 
+/** Memoized NotificationsApi instance. Recreates only when serverUrl/version change. */
+declare function useNotificationsApi(): NotificationsApi;
+
+interface UseNotificationsOptions {
+    /**
+     * Whose items: a workspace id, `'current'` for the selected workspace,
+     * `'none'` for the account notices that belong to no workspace, or omitted
+     * for everything the user has been sent.
+     */
+    workspaceId?: NotificationScope | 'current';
+    /** Items per page. Defaults to 20, at most 100. */
+    pageSize?: number;
+    /**
+     * How often to check for new items while the tab is visible, in ms.
+     * Defaults to 60 000; 0 turns polling off. Still runs with `live`, as the
+     * fallback when the live connection is down.
+     */
+    pollIntervalMs?: number;
+    /**
+     * Hear about new and changed items the moment they happen, over one shared
+     * connection per tab. Defaults to true.
+     */
+    live?: boolean;
+}
+interface UseNotifications {
+    /** Loaded items, newest first, archived ones left out. */
+    notifications: INotificationItem[];
+    /** The loaded items not yet read. More may be on later pages: see `counts`. */
+    unread: INotificationItem[];
+    /** Server counts for the whole scope, not just what is loaded. */
+    counts: NotificationCounts;
+    /** True while the first page is loading. */
+    loading: boolean;
+    loadingMore: boolean;
+    hasMore: boolean;
+    /** Error message from the last load or action, if any. */
+    error: string | null;
+    refresh: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    /** Read in the inbox. A no-op for an item already read. */
+    markRead: (id: string) => Promise<void>;
+    markUnread: (id: string) => Promise<void>;
+    /** Out of the list; it stays in the user's history. */
+    archive: (id: string) => Promise<void>;
+    markAllRead: () => Promise<void>;
+    /** The inbox was opened: clears the "new" state without reading anything. */
+    markSeen: () => Promise<void>;
+}
+/**
+ * The signed-in user's notification inbox: everything the app has sent them,
+ * by email, push or both, one item per notification. Empty (and not loading)
+ * while signed out. Shared by every consumer of the same org and scope, so a
+ * bell and an inbox page are one request and a read in either updates both.
+ *
+ * Headless; `<NotificationBell />` and `<NotificationInbox />` are built on it.
+ */
+declare function useNotifications(options?: UseNotificationsOptions): UseNotifications;
+
+interface NotificationInboxProps extends UseNotificationsOptions {
+    /** Extra classes for the root element. */
+    className?: string;
+    /** Heading text. Defaults to the translated title; set to null to hide. */
+    title?: string | null;
+    /** Sub-heading under the title. Defaults to the translated description; null to hide. */
+    description?: string | null;
+    /** Show the All / Unread switch. Defaults to true. */
+    showFilter?: boolean;
+    /**
+     * Called when an item is clicked, after it is marked read. Defaults to
+     * opening its `link` in the current tab when it has one. Pass your
+     * router's navigation here for an app path (`item.link` starting with
+     * `/`) to avoid a full page load.
+     */
+    onSelect?: (item: INotificationItem) => void;
+    /** Text shown when there is nothing to list. */
+    emptyLabel?: string;
+    /** Mark everything seen once the inbox has shown it. Defaults to true. */
+    markSeenOnView?: boolean;
+    /** Tighter spacing, for a popover. */
+    compact?: boolean;
+}
+/**
+ * A ready-made notification inbox: everything the app has sent the signed-in
+ * user, one item per notification however it was delivered, with read state,
+ * archive and what each channel did. Scoped to the current user; pass
+ * `workspaceId` for one workspace's items.
+ *
+ * For a fully custom UI, use the `useNotifications()` hook.
+ */
+declare function NotificationInbox({ className, title, description, showFilter, onSelect, emptyLabel, markSeenOnView, compact, ...options }: NotificationInboxProps): React$1.JSX.Element;
+
+interface NotificationBellProps extends UseNotificationsOptions {
+    /** Extra classes for the bell button. */
+    className?: string;
+    /** Which edge of the bell the panel lines up with. Defaults to `end`. */
+    align?: 'start' | 'center' | 'end';
+    /** Props for the inbox inside the panel (title, onSelect, empty text...). */
+    inboxProps?: Omit<NotificationInboxProps, keyof UseNotificationsOptions | 'compact'>;
+    /** Largest number the badge shows before it reads "99+". Defaults to 99. */
+    maxCount?: number;
+}
+/**
+ * A bell with the unread count, opening the inbox in a panel. Opening it
+ * marks what is there as seen, which clears the badge's highlight without
+ * reading anything; items are read when opened or clicked.
+ *
+ * Shares its data with any `<NotificationInbox />` or `useNotifications()`
+ * for the same scope, so a read in one updates the other.
+ */
+declare function NotificationBell({ className, align, inboxProps, maxCount, ...options }: NotificationBellProps): React$1.JSX.Element;
+
 interface IProps {
     slug: string;
     children: React.ReactNode;
@@ -5277,7 +5968,10 @@ declare function useUserFeatures(): {
  * - `deleteWorkspace(workspaceId)`: Function to delete a workspace (owner only)
  * - `getWorkspace(workspaceId)`: Function to fetch a specific workspace
  * - `getUsers(workspaceId)`: Function to fetch users in a workspace
- * - `addUser(workspaceId, email, role)`: Function to add a user to a workspace
+ * - `addUser(workspaceId, email, role)`: Add an EXISTING account to a workspace (404 when the address has none)
+ * - `inviteMember(workspaceId, email, role, options?)`: Invite an email address that may have no account yet
+ * - `listInvitations(workspaceId)`, `resendInvitation(workspaceId, id)`, `revokeInvitation(workspaceId, id)`: The admin's side of invitations
+ * - `myInvitations()`, `acceptInvitation(id, { token? })`, `declineInvitation(id)`, `previewInvitation(token)`: The invitee's side
  * - `removeUser(workspaceId, userId)`: Function to remove a user from a workspace
  * - `updateUser(workspaceId, userId, config)`: Function to update a user in a workspace
  * - `getProfile()`: Function to fetch current user profile
@@ -5395,6 +6089,21 @@ declare const useSaaSWorkspaces: () => {
         permissions: Record<string, string[]>;
     }) => Promise<unknown>;
     updateWorkspacePermissions: (workspaceId: string, permissions: Record<string, string[]>) => Promise<unknown>;
+    listInvitations: (workspaceId: string) => Promise<IWorkspaceInvitation[]>;
+    inviteMember: (workspaceId: string, email: string, role: string, options?: {
+        landingUrl?: string;
+    }) => Promise<IWorkspaceInvitation>;
+    resendInvitation: (workspaceId: string, invitationId: string) => Promise<IWorkspaceInvitation>;
+    revokeInvitation: (workspaceId: string, invitationId: string) => Promise<void>;
+    myInvitations: () => Promise<IWorkspaceInvitation[]>;
+    acceptInvitation: (invitationId: string, options?: {
+        token?: string;
+    }) => Promise<{
+        invitation: IWorkspaceInvitation;
+        workspace: IWorkspace | null;
+    }>;
+    declineInvitation: (invitationId: string) => Promise<IWorkspaceInvitation>;
+    previewInvitation: (token: string) => Promise<IWorkspaceInvitationPreview>;
     workspaces: IWorkspace[];
     loading: boolean;
     error: string | null;
@@ -6166,7 +6875,8 @@ declare const useUsageLogs: (workspaceId: string | null | undefined, quotaSlug?:
 
 /**
  * Hook to get the credit balance for a workspace.
- * Automatically fetches when workspaceId changes.
+ * Automatically fetches when workspaceId changes, and refetches whenever
+ * `invalidateCreditBalance()` is called (after a consume or a purchase).
  *
  * @param workspaceId - The workspace ID. Can be null/undefined to disable fetching.
  * @returns { balance, loading, error, refetch }
@@ -6460,6 +7170,12 @@ declare function useSeatStatus(workspace: {
     billingCurrency?: string | null;
 } | null, options?: {
     settingsMaxUsers?: number | null;
+    /**
+     * Live pending invitations. Each one holds a seat until it is answered,
+     * and the server counts them against the ceiling, so leaving them out
+     * offers an invite form that can only answer 402.
+     */
+    pendingInvitations?: number;
 }): SeatStatus;
 
 interface BetaFormProps {
@@ -6778,5 +7494,5 @@ declare class WorkspaceSettingsManager {
 }
 declare const workspaceSettingsManager: WorkspaceSettingsManager;
 
-export { ApiVersion, AuthApi, AuthStatus, BBAction, BBScreen, BBStatus, BB_PARAM, BaseApi, BetaForm, BillingIntervals, BuildBaseBadge, SaaSOSProvider as BuildBaseProvider, CURRENCY_DISPLAY, CURRENCY_FLAG, ConnectMcpGuide, ConnectedAgents, ConnectedAgentsApi, CreditActionsProvider, CreditBalance, CreditBalanceContextProvider, CreditBucketSource, CreditBucketStatus, CreditStorePage, CreditTransactionType, DEFAULT_ROLE_PERMISSIONS, Devices, DevicesApi, DunningState, EmptyState, EventEmitter, FullScreenLoader, InvoiceStatuses, LoadingState, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, PUSH_SERVICE_WORKER_SCRIPT, Permission, PricingPage, PushApi, PushNotificationProvider, QuotaUsageContextProvider, SDKEvent, SETTINGS_SCREENS, SUPPORTED_LOCALES, SaaSOSProvider, SectionHeader, Sessions, SessionsApi, SettingsApi, SettingsScreen, SidebarNavItem, SidebarNavSection, StatusBanner, SubscriptionContextProvider, SubscriptionItemType, SubscriptionStatus, UserApi, WhenAuthenticated, WhenCreditsAvailable, WhenCreditsExhausted, WhenCreditsLow, WhenNoSubscription, WhenNotTrialing, WhenPermission, WhenQuotaAvailable, WhenQuotaExhausted, WhenQuotaOverage, WhenQuotaThreshold, WhenRoles, WhenSubscription, WhenSubscriptionToPlans, WhenTrialEnding, WhenTrialing, WhenUnauthenticated, WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, WhenWorkspaceRoles, WorkspaceApi, WorkspaceSwitcher, calculateBillableSeats, calculateSeatOverageCents, calculateTotalSubscriptionCents, cleanBBParams, clearAuthIntent, coerceBadgeRef, consumeAuthIntent, createBBUrl, createCheckoutRedirectUrls, createCreditPurchaseRedirectUrls, eventEmitter, fillMcpTemplate, formatCents, formatMinorAmountIntl, formatOverageRate, formatOverageRateWithLabel, formatQuotaIncludedOverage, formatQuotaWithPrice, getAvailableCurrenciesFromPlans, getBasePriceCents, getBillingIntervalAndCurrencyFromPriceId, getCurrencyDecimals, getCurrencyFlag, getCurrencySymbol, getDisplayCurrency, getPerSeatPriceCents, getPricingVariant, getQuotaDisplayValue, getQuotaDisplayWithVariant, getQuotaOverageCents, getQuotaUnitLabelFromName, getSeatPricing, getStripePriceIdForInterval, hasPermission, invalidateCreditBalance, invalidateQuotaUsage, invalidateSubscription, isZeroDecimalCurrency, mcpServerKey, mergeUIConfig, minorAmountToDisplay, readBBParams, resolveMaxUsers, resolvePermissions, safeRedirect, saveAuthIntent, useAllQuotaUsage, useBillingPortal, useCancelSubscription, useConnectedAgents, useConnectedAgentsApi, useConsumeCredits, useCreateCheckoutSession, useCreditBalance, useCreditBalanceContext, useCreditPackages, useCreditTransactions, useDevices, useDevicesApi, useExpiringCredits, useFullScreenLoader, useInvoice, useInvoices, useMcpConnection, usePermissions, usePlanGroup, usePlanGroupVersions, usePublicCreditPackages, usePublicPlanGroupVersion, usePublicPlans, usePurchaseCredits, usePushNotifications, useQuotaUsageContext, useQuotaUsageStatus, useRecordUsage, useResumeSubscription, useSaaSAuth, useSaaSOs, useSaaSSettings, useSaaSWorkspaces, useSeatStatus, useSessions, useSessionsApi, useSubscription, useSubscriptionContext, useSubscriptionManagement, useTranslation, useTrialStatus, useUIConfig, useUIVisibility, useUpdateSubscription, useUsageLogs, useUserAttributes, useUserFeatures, validateInvite, validateRedirectUrl, workspaceSettingsManager };
-export type { BBActionType, BBScreenType, BBStatusType, BadgeHrefOptions, BetaFormData, BetaFormResponse, BillingInterval, BuildBaseBadgeProps, BuildBaseBadgeSize, BuildBaseBadgeTheme, BuildBaseBadgeVariant, SaaSOSProviderProps as BuildBaseProviderProps, CheckoutResult, ConnectMcpGuideProps, ConnectedAgentsProps, CreditActionsDetails, CreditBalanceContextValue, CreditBalanceDetails, CreditBucketSourceType, CreditBucketStatusType, CreditStorePageDetails, CreditTransactionTypeValue, DevicesProps, DunningStateType, EmptyStateProps, EventData, EventType, FormatQuotaWithPriceOptions, FullScreenLoaderProps, GetCheckoutStripeParams, IAllQuotaUsageResponse, IBaseApiConfig, IBasePricing, IBetaConfig, ICheckoutSessionRequest, ICheckoutSessionResponse, ICheckoutStripeOptions, IConnectedAgent, IConsumeCreditsRequest, IConsumeCreditsResponse, ICreditBalance, ICreditBucket, ICreditBucketsQuery, ICreditBucketsResponse, ICreditPackage, ICreditPackagePricingVariant, ICreditPurchaseRequest, ICreditPurchaseResponse, ICreditTransaction, ICreditTransactionsQuery, ICreditTransactionsResponse, IDeviceView, IEventCallbacks, IExpiringCreditsResponse, IInvoice, IInvoiceListResponse, IInvoiceResponse, IIpInfoLite, IOsConfig, IOsState, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPricingVariant, IPublicCreditPackage, IPublicCreditPackagesResponse, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaOveragePriceIdsByInterval, IQuotaOveragesByInterval, IQuotaUsageStatus, IQuotaUsageStatusResponse, IRecordUsageRequest, IRecordUsageResponse, ISessionView, ISettings, IStripePricesByInterval, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, IUsageLogEntry, IUsageLogsQuery, IUsageLogsResponse, IUser, IWorkspace, InviteBlockReason, InviteValidation, InvoiceStatus, InvoiceStatusType, LoadingProps, LoadingStateProps, MaxUsersConfig, McpClientGuide, McpConnectionConfig, NotificationData, NotificationEvent, NotificationResult, OnWorkspaceChangeParams, PartialSDKMessages, PermissionContext, PermissionKey, PlanVersionWithPricingVariants, PricingPageDetails, PricingPageProps, QuotaDisplayValue, QuotaDisplayWithOverage, QuotaUsageContextValue, RedirectValidationOptions, RolePermissionMap, SDKLocale, SDKMessages, SDKUIConfig, SaaSOSProviderProps, SeatStatus, SectionHeaderProps, SessionsProps, SettingsManagerState, SidebarNavItemProps, SidebarNavSectionProps, StatusBannerProps, StatusBannerVariant, SubscriptionContextValue, SubscriptionItemTypeValue, SubscriptionStatusType, TranslationKey, TrialStatus, UseConnectedAgents, UseDevices, UseSessions, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceSettingsSection, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };
+export { ApiVersion, AuthApi, AuthStatus, BBAction, BBScreen, BBStatus, BB_PARAM, BaseApi, BetaForm, BillingIntervals, BuildBaseBadge, SaaSOSProvider as BuildBaseProvider, CURRENCY_DISPLAY, CURRENCY_FLAG, ConnectMcpGuide, ConnectedAgents, ConnectedAgentsApi, CreditActionsProvider, CreditBalance, CreditBalanceContextProvider, CreditBucketSource, CreditBucketStatus, CreditStorePage, CreditTransactionType, DEFAULT_ROLE_PERMISSIONS, Devices, DevicesApi, DunningState, EmptyState, EventEmitter, FullScreenLoader, INVITATION_ERROR_CODE, InvoiceStatuses, LoadingState, NotificationBell, NotificationInbox, NotificationsApi, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, PUSH_SERVICE_WORKER_SCRIPT, PendingInvitations, Permission, PricingPage, PushApi, PushNotificationProvider, QuotaUsageContextProvider, SDKEvent, SETTINGS_SCREENS, SUPPORTED_LOCALES, SaaSOSProvider, SectionHeader, Sessions, SessionsApi, SettingsApi, SettingsScreen, SidebarNavItem, SidebarNavSection, StatusBanner, SubscriptionContextProvider, SubscriptionItemType, SubscriptionStatus, UserApi, WhenAuthenticated, WhenCreditsAvailable, WhenCreditsExhausted, WhenCreditsLow, WhenNoSubscription, WhenNotTrialing, WhenPendingInvitations, WhenPermission, WhenQuotaAvailable, WhenQuotaExhausted, WhenQuotaOverage, WhenQuotaThreshold, WhenRoles, WhenSubscription, WhenSubscriptionToPlans, WhenTrialEnding, WhenTrialing, WhenUnauthenticated, WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, WhenWorkspaceRoles, WorkspaceApi, WorkspaceSwitcher, actionableInvitations, calculateBillableSeats, calculateSeatOverageCents, calculateTotalSubscriptionCents, cleanBBParams, clearAuthIntent, clearPendingInvite, coerceBadgeRef, consumeAuthIntent, createBBUrl, createCheckoutRedirectUrls, createCreditPurchaseRedirectUrls, eventEmitter, fillMcpTemplate, formatCents, formatMinorAmountIntl, formatOverageRate, formatOverageRateWithLabel, formatQuotaIncludedOverage, formatQuotaWithPrice, getAvailableCurrenciesFromPlans, getBasePriceCents, getBillingIntervalAndCurrencyFromPriceId, getCurrencyDecimals, getCurrencyFlag, getCurrencySymbol, getDisplayCurrency, getPerSeatPriceCents, getPricingVariant, getQuotaDisplayValue, getQuotaDisplayWithVariant, getQuotaOverageCents, getQuotaUnitLabelFromName, getSeatPricing, getStripePriceIdForInterval, hasPermission, invalidateCreditBalance, invalidateQuotaUsage, invalidateSubscription, inviterNameOf, isInvitationActionable, isInvitationError, isInvitationLapsed, isZeroDecimalCurrency, mcpServerKey, mergeUIConfig, minorAmountToDisplay, parkPendingInvite, readBBParams, readPendingInvite, resendCooldownSeconds, resolveMaxUsers, resolvePermissions, safeRedirect, saveAuthIntent, sortInvitations, useAllQuotaUsage, useBillingPortal, useCancelSubscription, useConnectedAgents, useConnectedAgentsApi, useConsumeCredits, useCreateCheckoutSession, useCreditBalance, useCreditBalanceContext, useCreditPackages, useCreditTransactions, useDevices, useDevicesApi, useExpiringCredits, useFullScreenLoader, useInvoice, useInvoices, useMcpConnection, useMyInvitations, useNotifications, useNotificationsApi, usePermissions, usePlanGroup, usePlanGroupVersions, usePublicCreditPackages, usePublicPlanGroupVersion, usePublicPlans, usePurchaseCredits, usePushNotifications, useQuotaUsageContext, useQuotaUsageStatus, useRecordUsage, useResumeSubscription, useSaaSAuth, useSaaSOs, useSaaSSettings, useSaaSWorkspaces, useSeatStatus, useSessions, useSessionsApi, useSubscription, useSubscriptionContext, useSubscriptionManagement, useTranslation, useTrialStatus, useUIConfig, useUIVisibility, useUpdateSubscription, useUsageLogs, useUserAttributes, useUserFeatures, useWorkspaceInvitations, validateInvite, validateRedirectUrl, workspaceIdOf, workspaceNameOf, workspaceSettingsManager };
+export type { BBActionType, BBScreenType, BBStatusType, BadgeHrefOptions, BetaFormData, BetaFormResponse, BillingInterval, BuildBaseBadgeProps, BuildBaseBadgeSize, BuildBaseBadgeTheme, BuildBaseBadgeVariant, SaaSOSProviderProps as BuildBaseProviderProps, CheckoutResult, ConnectMcpGuideProps, ConnectedAgentsProps, CreditActionsDetails, CreditBalanceContextValue, CreditBalanceDetails, CreditBucketSourceType, CreditBucketStatusType, CreditStorePageDetails, CreditTransactionTypeValue, DevicesProps, DunningStateType, EmptyStateProps, EventData, EventType, FormatQuotaWithPriceOptions, FullScreenLoaderProps, GetCheckoutStripeParams, IAllQuotaUsageResponse, IBaseApiConfig, IBasePricing, IBetaConfig, ICheckoutSessionRequest, ICheckoutSessionResponse, ICheckoutStripeOptions, IConnectedAgent, IConsumeCreditsRequest, IConsumeCreditsResponse, ICreditBalance, ICreditBucket, ICreditBucketsQuery, ICreditBucketsResponse, ICreditPackage, ICreditPackagePricingVariant, ICreditPurchaseRequest, ICreditPurchaseResponse, ICreditTransaction, ICreditTransactionsQuery, ICreditTransactionsResponse, IDeviceView, IEventCallbacks, IExpiringCreditsResponse, IInvoice, IInvoiceListResponse, IInvoiceResponse, IIpInfoLite, INotificationItem, IOsConfig, IOsState, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPricingVariant, IPublicCreditPackage, IPublicCreditPackagesResponse, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaOveragePriceIdsByInterval, IQuotaOveragesByInterval, IQuotaUsageStatus, IQuotaUsageStatusResponse, IRecordUsageRequest, IRecordUsageResponse, ISessionView, ISettings, IStripePricesByInterval, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, IUsageLogEntry, IUsageLogsQuery, IUsageLogsResponse, IUser, IWorkspace, IWorkspaceInvitation, IWorkspaceInvitationPreview, IWorkspaceInvitationStatus, InvitationError, InvitationErrorCode, InvitationErrorFields, InviteBlockReason, InviteValidation, InvoiceStatus, InvoiceStatusType, LoadingProps, LoadingStateProps, MaxUsersConfig, McpClientGuide, McpConnectionConfig, MyNotificationPreferences, NotificationBellProps, NotificationChannelPreference, NotificationCounts, NotificationData, NotificationEvent, NotificationInboxProps, NotificationListParams, NotificationPage, NotificationResult, NotificationScope, OnWorkspaceChangeParams, PartialSDKMessages, PendingInvitationsProps, PermissionContext, PermissionKey, PlanVersionWithPricingVariants, PricingPageDetails, PricingPageProps, QuotaDisplayValue, QuotaDisplayWithOverage, QuotaUsageContextValue, RedirectValidationOptions, RolePermissionMap, SDKLocale, SDKMessages, SDKUIConfig, SaaSOSProviderProps, SeatStatus, SectionHeaderProps, SessionsProps, SettingsManagerState, SidebarNavItemProps, SidebarNavSectionProps, SignOutOptions, StatusBannerProps, StatusBannerVariant, SubscriptionContextValue, SubscriptionItemTypeValue, SubscriptionStatusType, TranslationKey, TrialStatus, UseConnectedAgents, UseDevices, UseMyInvitations, UseNotifications, UseNotificationsOptions, UseSessions, UseWorkspaceInvitations, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceInvitationAcceptedEventData, WorkspaceInvitationDeclinedEventData, WorkspaceInvitationRevokedEventData, WorkspaceInvitationSentEventData, WorkspaceNotificationDefault, WorkspaceSettingsSection, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };