@buildbase/sdk 0.0.70 → 0.0.73

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
@@ -1036,6 +1110,16 @@ interface ISettings {
         canInviteMembers: boolean | 'admin-only';
         /** Custom role→permission mapping. Overrides SDK defaults when provided by backend. */
         permissions?: Record<string, string[]>;
+        /**
+         * The organization's own permissions, defined in the BuildBase console:
+         * `{ key: 'app:reports:export', label: 'Export reports', group: 'Reports' }`.
+         * Absent on a server from before release 23.
+         */
+        customPermissions?: {
+            key: string;
+            label: string;
+            group?: string;
+        }[];
         /** Show workspace switcher in the UI */
         showSwitcher: boolean;
         /** Max workspaces a user can own. 0 = unlimited */
@@ -1238,6 +1322,18 @@ interface AuthRequestParams {
      * Populated automatically from the tracking provider when one is mounted.
      * Omitted means unanswered, which is not the same as refused.
      */
+    /**
+     * Where the visitor came from - the click ids and campaign fields captured
+     * on their landing page, when, and where. Stored on the user the hosted
+     * pages create, so a conversion that happens later with no browser (a trial
+     * converting, a renewal) can still be joined to the ad click. Populated
+     * automatically from the attribution cookie when tracking is mounted.
+     */
+    trackingAttribution?: {
+        params: Record<string, string>;
+        capturedAt?: number;
+        landingUrl?: string;
+    };
     trackingConsent?: {
         analytics: boolean;
         marketing: boolean;
@@ -1424,6 +1520,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<{
@@ -1511,6 +1712,15 @@ declare class UserApi extends BaseApi {
     getFeatures(signal?: AbortSignal): Promise<Record<string, boolean>>;
 }
 
+/** What a member may do in a workspace, as the server resolved it. */
+interface WorkspaceMemberPermissions {
+    /** The member's role, or null when they are not a member. */
+    role: string | null;
+    /** The workspace's owner holds every permission. */
+    isOwner: boolean;
+    /** Platform keys (`workspace:*`) and the organization's own keys. */
+    permissions: string[];
+}
 /** Data passed to a notification template for merge tag replacement. */
 interface NotificationData {
     /** Push notification title. Falls back to the event name if not provided. */
@@ -1593,6 +1803,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;
@@ -1602,6 +1829,12 @@ declare class WorkspaceApi extends BaseApi {
     createWorkspace(data: {
         name: string;
         image?: string;
+        /** Where the creator came from. Stored on the workspace for conversions recorded later. */
+        trackingAttribution?: {
+            params: Record<string, string>;
+            capturedAt?: number;
+            landingUrl?: string;
+        };
     }, signal?: AbortSignal): Promise<IWorkspace>;
     updateWorkspace(id: string, data: Partial<IWorkspace>, signal?: AbortSignal): Promise<IWorkspace>;
     deleteWorkspace(id: string, signal?: AbortSignal): Promise<{
@@ -1616,6 +1849,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;
@@ -1630,6 +1918,12 @@ declare class WorkspaceApi extends BaseApi {
         permissions: Record<string, string[]>;
     }, signal?: AbortSignal): Promise<any>;
     updateWorkspacePermissions(workspaceId: string, permissions: Record<string, string[]>, signal?: AbortSignal): Promise<any>;
+    /**
+     * What the signed-in member may do in a workspace, as the server resolves
+     * it: the platform's permissions and the organization's own. A backend asks
+     * this rather than trusting a flag the browser sent.
+     */
+    getMyPermissions(workspaceId: string, signal?: AbortSignal): Promise<WorkspaceMemberPermissions>;
     getFeatures(signal?: AbortSignal): Promise<IWorkspaceFeature[]>;
     updateFeature(workspaceId: string, key: string, value: boolean, signal?: AbortSignal): Promise<IWorkspace>;
     getWorkspace(workspaceId: string, signal?: AbortSignal): Promise<IWorkspace>;
@@ -1840,17 +2134,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
@@ -1970,6 +2271,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
@@ -2472,17 +2781,45 @@ declare const Permission: {
     readonly WORKSPACE_BILLING_VIEW: "workspace:billing:view";
     readonly WORKSPACE_BILLING_MANAGE: "workspace:billing:manage";
     readonly WORKSPACE_USAGE_VIEW: "workspace:usage:view";
+    /** Record usage and spend the workspace's credits. Withheld from viewers. */
+    readonly WORKSPACE_USAGE_RECORD: "workspace:usage:record";
 };
 type PermissionKey = (typeof Permission)[keyof typeof Permission];
 type RolePermissionMap = Record<string, string[]>;
+/**
+ * Defaults for the three roles every org is seeded with, the same lists the
+ * server enforces. Servers now send each role's effective permissions in the
+ * public settings, so these apply only to a server that does not. There is no
+ * `member` entry: no one can hold that role, and `editor` had none, so an
+ * editor was shown nothing the server let them do.
+ */
 declare const DEFAULT_ROLE_PERMISSIONS: RolePermissionMap;
+/** The least privileged built-in role, used when no default is usable. */
+declare const FALLBACK_WORKSPACE_ROLE = "viewer";
+/**
+ * The role to preselect for someone joining: the org's default role when it
+ * is on the list, but never `admin`, which must be a deliberate choice. Then
+ * viewer, then any role other than admin.
+ */
+declare function pickDefaultRole(roles: readonly string[], defaultRole?: string | null): string;
 interface WorkspaceLike extends WorkspaceLike$1 {
     permissions?: Record<string, string[]>;
 }
+/**
+ * A permission the organization defined for its own application, in the
+ * BuildBase console. The server stores and resolves it exactly like a platform
+ * permission; what it means is the application's business.
+ */
+interface WorkspacePermissionDefinition {
+    key: string;
+    label: string;
+    group?: string;
+}
 interface SettingsLike {
     workspace?: {
         defaultRole?: string;
         permissions?: Record<string, string[]>;
+        customPermissions?: WorkspacePermissionDefinition[];
         canInviteMembers?: boolean | 'admin-only';
         canCreateWorkspace?: boolean | 'owner-only';
     };
@@ -2512,12 +2849,31 @@ interface PermissionContext {
  * 7. Apply setting restrictions (canInviteMembers)
  */
 declare function resolvePermissions(ctx: PermissionContext): Set<string>;
+/**
+ * What one role may do in a workspace, by the same tiers the server uses.
+ * `resolvePermissions` answers for a user; this answers for a role, which is
+ * what a screen editing the matrix needs. `applyRestrictions: false` leaves
+ * out the org's live switches (who may invite), so a screen does not write a
+ * switch's current effect into a saved override.
+ */
+declare function resolveRolePermissions(role: string, ctx: Pick<PermissionContext, 'workspace' | 'settings' | 'appPermissions'>, options?: {
+    applyRestrictions?: boolean;
+}): Set<string>;
 /**
  * Check if a user has a specific permission (or all of an array).
  * Works with both platform permissions (Permission.WORKSPACE_*) and
  * app permissions (any custom string).
  */
 declare function hasPermission(permission: string | string[], ctx: PermissionContext): boolean;
+/** Where a permission the app checks was defined. */
+declare const APP_PERMISSION_FALLBACK_GROUP = "App";
+/**
+ * Every permission this application defines, for a UI that lists them: the
+ * organization's catalogue from the console, plus any key the app passed
+ * through `defaultPermissions` that the catalogue does not name yet. Keys from
+ * the prop keep working, so adopting the console costs nothing.
+ */
+declare function appPermissionCatalogue(settings?: SettingsLike | null, appPermissions?: Record<string, string[]> | null): WorkspacePermissionDefinition[];
 
 /**
  * Push notification service worker source code.
@@ -2856,6 +3212,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;
@@ -2969,6 +3379,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;
@@ -2986,6 +3418,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;
@@ -3254,6 +3693,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 */
@@ -3447,6 +3977,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?: {
@@ -3563,6 +4095,27 @@ declare function useTranslation(): {
     messages: SDKMessages;
 };
 
+/** A consent default: what applies before the visitor has answered. */
+type ConsentDefault = 'granted' | 'denied';
+/**
+ * A consent default that depends on where the visitor is.
+ *
+ * `default` covers everyone no region rule matches. Region entries are ISO
+ * 3166-1 alpha-2 countries (`GB`), ISO 3166-2 subdivisions (`US-CA`), or `EEA`,
+ * which expands to the current member states.
+ *
+ * @example The recommended setting
+ * ```ts
+ * { default: 'granted', regions: { denied: ['EEA', 'GB', 'CH'] } }
+ * ```
+ */
+interface RegionalConsent {
+    default: ConsentDefault;
+    regions?: {
+        denied?: string[];
+        granted?: string[];
+    };
+}
 /**
  * The events the SDK fires on the app's behalf.
  *
@@ -3591,12 +4144,21 @@ interface TrackingOptions {
     /** Set false to fetch nothing and render nothing. */
     enabled?: boolean;
     /**
-     * `auto` (default) sets Consent Mode v2 to denied and waits for
-     * `setConsent`. `granted` is the app asserting it has a lawful basis
-     * already - documented as their assertion, not ours. `denied` keeps
-     * everything off.
+     * The consent default, before the visitor answers.
+     *
+     * - `auto` (default): the client's regional default from the console, when
+     *   one is set; otherwise Consent Mode v2 denied everywhere until
+     *   `consent.set()`.
+     * - `{ default, regions }`: a regional default set in code, which wins over
+     *   the console's. Resolved against the country the server saw.
+     * - `granted`: the app asserting it already has a lawful basis everywhere -
+     *   their assertion, not ours.
+     * - `denied`: nothing loads at all, not even a Consent Mode tag.
+     *
+     * Whichever default applies, `consent.set()` replaces it. The choice of
+     * default, and its lawful basis, belong to the app.
      */
-    consent?: 'auto' | 'granted' | 'denied';
+    consent?: 'auto' | 'granted' | 'denied' | RegionalConsent;
     /**
      * Fire a `page_view` on SPA navigation. Turn it off when the app's GTM
      * container already does it - double-counted pageviews is the single most
@@ -3774,7 +4336,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;
@@ -3808,7 +4370,7 @@ interface IProps$2 {
  * ```
  */
 declare const WhenAuthenticated: {
-    (props: IProps$2): React$1.ReactNode;
+    (props: IProps$3): React$1.ReactNode;
     displayName: string;
 };
 /**
@@ -3856,10 +4418,111 @@ 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. */
@@ -4155,6 +4818,7 @@ declare function usePermissions(workspace?: WorkspaceLike | null): {
     permissions: Set<string>;
     isOwner: boolean;
     role: string | null;
+    appPermissionDefinitions: WorkspacePermissionDefinition[];
 };
 
 /** Memoized ConnectedAgentsApi instance. Recreates only when serverUrl/version change. */
@@ -4345,6 +5009,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;
@@ -5314,7 +6089,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
@@ -5432,6 +6210,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;
@@ -6203,7 +6996,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 }
@@ -6480,7 +7274,8 @@ interface SeatStatus {
  * Must be used within SubscriptionContextProvider.
  *
  * @param workspace - The current workspace (needs users array, limits, billingCurrency)
- * @param options - Optional overrides (e.g. settingsMaxUsers fallback)
+ * @param options - Optional overrides. `settingsMaxUsers` defaults to the org's
+ *   `maxWorkspaceUsers` from the SDK settings, the ceiling the server enforces.
  * @returns SeatStatus — computed seat and invite information
  *
  * @example
@@ -6497,6 +7292,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 {
@@ -6815,5 +7616,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, SignOutOptions, StatusBannerProps, StatusBannerVariant, SubscriptionContextValue, SubscriptionItemTypeValue, SubscriptionStatusType, TranslationKey, TrialStatus, UseConnectedAgents, UseDevices, UseSessions, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceSettingsSection, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };
+export { APP_PERMISSION_FALLBACK_GROUP, 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, FALLBACK_WORKSPACE_ROLE, 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, appPermissionCatalogue, 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, pickDefaultRole, readBBParams, readPendingInvite, resendCooldownSeconds, resolveMaxUsers, resolvePermissions, resolveRolePermissions, 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, WorkspaceMemberPermissions, WorkspaceNotificationDefault, WorkspacePermissionDefinition, WorkspaceSettingsSection, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };