@buildbase/sdk 0.0.11 → 0.0.13

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

@@ -0,0 +1,182 @@
+/**
+ * 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>;
+/**
+ * Extract error message from a failed response.
+ * Parses JSON body and returns message/error field, or defaultMsg if not available.
+ *
+ * @param response - The Response object (typically from a failed request)
+ * @param defaultMsg - Default message if parsing fails or no message in body
+ * @returns Promise resolving to the error message string
+ *
+ * @example
+ * ```tsx
+ * const response = await safeFetch('/api/users');
+ * if (!response.ok) {
+ *   const msg = await getErrorMessage(response, 'Failed to fetch users');
+ *   throw new Error(msg);
+ * }
+ * ```
+ */
+export declare function getErrorMessage(response: Response, defaultMsg: string): Promise<string>;
+/**
+ * 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,64 @@ 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;
+/**
+ * Handle an error only if it is not an AbortError.
+ * Convenience for async code that uses AbortSignal - call this in catch and abort errors are ignored.
+ *
+ * @param error - The error that occurred
+ * @param context - Optional context about where the error occurred
+ * @returns true if error was handled, false if it was an abort error (ignored)
+ *
+ * @example
+ * ```tsx
+ * try {
+ *   await safeFetch(url, { signal });
+ * } catch (error) {
+ *   handleErrorUnlessAborted(error, { component: 'MyComponent', action: 'fetch' });
+ * }
+ * ```
+ */
+export declare function handleErrorUnlessAborted(error: Error | unknown, context?: SDKErrorContext): boolean;
+/**
+ * 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/lib/logger.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Centralized logger for SDK
+ * All console output should go through this for consistency and configurable behavior
+ */
+/**
+ * Configure the SDK logger
+ */
+export declare function configureLogger(config: {
+    enableLogging?: boolean;
+}): void;
+/**
+ * Log info (dev only, respects enableLogging)
+ */
+export declare function sdkLog(message: string, ...args: unknown[]): void;
+/**
+ * Log warning (dev only, respects enableLogging)
+ */
+export declare function sdkWarn(message: string, ...args: unknown[]): void;
+/**
+ * Log error (dev only, respects enableLogging)
+ */
+export declare function sdkLogError(message: string, ...args: unknown[]): void;
+/**
+ * Log internal/critical error - always logs.
+ * Use when the error handling system itself fails (e.g. user's onError callback throws).
+ */
+export declare function sdkError(message: string, ...args: unknown[]): void;

package/dist/types/lib/useAsyncEffect.d.ts

@@ -0,0 +1,29 @@
+import type { DependencyList } from 'react';
+export interface UseAsyncEffectOptions {
+    /**
+     * Called when the effect promise rejects (except for AbortError which is ignored).
+     */
+    onError?: (err: unknown) => void;
+}
+/**
+ * Encapsulates the AbortController + async effect pattern.
+ * Provides cancellation on cleanup and optional error handling.
+ *
+ * @param effect - Async function that receives AbortSignal for cancellation
+ * @param deps - Dependency array (same as useEffect)
+ * @param options - Optional onError callback for unhandled rejections
+ *
+ * @example
+ * ```tsx
+ * useAsyncEffect(
+ *   async (signal) => {
+ *     const response = await safeFetch(url, { signal });
+ *     const data = await response.json();
+ *     setData(data);
+ *   },
+ *   [url],
+ *   { onError: (err) => handleError(err, { component: 'MyComponent', action: 'fetch' }) }
+ * );
+ * ```
+ */
+export declare function useAsyncEffect(effect: (signal: AbortSignal) => Promise<void>, deps: DependencyList, options?: UseAsyncEffectOptions): void;

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

@@ -1,2 +1,7 @@
 import { type ClassValue } from 'clsx';
+/**
+ * Check if running in development mode.
+ * Safe for browser bundles where process may be undefined.
+ */
+export declare function isDevelopment(): boolean;
 export declare function cn(...inputs: ClassValue[]): string;

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

