@buildbase/sdk 0.0.10 → 0.0.12

package/dist/types/index.d.ts

@@ -5,15 +5,16 @@ export { BetaForm } from './components/beta/BetaForm';
 export { WhenAuthenticated, WhenUnauthenticated } from './components/user/auth';
 export { WhenRoles, WhenWorkspaceRoles } from './components/user/role';
 export { WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, } from './components/features';
+export { AuthStatus } from './providers/auth/types';
 export { useSaaSAuth } from './providers/auth/hooks';
 export { useSaaSSettings } from './providers/os/hooks';
 export { useUserAttributes, useUserFeatures } from './providers/user/hooks';
 export { useSaaSWorkspaces } from './providers/workspace/hooks';
 export { WorkspaceSwitcher } from './providers/workspace/provider';
-export { usePlanGroup, useSubscription, useSubscriptionManagement, useUpdateSubscription, } from './providers/workspace/subscription-hooks';
+export { useCreateCheckoutSession, useInvoice, useInvoices, usePlanGroup, usePlanGroupVersions, useSubscription, useSubscriptionManagement, useUpdateSubscription, } from './providers/workspace/subscription-hooks';
 export { eventEmitter } from './providers/events';
 export type { EventData, EventType, IEventCallbacks, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData, } from './providers/events/types';
 export { default as ErrorBoundary, SDKErrorBoundary } from './components/ErrorBoundary';
 export { SDKError, createSDKError, errorHandler, handleError } from './lib/error-handler';
 export type { ErrorHandlerConfig, SDKErrorContext } from './lib/error-handler';
-export type { IPlan, IPlanGroup, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanVersion, IPlanVersionWithPlan, IQuotaValue, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, } from './api/types';
+export type { BillingInterval, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, IInvoice, IInvoiceListResponse, IInvoiceResponse, InvoiceStatus, IPlan, IPlanGroup, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionsResponse, IPlanGroupVersionWithPlans, IPlanVersion, IPlanVersionWithPlan, IQuotaValue, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, } from './api/types';

package/dist/types/lib/api-utils.d.ts