@@ -1,3 +1,64 @@
+/**
+ * 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(): {
     signIn: () => Promise<void>;
     signOut: () => Promise<void>;

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

@@ -1,4 +1,5 @@
 import type { EventData, EventType } from '../events/types';
+import type { IWorkspace } from '../workspace/types';
 export declare enum AuthStatus {
     loading = "loading",
     redirecting = "redirecting",
@@ -47,4 +48,15 @@ export interface IAuthCallbacks {
      * @param data - The event data (type varies based on eventType)
      */
     handleEvent?: (eventType: EventType, data: EventData) => void | Promise<void>;
+    /**
+     * Called before switching workspace (e.g. generate token, save state).
+     * Used when user clicks "Switch to" and when restoring from storage on page refresh.
+     * Switch proceeds only when this resolves; reject to abort.
+     */
+    onWorkspaceChange?: (params: OnWorkspaceChangeParams) => Promise<void>;
+}
+export interface OnWorkspaceChangeParams {
+    workspace: IWorkspace;
+    user: AuthUser | null;
+    role: string | null;
 }

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

@@ -1,5 +1,10 @@
-import type { AuthSession } from './types';
-import { AuthUser } from './types';
+import { IUser } from '../../api/types';
+import type { AuthSession, AuthUser } from './types';
+/**
+ * Map IUser from API to AuthUser for session
+ * @throws Error if user data is missing required ID or email fields
+ */
+export declare function mapIUserToAuthUser(userData: IUser, orgId: string, clientId: string): AuthUser;
 /**
  * Centralized Session Management
  * Only stores sessionId in localStorage - user data is kept in context only

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

@@ -1,2 +1,3 @@
 export declare const AUTH_TOKEN_PARAM = "code";
 export declare const AUTH_SESSION_ID_KEY = "saas-session-id";
+export declare const WORKSPACE_STORAGE_KEY = "saas-workspace-current";

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/hooks.d.ts

@@ -1,6 +1,110 @@
 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 - true when a workspace switch is in progress
+ * - `fetchWorkspaces()`: Function to fetch all workspaces
+ * - `refreshWorkspaces()`: Function to refresh workspaces in background (non-blocking)
+ * - `setCurrentWorkspace(workspace)`: Function to set the current workspace (direct, no callback)
+ * - `switchToWorkspace(workspace)`: Centralized switch - calls onWorkspaceChange first, then sets 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;
@@ -8,16 +112,19 @@ export declare const useSaaSWorkspaces: () => {
     fetchWorkspaces: () => Promise<void>;
     refreshWorkspaces: () => Promise<void>;
     refreshing: boolean;
-    WorkspaceSwitcher: typeof WorkspaceSwitcher;
     currentWorkspace: IWorkspace | null;
-    setCurrentWorkspace: (ws: IWorkspace) => void;
+    setCurrentWorkspace: (ws: IWorkspace, options?: {
+        forceEmit?: boolean;
+    }) => void;
+    switchToWorkspace: (ws: IWorkspace, options?: {
+        forceEmit?: boolean;
+    }) => Promise<void>;
     resetCurrentWorkspace: () => void;
     createWorkspace: (name: string, image: string) => Promise<void>;
     allFeatures: import("./types").IWorkspaceFeature[];
     getFeatures: () => Promise<import("./types").IWorkspaceFeature[] | null>;
     updateFeature: (workspaceId: string, key: string, value: boolean) => Promise<IWorkspace>;
     getWorkspace: (workspaceId: string) => Promise<IWorkspace>;
-    switching: boolean;
     updateWorkspace: (ws: IWorkspace, _data: Partial<IWorkspace>) => Promise<void>;
     getUsers: (workspaceId: string) => Promise<IWorkspaceUser[]>;
     addUser: (workspaceId: string, email: string, role: string) => Promise<{
@@ -40,4 +147,5 @@ export declare const useSaaSWorkspaces: () => {
     deleteWorkspace: (workspaceId: string) => Promise<{
         success: boolean;
     }>;
+    switching: boolean;
 };

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

@@ -5,5 +5,4 @@ export declare const WorkspaceProvider: ({ children }: {
 }) => import("react/jsx-runtime").JSX.Element;
 export declare function WorkspaceSwitcher(props: {
     trigger: (isLoading: boolean, currentWorkspace: IWorkspace | null) => ReactNode;
-    onWorkspaceChange: (workspace: IWorkspace) => Promise<void>;
 }): import("react/jsx-runtime").JSX.Element;