@@ -0,0 +1,164 @@
+/**
+ * API utility functions for consistent error handling and request management
+ */
+/**
+ * Check if an error is from AbortController (request was cancelled).
+ * Useful for ignoring abort errors when components unmount or requests are cancelled.
+ *
+ * @param error - The error to check
+ * @returns True if the error is an AbortError, false otherwise
+ *
+ * @example
+ * ```tsx
+ * try {
+ *   await safeFetch(url, { signal });
+ * } catch (error) {
+ *   if (isAbortError(error)) {
+ *     // Request was cancelled, ignore
+ *     return;
+ *   }
+ *   // Handle other errors
+ *   console.error('Request failed:', error);
+ * }
+ * ```
+ */
+export declare function isAbortError(error: unknown): boolean;
+/**
+ * Safely execute a fetch request with network error handling.
+ * Wraps native fetch to provide better error messages for network failures.
+ * Supports AbortSignal - when aborted, throws with name 'AbortError' (caller can use isAbortError()).
+ * In development mode, automatically logs request/response for debugging (prefixed with [SDK API]).
+ * Sensitive data (tokens, passwords) is automatically redacted from logs.
+ *
+ * @param url - The URL to fetch
+ * @param options - Optional fetch options (RequestInit), including AbortSignal
+ * @returns Promise resolving to Response object
+ * @throws {Error} Network errors with descriptive messages, or AbortError if request was aborted
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * const response = await safeFetch('/api/users');
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With abort signal
+ * const controller = new AbortController();
+ * const response = await safeFetch('/api/users', {
+ *   signal: controller.signal,
+ *   method: 'POST',
+ *   body: JSON.stringify({ name: 'John' }),
+ * });
+ *
+ * // Cancel request
+ * controller.abort();
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handle network errors
+ * try {
+ *   const response = await safeFetch('/api/users');
+ * } catch (error) {
+ *   if (isAbortError(error)) {
+ *     // Request was cancelled
+ *     return;
+ *   }
+ *   // Network error: "Network error: Please check your internet connection"
+ *   console.error(error.message);
+ * }
+ * ```
+ */
+export declare function safeFetch(url: string, options?: RequestInit): Promise<Response>;
+/**
+ * Parse JSON response with error handling.
+ * Provides better error messages if response is not valid JSON.
+ *
+ * @param response - The Response object to parse
+ * @returns Promise resolving to parsed JSON data
+ * @throws {Error} If response body is empty or not valid JSON
+ *
+ * @example
+ * ```tsx
+ * const response = await safeFetch('/api/users');
+ * const users = await parseJsonResponse<User[]>(response);
+ * ```
+ */
+export declare function parseJsonResponse<T>(response: Response): Promise<T>;
+/**
+ * Create a standardized API error from a response.
+ * Provides user-friendly error messages based on HTTP status codes.
+ *
+ * @param response - The Response object with error status
+ * @param defaultMessage - Default error message if status-specific message not available
+ * @returns Error instance with descriptive message
+ *
+ * @example
+ * ```tsx
+ * const response = await safeFetch('/api/users');
+ * if (!response.ok) {
+ *   throw createApiError(response, 'Failed to fetch users');
+ *   // Error message: "Failed to fetch users (401: Unauthorized - Please check your session)"
+ * }
+ * ```
+ */
+export declare function createApiError(response: Response, defaultMessage: string): Error;
+/**
+ * Handle API response with consistent error handling.
+ * Checks response status, parses JSON, and provides standardized error messages.
+ * This is the recommended way to handle API responses in the SDK.
+ *
+ * @param response - The Response object to handle
+ * @param defaultErrorMessage - Default error message if response is not ok
+ * @returns Promise resolving to parsed JSON data
+ * @throws {Error} If response is not ok or JSON parsing fails
+ *
+ * @example
+ * ```tsx
+ * const response = await safeFetch('/api/users');
+ * const users = await handleApiResponse<User[]>(response, 'Failed to fetch users');
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With error handling
+ * try {
+ *   const response = await safeFetch('/api/users');
+ *   const users = await handleApiResponse<User[]>(response);
+ * } catch (error) {
+ *   // Error message includes status code and descriptive text
+ *   console.error(error.message);
+ * }
+ * ```
+ */
+export declare function handleApiResponse<T>(response: Response, defaultErrorMessage?: string): Promise<T>;
+/**
+ * Fetch with timeout support.
+ * Automatically cancels request if it takes longer than specified timeout.
+ *
+ * @param url - The URL to fetch
+ * @param options - Optional fetch options (RequestInit)
+ * @param timeout - Timeout in milliseconds (default: 10000ms / 10 seconds)
+ * @returns Promise resolving to Response object
+ * @throws {Error} If request times out: "Request timeout after {timeout}ms"
+ *
+ * @example
+ * ```tsx
+ * // 5 second timeout
+ * const response = await fetchWithTimeout('/api/users', {}, 5000);
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handle timeout
+ * try {
+ *   const response = await fetchWithTimeout('/api/users', {}, 5000);
+ * } catch (error) {
+ *   if (error.message.includes('timeout')) {
+ *     console.error('Request took too long');
+ *   }
+ * }
+ * ```
+ */
+export declare function fetchWithTimeout(url: string, options?: RequestInit, timeout?: number): Promise<Response>;

package/dist/types/lib/error-handler.d.ts

@@ -55,6 +55,46 @@ declare class ErrorHandler {
     wrapSync<T extends (...args: any[]) => any>(fn: T, context: SDKErrorContext): T;
 }
 export declare const errorHandler: ErrorHandler;
+/**
+ * Convenience function to handle an error with context.
+ * Uses the global error handler instance.
+ *
+ * @param error - The error to handle (Error instance, string, or unknown)
+ * @param context - Optional context about where the error occurred
+ *
+ * @example
+ * ```tsx
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   handleError(error, {
+ *     component: 'MyComponent',
+ *     action: 'someOperation',
+ *     metadata: { userId: '123' },
+ *   });
+ * }
+ * ```
+ */
 export declare function handleError(error: Error | unknown, context?: SDKErrorContext): void;
+/**
+ * Creates a new SDKError instance with optional code and context.
+ * Useful for creating standardized errors throughout the SDK.
+ *
+ * @param message - Error message
+ * @param code - Optional error code (e.g., 'AUTH_FAILED', 'NETWORK_ERROR')
+ * @param context - Optional context about where the error occurred
+ * @param originalError - Optional original error that caused this error
+ * @returns A new SDKError instance
+ *
+ * @example
+ * ```tsx
+ * throw createSDKError(
+ *   'Failed to authenticate user',
+ *   'AUTH_FAILED',
+ *   { component: 'AuthProvider', action: 'signIn' },
+ *   originalError
+ * );
+ * ```
+ */
 export declare function createSDKError(message: string, code?: string, context?: SDKErrorContext, originalError?: Error): SDKError;
 export {};

package/dist/types/providers/auth/hooks.d.ts

@@ -1,11 +1,72 @@
+/**
+ * Main authentication hook for the SDK.
+ * Provides authentication state, user session, and auth actions.
+ *
+ * @returns An object containing:
+ * - `user`: Current authenticated user object (null if not authenticated)
+ * - `session`: Full session object with user and token (null if not authenticated)
+ * - `status`: Current authentication status (loading, redirecting, authenticating, authenticated, unauthenticated)
+ * - `isLoading`: Boolean indicating if auth state is being determined
+ * - `isAuthenticated`: Boolean indicating if user is authenticated
+ * - `isRedirecting`: Boolean indicating if redirecting to OAuth provider
+ * - `signIn()`: Function to initiate OAuth sign-in flow
+ * - `signOut()`: Function to sign out the current user
+ * - `openWorkspaceSettings(section?)`: Function to open workspace settings dialog
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { user, isAuthenticated, signIn, signOut } = useSaaSAuth();
+ *
+ *   if (!isAuthenticated) {
+ *     return <button onClick={signIn}>Sign In</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {user?.name}</p>
+ *       <button onClick={signOut}>Sign Out</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handle loading state
+ * function App() {
+ *   const { status, isLoading } = useSaaSAuth();
+ *
+ *   if (isLoading) {
+ *     return <LoadingSpinner />;
+ *   }
+ *
+ *   return <MainContent />;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Open workspace settings
+ * function SettingsButton() {
+ *   const { openWorkspaceSettings } = useSaaSAuth();
+ *
+ *   return (
+ *     <button onClick={() => openWorkspaceSettings('general')}>
+ *       Open Settings
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
 export declare function useSaaSAuth(): {
-    user: import("./types").AuthUser | undefined;
-    session: import("./types").AuthSession | null;
-    isLoading: boolean;
-    isAuthenticated: boolean;
-    isRedirecting: boolean;
-    status: import("./types").AuthStatus;
     signIn: () => Promise<void>;
     signOut: () => Promise<void>;
     openWorkspaceSettings: (section?: "profile" | "general" | "users" | "features" | "danger") => void;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isRedirecting: boolean;
+    user: import("./types").AuthUser | undefined;
+    session: import("./types").AuthSession | null;
+    status: import("./types").AuthStatus;
 };

package/dist/types/providers/auth/types.d.ts

@@ -1,10 +1,17 @@
 import type { EventData, EventType } from '../events/types';
 export declare enum AuthStatus {
     loading = "loading",
+    redirecting = "redirecting",
     authenticated = "authenticated",
     unauthenticated = "unauthenticated",
     authenticating = "authenticating"
 }
+/** Derive booleans from status (single source of truth) */
+export declare function getAuthFlags(status: AuthStatus): {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isRedirecting: boolean;
+};
 export interface AuthUser {
     id: string;
     name: string;
@@ -22,9 +29,6 @@ export interface AuthSession {
 }
 export interface IAuthState {
     session: AuthSession | null;
-    isLoading: boolean;
-    isAuthenticated: boolean;
-    isRedirecting: boolean;
     status: AuthStatus;
 }
 export interface IAuthConfig {

package/dist/types/providers/os/hooks.d.ts

@@ -1,5 +1,44 @@
 import type { ISettings } from '../types';
+/**
+ * Hook to access organization settings from the OS context.
+ * Automatically fetches settings when OS config is ready.
+ *
+ * @returns An object containing:
+ * - `settings`: Organization settings object (null if not loaded)
+ * - `getSettings(signal?)`: Function to manually fetch settings (supports AbortSignal)
+ *
+ * @example
+ * ```tsx
+ * function SettingsDisplay() {
+ *   const { settings } = useSaaSSettings();
+ *
+ *   if (!settings) return <Loading />;
+ *
+ *   return (
+ *     <div>
+ *       <p>Organization: {settings.name}</p>
+ *       <p>Theme: {settings.theme}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Manual fetch with abort signal
+ * function SettingsLoader() {
+ *   const { getSettings } = useSaaSSettings();
+ *
+ *   useEffect(() => {
+ *     const controller = new AbortController();
+ *     getSettings(controller.signal);
+ *
+ *     return () => controller.abort();
+ *   }, [getSettings]);
+ * }
+ * ```
+ */
 export declare function useSaaSSettings(): {
     settings: ISettings | null | undefined;
-    getSettings: () => Promise<ISettings | null>;
+    getSettings: (signal?: AbortSignal) => Promise<ISettings | null>;
 };

package/dist/types/providers/user/hooks.d.ts

@@ -1,4 +1,75 @@
+/**
+ * Hook to access user attributes from the UserProvider.
+ * Must be used within a UserProvider component.
+ *
+ * @returns User context object containing:
+ * - `attributes`: Record of user attribute key-value pairs
+ * - `isLoading`: Boolean indicating if attributes are being loaded
+ * - `error`: Error message string (null if no error)
+ * - `refreshAttributes()`: Function to manually refresh attributes
+ *
+ * @throws {Error} If used outside of UserProvider
+ *
+ * @example
+ * ```tsx
+ * function UserProfile() {
+ *   const { attributes, isLoading } = useUserAttributes();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   return (
+ *     <div>
+ *       <p>Plan: {attributes?.plan}</p>
+ *       <p>Company: {attributes?.company}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export declare function useUserAttributes(): import("./provider").UserContextValue;
+/**
+ * Hook to access user feature flags from the UserProvider.
+ * Must be used within a UserProvider component.
+ *
+ * @returns An object containing:
+ * - `features`: Record of feature flag key-value pairs (boolean values)
+ * - `isLoading`: Boolean indicating if features are being loaded
+ * - `error`: Error message string (null if no error)
+ * - `refreshFeatures()`: Function to manually refresh features
+ * - `isFeatureEnabled(featureId)`: Function to check if a specific feature is enabled
+ *
+ * @throws {Error} If used outside of UserProvider
+ *
+ * @example
+ * ```tsx
+ * function FeatureContent() {
+ *   const { isFeatureEnabled, isLoading } = useUserFeatures();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   if (isFeatureEnabled('premium-feature')) {
+ *     return <PremiumFeature />;
+ *   }
+ *
+ *   return <BasicFeature />;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Check multiple features
+ * function Dashboard() {
+ *   const { isFeatureEnabled } = useUserFeatures();
+ *
+ *   return (
+ *     <div>
+ *       {isFeatureEnabled('analytics') && <Analytics />}
+ *       {isFeatureEnabled('reports') && <Reports />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export declare function useUserFeatures(): {
     features: Record<string, boolean>;
     isLoading: boolean;

package/dist/types/providers/workspace/api.d.ts

@@ -1,4 +1,4 @@
-import { IPlanGroupResponse, IPlanGroupVersion, ISubscriptionResponse, ISubscriptionUpdateResponse, IUser } from '../../api/types';
+import { ICheckoutSessionRequest, ICheckoutSessionResponse, IInvoiceListResponse, IInvoiceResponse, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionsResponse, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, IUser } from '../../api/types';
 import { IOsConfig } from '../os/types';
 import type { IWorkspace, IWorkspaceFeature, IWorkspaceUser } from './types';
 export declare class WorkspaceApi {
@@ -51,14 +51,54 @@ export declare class WorkspaceApi {
      * otherwise returns the latest published group
      */
     getPlanGroup(workspaceId: string): Promise<IPlanGroupResponse>;
+    /**
+     * Get plan group for a workspace with a specific version
+     * @param workspaceId - The workspace ID
+     * @param groupVersionId - The plan group version ID to fetch
+     * @returns Plan group response with the specified version
+     */
+    getPlanGroupByVersion(workspaceId: string, groupVersionId: string): Promise<IPlanGroupResponse>;
+    /**
+     * Get current group version and available newer versions of the same group
+     * - If user has active subscription: returns their current group version + newer versions
+     * - If no subscription: returns the latest published group version
+     * Shows what's new in newer versions to help users upgrade
+     * Example: User on Group v1 (Basic Plan) can see Group v2 (Basic + Pro Plan)
+     * @param workspaceId - The workspace ID
+     * @returns Plan group versions response with currentVersion and availableVersions
+     */
+    getPlanGroupVersions(workspaceId: string): Promise<IPlanGroupVersionsResponse>;
     /**
      * Get plan group version details by ID
      * Returns the full plan group version with populated plan versions
      */
     getPlanGroupVersion(groupVersionId: string): Promise<IPlanGroupVersion>;
+    /**
+     * Create checkout session for new subscription
+     * @param workspaceId - The workspace ID
+     * @param request - Checkout session request with planVersionId and optional billing interval/URLs
+     * @returns Checkout session response with checkoutUrl to redirect user
+     */
+    createCheckoutSession(workspaceId: string, request: ICheckoutSessionRequest): Promise<ICheckoutSessionResponse>;
     /**
      * Update subscription (upgrade/downgrade)
      * Only allows plan changes within the same plan group
+     * Returns checkout session if payment is required, otherwise returns subscription update response
+     */
+    updateSubscription(workspaceId: string, request: ISubscriptionUpdateRequest): Promise<ISubscriptionUpdateResponse | ICheckoutSessionResponse>;
+    /**
+     * List invoices for a workspace subscription
+     * @param workspaceId - The workspace ID
+     * @param limit - Number of invoices to return (default: 10)
+     * @param startingAfter - Invoice ID to start after (for pagination)
+     * @returns List of invoices with pagination info
+     */
+    listInvoices(workspaceId: string, limit?: number, startingAfter?: string): Promise<IInvoiceListResponse>;
+    /**
+     * Get a single invoice by ID
+     * @param workspaceId - The workspace ID
+     * @param invoiceId - The invoice ID
+     * @returns Invoice details
      */
-    updateSubscription(workspaceId: string, planVersionId: string): Promise<ISubscriptionUpdateResponse>;
+    getInvoice(workspaceId: string, invoiceId: string): Promise<IInvoiceResponse>;
 }

package/dist/types/providers/workspace/hooks.d.ts

@@ -1,6 +1,111 @@
 import { IUser } from '../../api/types';
 import { WorkspaceSwitcher } from './provider';
 import { IWorkspace, IWorkspaceUser } from './types';
+/**
+ * Main workspace management hook for the SDK.
+ * Provides workspace state, CRUD operations, and user management.
+ *
+ * @returns An object containing:
+ * - `workspaces`: Array of all workspaces the user has access to
+ * - `currentWorkspace`: Currently selected workspace (null if none selected)
+ * - `loading`: Boolean indicating if workspaces are being fetched
+ * - `error`: Error message string (null if no error)
+ * - `refreshing`: Boolean indicating if workspaces are being refreshed in background
+ * - `switching`: Boolean indicating if workspace is being switched
+ * - `WorkspaceSwitcher`: Component for switching between workspaces
+ * - `fetchWorkspaces()`: Function to fetch all workspaces
+ * - `refreshWorkspaces()`: Function to refresh workspaces in background (non-blocking)
+ * - `setCurrentWorkspace(workspace)`: Function to set the current workspace
+ * - `resetCurrentWorkspace()`: Function to clear the current workspace
+ * - `createWorkspace(name, image?)`: Function to create a new workspace
+ * - `updateWorkspace(workspace, data)`: Function to update a workspace
+ * - `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
+ * - `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
+ * - `updateUserProfile(config)`: Function to update current user profile
+ * - `allFeatures`: Array of all available feature flags
+ * - `getFeatures()`: Function to fetch all available features
+ * - `updateFeature(workspaceId, key, value)`: Function to update a feature flag
+ *
+ * @example
+ * ```tsx
+ * function WorkspaceList() {
+ *   const { workspaces, loading, fetchWorkspaces } = useSaaSWorkspaces();
+ *
+ *   useEffect(() => {
+ *     fetchWorkspaces();
+ *   }, [fetchWorkspaces]);
+ *
+ *   if (loading) return <Loading />;
+ *
+ *   return (
+ *     <ul>
+ *       {workspaces.map(ws => (
+ *         <li key={ws._id}>{ws.name}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Create a new workspace
+ * function CreateWorkspace() {
+ *   const { createWorkspace } = useSaaSWorkspaces();
+ *
+ *   const handleCreate = async () => {
+ *     try {
+ *       await createWorkspace('My Workspace', 'https://example.com/logo.png');
+ *     } catch (error) {
+ *       console.error('Failed to create workspace:', error);
+ *     }
+ *   };
+ *
+ *   return <button onClick={handleCreate}>Create Workspace</button>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Delete workspace (owner only)
+ * function DeleteWorkspaceButton({ workspaceId }) {
+ *   const { deleteWorkspace } = useSaaSWorkspaces();
+ *
+ *   const handleDelete = async () => {
+ *     if (!confirm('Are you sure?')) return;
+ *     try {
+ *       await deleteWorkspace(workspaceId);
+ *     } catch (error) {
+ *       // Error: "Only the workspace creator can delete the workspace"
+ *       alert(error.message);
+ *     }
+ *   };
+ *
+ *   return <button onClick={handleDelete}>Delete</button>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Edge case: Workspace removed from user's access
+ * function WorkspaceContent() {
+ *   const { currentWorkspace, workspaces } = useSaaSWorkspaces();
+ *
+ *   // If current workspace is not in the list, it was removed
+ *   // The hook automatically switches to first available workspace
+ *   if (!currentWorkspace) {
+ *     return <p>No workspace selected</p>;
+ *   }
+ *
+ *   return <div>{currentWorkspace.name}</div>;
+ * }
+ * ```
+ */
 export declare const useSaaSWorkspaces: () => {
     workspaces: IWorkspace[];
     loading: boolean;