@buildbase/sdk 0.0.27 → 0.0.29

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-import * as react from 'react';
-import react__default, { ReactNode } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { z } from 'zod';
 
 interface IDocument {
     _id: string;
@@ -27,6 +25,32 @@ interface IUser extends IDocument {
     currency?: string;
     attributes?: Record<string, string | number | boolean>;
 }
+interface IAsset extends IDocument {
+    _id: string;
+    createdAt: string;
+    updatedAt: string;
+    deleted: boolean;
+    name: string;
+    uniqueName: string;
+    mimeType: string;
+    size: number;
+    encoding: string;
+    bucket: {
+        name: string;
+        url: string;
+        path: string;
+    };
+    metadata: {
+        [key: string]: string | number | boolean | object | null;
+    };
+    image?: {
+        width: number;
+        height: number;
+    };
+    tags: string[];
+    public: boolean;
+    creator: string | IUser;
+}
 type BillingInterval = 'monthly' | 'yearly' | 'quarterly';
 interface ISubscription {
     _id: string;
@@ -595,11 +619,6 @@ interface AuthUser {
     role: string;
     image?: string;
 }
-interface AuthSession {
-    user: AuthUser;
-    sessionId: string;
-    expires: string;
-}
 interface IAuthConfig {
     clientId: string;
     redirectUrl: string;
@@ -610,6 +629,23 @@ interface IAuthCallbacks {
         sessionId: string;
     }>;
     onSignOut: () => Promise<void>;
+    /**
+     * Called on page refresh to restore the session.
+     * Return the sessionId if the user is still authenticated, or null to log out.
+     *
+     * The SDK calls this instead of reading from localStorage.
+     * Implement this to read from an httpOnly cookie via a server endpoint.
+     *
+     * @example Next.js — read from httpOnly cookie via API route
+     * ```ts
+     * getSession: async () => {
+     *   const res = await fetch('/api/auth/session')
+     *   const data = await res.json()
+     *   return data.sessionId ?? null
+     * }
+     * ```
+     */
+    getSession: () => Promise<string | null>;
     /**
      * Event handler for User and Workspace events
      * @param eventType - The type of event that occurred
@@ -655,975 +691,232 @@ interface IOsState extends IOsConfig {
     settings?: ISettings | null;
 }
 
-interface SaaSOSProviderProps extends IOsState {
-    children: react__default.ReactNode;
-}
-declare const SaaSOSProvider: react__default.FC<SaaSOSProviderProps>;
-
-type Language = 'en' | 'es' | 'fr' | 'de' | 'zh' | 'ja' | 'ko';
-interface FormText {
-    nameLabel: string;
-    emailLabel: string;
-    submitText: string;
-    submittingText: string;
-    errorMessage: string;
-}
-interface BetaFormProps {
-    onSuccess?: () => void;
-    onError?: (error: string) => void;
-    className?: string;
-    fieldClassName?: string;
-    language?: Language;
-    customTexts?: Partial<FormText>;
-    autoFocus?: boolean;
-    showSuccessMessage?: boolean;
-    successMessageDuration?: number;
-    hideLogo?: boolean;
-    hideTitles?: boolean;
-}
-declare const BetaForm: react__default.FC<BetaFormProps>;
-
-interface PricingPageDetails {
-    /** Whether plan data is being fetched */
-    loading: boolean;
-    /** Error message if fetch failed */
-    error: string | null;
-    /** Subscription items (features, limits, quotas) */
-    items: IPublicPlanItem[];
-    /** Plan versions with pricing, features, limits, quotas */
-    plans: IPublicPlanVersion[];
-    /** Optional note from API (e.g. "Pricing is in cents. Please convert to dollars for display.") */
-    notes?: string;
-    /** Refetch plan data */
-    refetch: () => Promise<void>;
-}
-interface PricingPageProps {
-    /** Plan group slug (e.g. 'main-pricing', 'enterprise') */
-    slug: string;
-    /** Render prop receiving plan details - construct layout from items and plans */
-    children: (details: PricingPageDetails) => ReactNode;
-    /** Custom loading UI. Defaults to skeleton. */
-    loadingFallback?: ReactNode;
-    /** Custom error UI. Receives error message. */
-    errorFallback?: (error: string) => ReactNode;
-}
 /**
- * Fetches and provides plan/pricing details for public pricing pages (no login required).
- * Returns items (features, limits, quotas) and plans (with pricing) - user constructs layout.
+ * Base API client for SDK endpoints.
+ * All domain API classes (WorkspaceApi, UserApi, etc.) extend this to share
+ * URL building, auth headers, and request/response handling.
  *
- * @example
- * ```tsx
- * <PricingPage slug="main-pricing">
- *   {({ loading, error, items, plans, refetch }) => {
- *     if (loading) return <Loading />;
- *     if (error) return <Error message={error} />;
+ * Supports two auth modes:
+ * 1. **Client-side (default):** reads sessionId from localStorage automatically.
+ * 2. **Server-side:** pass `sessionId` in config — no localStorage access.
  *
- *     return (
- *       <div>
- *         {plans.map(plan => (
- *           <PlanCard key={plan._id} plan={plan} items={items} />
- *         ))}
- *       </div>
- *     );
- *   }}
- * </PricingPage>
+ * @example Server-side usage
+ * ```ts
+ * const api = new WorkspaceApi({
+ *   serverUrl: "https://api.buildbase.app",
+ *   version: "v1",
+ *   orgId: "...",
+ *   sessionId: req.headers["x-session-id"], // from your request
+ * });
+ * const sub = await api.getCurrentSubscription(workspaceId);
  * ```
  */
-declare function PricingPage({ slug, children, loadingFallback, errorFallback }: PricingPageProps): react_jsx_runtime.JSX.Element;
 
-interface IProps$2 {
-    children: React.ReactNode;
+interface IBaseApiConfig {
+    serverUrl: string;
+    version: ApiVersion;
+    orgId?: string;
+    /** When true, ensureReady() also requires orgId. Used by WorkspaceApi and SettingsApi. */
+    requireOrgId?: boolean;
+    /** API path segment after version (default 'public'). e.g. 'public' => .../v1/public, 'beta' => .../v1/beta */
+    basePath?: string;
+    /**
+     * Session ID for server-side usage. When provided, this is used for auth
+     * instead of reading from localStorage. Pass the session token from your
+     * request headers, cookies, or any server-side session store.
+     */
+    sessionId?: string;
+    /** Request timeout in milliseconds. 0 = no timeout. */
+    timeout?: number;
+    /** Max automatic retries for network errors / 5xx. */
+    maxRetries?: number;
+    /** Enable debug logging for all requests. */
+    debug?: boolean;
+    /** Custom headers merged into every request. */
+    headers?: Record<string, string>;
+    /** Error callback — called before error is thrown. */
+    onError?: (error: Error, context: {
+        method: string;
+        path: string;
+    }) => void;
+    /** Custom fetch implementation. */
+    fetch?: typeof globalThis.fetch;
 }
 /**
- * Conditional component that renders children only when user is authenticated.
- * Returns null if user is not authenticated or authentication status is still loading.
- *
- * @param props - Component props
- * @param props.children - Content to render when authenticated
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <SaaSOSProvider {...config}>
- *       <WhenAuthenticated>
- *         <Dashboard />
- *       </WhenAuthenticated>
- *       <WhenUnauthenticated>
- *         <LoginPage />
- *       </WhenUnauthenticated>
- *     </SaaSOSProvider>
- *   );
- * }
- * ```
- */
-declare const WhenAuthenticated: {
-    (props: IProps$2): react.ReactNode;
-    displayName: string;
-};
-/**
- * Conditional component that renders children only when user is NOT authenticated.
- * Returns null if user is authenticated.
- * Note: Also renders during loading/redirecting states (when not yet authenticated).
- *
- * @param props - Component props
- * @param props.children - Content to render when unauthenticated
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <SaaSOSProvider {...config}>
- *       <WhenUnauthenticated>
- *         <LoginPage />
- *       </WhenUnauthenticated>
- *       <WhenAuthenticated>
- *         <Dashboard />
- *       </WhenAuthenticated>
- *     </SaaSOSProvider>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Handle loading state separately
- * function App() {
- *   const { isLoading } = useSaaSAuth();
- *
- *   if (isLoading) return <LoadingSpinner />;
- *
- *   return (
- *     <>
- *       <WhenUnauthenticated><LoginPage /></WhenUnauthenticated>
- *       <WhenAuthenticated><Dashboard /></WhenAuthenticated>
- *     </>
- *   );
- * }
- * ```
+ * Base class for SDK API clients.
+ * Provides:
+ * - baseUrl: `${serverUrl}/api/${version}/public`
+ * - getAuthHeaders()
+ * - fetchJson<T>(path, init, errorMessage): GET/POST/etc. with handleApiResponse
+ * - fetchResponse(path, init): raw Response for custom parsing (e.g. non-JSON or custom error handling)
  */
-declare const WhenUnauthenticated: {
-    (props: IProps$2): react.ReactNode;
-    displayName: string;
-};
-
-interface IProps$1 {
-    roles: string[];
-    children: React.ReactNode;
-    fallback?: React.ReactNode;
+declare abstract class BaseApi {
+    protected readonly serverUrl: string;
+    protected readonly version: ApiVersion;
+    protected readonly orgId: string | undefined;
+    private readonly requireOrgId;
+    private readonly basePath;
+    private readonly _sessionId;
+    private readonly _timeout;
+    private readonly _maxRetries;
+    private readonly _debug;
+    private readonly _customHeaders;
+    private readonly _onError?;
+    private readonly _fetch;
+    constructor(config: IBaseApiConfig);
+    /** Throws if config is not ready for API calls. Called automatically by fetchJson/fetchResponse. */
+    protected ensureReady(): void;
+    /** Base URL: ${serverUrl}/api/${version}/${basePath} */
+    protected get baseUrl(): string;
+    /**
+     * Auth headers (x-session-id).
+     * Uses injected sessionId (server-side) or falls back to localStorage (client-side).
+     * Subclasses can override to add more headers.
+     */
+    protected getAuthHeaders(): Record<string, string>;
+    /** Build full URL from path (path can be "workspaces" or "/workspaces"). */
+    protected url(path: string): string;
+    /** Merge auth + custom + per-request headers. */
+    private buildHeaders;
+    /** Execute fetch with timeout, retries, debug logging, and error callback. */
+    private executeFetch;
+    /**
+     * Execute request and parse JSON with handleApiResponse (throws on !response.ok).
+     * Use for standard JSON APIs.
+     */
+    protected fetchJson<T>(path: string, init?: RequestInit, errorMessage?: string): Promise<T>;
+    /**
+     * Execute request and return raw Response (for custom parsing or error handling).
+     * Caller is responsible for checking response.ok and parsing body.
+     */
+    protected fetchResponse(path: string, init?: RequestInit): Promise<Response>;
 }
+
 /**
- * Conditional component that renders children only when user has one of the specified roles.
- * Checks the user's global role (not workspace-specific).
- *
- * @param props - Component props
- * @param props.roles - Array of role strings to check against user's role
- * @param props.children - Content to render when user has matching role
- * @param props.fallback - Optional content to render when user doesn't have matching role (default: null)
- *
- * @example
- * ```tsx
- * function AdminPanel() {
- *   return (
- *     <WhenRoles roles={['admin', 'super-admin']}>
- *       <AdminContent />
- *     </WhenRoles>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // With fallback
- * function SettingsPage() {
- *   return (
- *     <WhenRoles
- *       roles={['admin']}
- *       fallback={<p>You don't have permission to access this page.</p>}
- *     >
- *       <AdminSettings />
- *     </WhenRoles>
- *   );
- * }
- * ```
- */
-declare const WhenRoles: {
-    (props: IProps$1): react.ReactNode;
-    displayName: string;
-};
-/**
- * Conditional component that renders children only when user has one of the specified roles
- * in the current workspace. Checks workspace-specific role, not global role.
- *
- * @param props - Component props
- * @param props.roles - Array of role strings to check against user's workspace role
- * @param props.children - Content to render when user has matching workspace role
- * @param props.fallback - Optional content to render when user doesn't have matching role (default: null)
- *
- * @example
- * ```tsx
- * function WorkspaceSettings() {
- *   return (
- *     <WhenWorkspaceRoles roles={['owner', 'admin']}>
- *       <SettingsContent />
- *     </WhenWorkspaceRoles>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Edge case: User not in current workspace
- * function WorkspaceContent() {
- *   return (
- *     <WhenWorkspaceRoles
- *       roles={['member']}
- *       fallback={<p>You are not a member of this workspace.</p>}
- *     >
- *       <WorkspaceDashboard />
- *     </WhenWorkspaceRoles>
- *   );
- * }
- * ```
+ * API client for authentication.
+ * Extends BaseApi for shared URL/auth/request handling.
  */
-declare const WhenWorkspaceRoles: {
-    (props: IProps$1): react.ReactNode;
-    displayName: string;
-};
 
-interface IProps {
-    slug: string;
-    children: React.ReactNode;
+interface AuthRequestParams {
+    orgId: string;
+    clientId: string;
+    redirect: {
+        success: string;
+        error: string;
+    };
+}
+interface AuthRequestResponse {
+    success: boolean;
+    data: {
+        redirectUrl: string;
+    };
+    message: string;
+}
+declare class AuthApi extends BaseApi {
+    constructor(config: Pick<IOsConfig, 'serverUrl' | 'version'> & {
+        sessionId?: string;
+    });
+    /**
+     * Initiate OAuth sign-in flow. Returns redirect URL to the auth provider.
+     * Uses /api/v1/auth/request (no 'public' prefix — auth endpoints are at the root).
+     */
+    requestAuth(params: AuthRequestParams): Promise<AuthRequestResponse>;
+    /** Fetch user profile with the given session ID (used after OAuth redirect or from storage). */
+    getProfile(sessionId: string, signal?: AbortSignal): Promise<IUser>;
 }
-/**
- * Conditional component that renders children only when the specified workspace feature is enabled.
- * Checks feature flags at the workspace level.
- *
- * @param props - Component props
- * @param props.slug - Feature flag slug/key to check
- * @param props.children - Content to render when feature is enabled
- *
- * @example
- * ```tsx
- * function PremiumFeature() {
- *   return (
- *     <WhenWorkspaceFeatureEnabled slug="premium-analytics">
- *       <AnalyticsDashboard />
- *     </WhenWorkspaceFeatureEnabled>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Multiple features
- * function FeatureContent() {
- *   return (
- *     <>
- *       <WhenWorkspaceFeatureEnabled slug="feature-a">
- *         <FeatureA />
- *       </WhenWorkspaceFeatureEnabled>
- *       <WhenWorkspaceFeatureEnabled slug="feature-b">
- *         <FeatureB />
- *       </WhenWorkspaceFeatureEnabled>
- *     </>
- *   );
- * }
- * ```
- */
-declare const WhenWorkspaceFeatureEnabled: {
-    (props: IProps): react.ReactNode;
-    displayName: string;
-};
-/**
- * Conditional component that renders children only when the specified workspace feature is disabled.
- * Checks feature flags at the workspace level.
- *
- * @param props - Component props
- * @param props.slug - Feature flag slug/key to check
- * @param props.children - Content to render when feature is disabled
- *
- * @example
- * ```tsx
- * function UpgradePrompt() {
- *   return (
- *     <WhenWorkspaceFeatureDisabled slug="premium-feature">
- *       <UpgradeButton />
- *     </WhenWorkspaceFeatureDisabled>
- *   );
- * }
- * ```
- */
-declare const WhenWorkspaceFeatureDisabled: {
-    (props: IProps): react.ReactNode;
-    displayName: string;
-};
-/**
- * Conditional component that renders children only when the specified user feature is enabled.
- * Checks feature flags at the user level (from UserProvider).
- *
- * @param props - Component props
- * @param props.slug - Feature flag slug/key to check
- * @param props.children - Content to render when feature is enabled
- *
- * @example
- * ```tsx
- * function BetaFeature() {
- *   return (
- *     <WhenUserFeatureEnabled slug="beta-access">
- *       <BetaContent />
- *     </WhenUserFeatureEnabled>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Edge case: Feature not loaded yet
- * function FeatureContent() {
- *   const { isLoading } = useUserFeatures();
- *
- *   if (isLoading) return <Loading />;
- *
- *   return (
- *     <WhenUserFeatureEnabled slug="feature-x">
- *       <FeatureX />
- *     </WhenUserFeatureEnabled>
- *   );
- * }
- * ```
- */
-declare const WhenUserFeatureEnabled: {
-    (props: IProps): react.ReactNode;
-    displayName: string;
-};
-/**
- * Conditional component that renders children only when the specified user feature is disabled.
- * Checks feature flags at the user level (from UserProvider).
- *
- * @param props - Component props
- * @param props.slug - Feature flag slug/key to check
- * @param props.children - Content to render when feature is disabled
- *
- * @example
- * ```tsx
- * function UpgradePrompt() {
- *   return (
- *     <WhenUserFeatureDisabled slug="premium-access">
- *       <UpgradeButton />
- *     </WhenUserFeatureDisabled>
- *   );
- * }
- * ```
- */
-declare const WhenUserFeatureDisabled: {
-    (props: IProps): react.ReactNode;
-    displayName: string;
-};
 
-interface IWhenSubscriptionProps {
-    /** Content to render when the condition is met (workspace has an active subscription). */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading (e.g. <Skeleton />). */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when condition is not met (e.g. <UpgradePrompt />). */
-    fallbackComponent?: React.ReactNode;
+interface IScreenDetail {
+    title: string;
+    description: string;
 }
-/**
- * Renders children only when the current workspace has an active subscription (any plan).
- * Optionally pass loadingComponent (while loading) or fallbackComponent (when not subscribed).
- * Must be used within SubscriptionContextProvider.
- *
- * @param props - Component props
- * @param props.children - Content to render when subscribed
- * @param props.loadingComponent - Optional component/element to show while loading
- * @param props.fallbackComponent - Optional component/element to show when not subscribed
- * @returns ReactNode - children when subscribed, loadingComponent when loading, fallbackComponent when not subscribed, or null
- *
- * @example
- * ```tsx
- * <WhenSubscription>
- *   <BillingSettings />
- * </WhenSubscription>
- * ```
- *
- * @example
- * ```tsx
- * <WhenSubscription
- *   loadingComponent={<Skeleton />}
- *   fallbackComponent={<UpgradePrompt />}
- * >
- *   <BillingSettings />
- * </WhenSubscription>
- * ```
- */
-declare const WhenSubscription: {
-    (props: IWhenSubscriptionProps): react.ReactNode;
-    displayName: string;
-};
-/**
- * Renders children only when the current workspace has no subscription (or no current workspace).
- * Optionally pass loadingComponent (while loading) or fallbackComponent (when already subscribed).
- * Must be used within SubscriptionContextProvider.
- *
- * @param props - Component props
- * @param props.children - Content to render when not subscribed
- * @param props.loadingComponent - Optional component/element to show while loading
- * @param props.fallbackComponent - Optional component/element to show when already subscribed
- * @returns ReactNode - children when not subscribed, loadingComponent when loading, fallbackComponent when subscribed, or null
- *
- * @example
- * ```tsx
- * <WhenNoSubscription>
- *   <UpgradePrompt />
- * </WhenNoSubscription>
- * ```
- *
- * @example
- * ```tsx
- * <WhenNoSubscription
- *   loadingComponent={<Spinner />}
- *   fallbackComponent={null}
- * >
- *   <UpgradePrompt />
- * </WhenNoSubscription>
- * ```
- */
-declare const WhenNoSubscription: {
-    (props: IWhenSubscriptionProps): react.ReactNode;
-    displayName: string;
-};
-interface IWhenSubscriptionToPlansProps {
-    /** Plan slugs to match (e.g. ['pro', 'enterprise']). Matching is case-insensitive. */
-    plans: string[];
-    /** Content to render when the workspace is on one of the given plans. */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading (e.g. <Skeleton />). */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when not on a matching plan (e.g. <UpgradeToPro />). */
-    fallbackComponent?: React.ReactNode;
+interface IBetaConfig extends IDocument {
+    name: string;
+    smallName: string;
+    description: string;
+    logoFallBack: string;
+    logo: string | IAsset;
+    privacyPolicy: string;
+    termsOfService: string;
+    enabled: boolean;
+    screen: {
+        register: IScreenDetail;
+        thankYou: IScreenDetail;
+    };
 }
-/**
- * Renders children only when the current workspace is subscribed to one of the given plans.
- * Matches by plan slug only. Optionally pass loadingComponent (while loading) or fallbackComponent (when not on a matching plan).
- * Must be used within SubscriptionContextProvider.
- *
- * @param props - Component props
- * @param props.plans - Plan slugs to match (e.g. ['pro', 'enterprise'])
- * @param props.children - Content to render when on a matching plan
- * @param props.loadingComponent - Optional component/element to show while loading
- * @param props.fallbackComponent - Optional component/element to show when not on a matching plan
- * @returns ReactNode - children when on a matching plan, loadingComponent when loading, fallbackComponent when not matching, or null
- *
- * @example
- * ```tsx
- * <WhenSubscriptionToPlans plans={['pro', 'enterprise']}>
- *   <AdvancedAnalytics />
- * </WhenSubscriptionToPlans>
- * ```
- *
- * @example
- * ```tsx
- * <WhenSubscriptionToPlans
- *   plans={['pro', 'enterprise']}
- *   loadingComponent={<Skeleton />}
- *   fallbackComponent={<UpgradeToPro />}
- * >
- *   <AdvancedAnalytics />
- * </WhenSubscriptionToPlans>
- * ```
- */
-declare const WhenSubscriptionToPlans: {
-    (props: IWhenSubscriptionToPlansProps): react.ReactNode;
-    displayName: string;
-};
-interface IWhenTrialingProps {
-    /** Content to render when the condition is met. */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading. */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when condition is not met. */
-    fallbackComponent?: React.ReactNode;
+interface ApiResponse {
+    status: string;
+    message: string;
+    data?: {
+        submissionId: string;
+        status: string;
+    };
+    code: string;
+    config?: IBetaConfig;
+    submissionId?: string;
 }
-/**
- * Renders children only when the current workspace subscription is in trial (status === 'trialing').
- * Must be used within SubscriptionContextProvider.
- *
- * @example
- * ```tsx
- * <WhenTrialing fallbackComponent={<NormalContent />}>
- *   <TrialBanner />
- * </WhenTrialing>
- * ```
- */
-declare const WhenTrialing: {
-    (props: IWhenTrialingProps): react.ReactNode;
-    displayName: string;
-};
-/**
- * Renders children only when the current workspace subscription is NOT in trial.
- * This includes: no subscription, active, canceled, past_due, etc.
- * Must be used within SubscriptionContextProvider.
- *
- * @example
- * ```tsx
- * <WhenNotTrialing>
- *   <RegularPricingPage />
- * </WhenNotTrialing>
- * ```
- */
-declare const WhenNotTrialing: {
-    (props: IWhenTrialingProps): react.ReactNode;
-    displayName: string;
-};
-interface IWhenTrialEndingProps {
-    /** Content to render when trial is ending soon. */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading. */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when trial is not ending soon. */
-    fallbackComponent?: React.ReactNode;
-    /** Number of days threshold to consider "ending soon". Defaults to 3. */
-    daysThreshold?: number;
+declare class BetaForm {
+    private api;
+    private orgId;
+    constructor(config: IOsConfig);
+    fetchConfig(): Promise<IBetaConfig>;
+    submitBetaUser(formData: {
+        name: string;
+        email: string;
+        context?: {
+            country?: string;
+            language?: string;
+            timezone?: string;
+            currency?: string;
+        };
+    }): Promise<ApiResponse>;
 }
-/**
- * Renders children only when the subscription is trialing AND the trial ends within
- * the given threshold (default 3 days). Useful for showing urgent upgrade prompts.
- * Must be used within SubscriptionContextProvider.
- *
- * @example
- * ```tsx
- * <WhenTrialEnding daysThreshold={5}>
- *   <UpgradeBanner />
- * </WhenTrialEnding>
- * ```
- */
-declare const WhenTrialEnding: {
-    (props: IWhenTrialEndingProps): react.ReactNode;
-    displayName: string;
-};
 
-interface IWhenQuotaProps {
-    /** Quota slug to check (e.g. 'api_calls', 'emails', 'storage'). */
-    slug: string;
-    /** Content to render when the condition is met. */
-    children: React.ReactNode;
-    /** Optional component/element to show while quota usage is loading (e.g. <Skeleton />). */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when condition is not met (e.g. <UpgradePrompt />). */
-    fallbackComponent?: React.ReactNode;
-}
-interface IWhenQuotaThresholdProps extends IWhenQuotaProps {
-    /** Usage percentage threshold (0-100). Children render when usage >= this percentage. */
-    threshold: number;
+declare class PushApi extends BaseApi {
+    constructor(config: Pick<IBaseApiConfig, 'serverUrl' | 'version' | 'orgId' | 'sessionId'>);
+    getVapidPublicKey(): Promise<{
+        publicKey: string;
+    }>;
+    subscribe(subscription: {
+        endpoint: string;
+        keys: {
+            p256dh: string;
+            auth: string;
+        };
+    }, userAgent: string): Promise<void>;
+    unsubscribe(endpoint: string): Promise<void>;
 }
+
 /**
- * Renders children only when the specified quota has remaining units (available > 0).
- * Must be used within QuotaUsageContextProvider (included in SaaSOSProvider by default).
- *
- * @example
- * ```tsx
- * <WhenQuotaAvailable slug="api_calls">
- *   <MakeApiCallButton />
- * </WhenQuotaAvailable>
- * ```
- *
- * @example
- * ```tsx
- * <WhenQuotaAvailable
- *   slug="emails"
- *   loadingComponent={<Skeleton />}
- *   fallbackComponent={<p>Email quota exhausted. <UpgradeLink /></p>}
- * >
- *   <SendEmailButton />
- * </WhenQuotaAvailable>
- * ```
+ * Centralized API client for organization (OS) settings.
+ * Extends BaseApi for shared URL/auth/request handling.
  */
-declare const WhenQuotaAvailable: {
-    (props: IWhenQuotaProps): react.ReactNode;
-    displayName: string;
-};
+
+declare class SettingsApi extends BaseApi {
+    constructor(config: IOsConfig & {
+        sessionId?: string;
+    });
+    getSettings(signal?: AbortSignal): Promise<ISettings>;
+}
+
 /**
- * Renders children only when the specified quota is fully consumed (available <= 0).
- * Must be used within QuotaUsageContextProvider (included in SaaSOSProvider by default).
- *
- * @example
- * ```tsx
- * <WhenQuotaExhausted slug="api_calls">
- *   <UpgradePrompt message="You've used all your API calls this month." />
- * </WhenQuotaExhausted>
- * ```
- *
- * @example
- * ```tsx
- * <WhenQuotaExhausted
- *   slug="storage"
- *   loadingComponent={<Spinner />}
- *   fallbackComponent={null}
- * >
- *   <StorageFullBanner />
- * </WhenQuotaExhausted>
- * ```
- */
-declare const WhenQuotaExhausted: {
-    (props: IWhenQuotaProps): react.ReactNode;
-    displayName: string;
-};
-/**
- * Renders children only when the specified quota is in overage (consumed > included).
- * Must be used within QuotaUsageContextProvider (included in SaaSOSProvider by default).
- *
- * @example
- * ```tsx
- * <WhenQuotaOverage slug="api_calls">
- *   <OverageBillingWarning />
- * </WhenQuotaOverage>
- * ```
- *
- * @example
- * ```tsx
- * <WhenQuotaOverage
- *   slug="emails"
- *   loadingComponent={<Skeleton />}
- *   fallbackComponent={null}
- * >
- *   <p>You are being billed for overage usage.</p>
- * </WhenQuotaOverage>
- * ```
- */
-declare const WhenQuotaOverage: {
-    (props: IWhenQuotaProps): react.ReactNode;
-    displayName: string;
-};
-/**
- * Renders children when the specified quota's usage percentage reaches or exceeds the threshold.
- * Usage percentage = (consumed / included) * 100. If included is 0 and consumed > 0, treats as 100%.
- * Must be used within QuotaUsageContextProvider (included in SaaSOSProvider by default).
- *
- * @example
- * ```tsx
- * <WhenQuotaThreshold slug="api_calls" threshold={80}>
- *   <p>Warning: You've used over 80% of your API calls.</p>
- * </WhenQuotaThreshold>
- * ```
- *
- * @example
- * ```tsx
- * <WhenQuotaThreshold
- *   slug="storage"
- *   threshold={90}
- *   loadingComponent={<Spinner />}
- *   fallbackComponent={null}
- * >
- *   <StorageWarningBanner />
- * </WhenQuotaThreshold>
- * ```
- */
-declare const WhenQuotaThreshold: {
-    (props: IWhenQuotaThresholdProps): react.ReactNode;
-    displayName: string;
-};
-
-/**
- * Value provided by SubscriptionContext and returned by useSubscriptionContext.
- */
-interface SubscriptionContextValue {
-    /** Current subscription response for the current workspace, or null if none or not loaded. */
-    response: ISubscriptionResponse | null;
-    /** True while subscription is being fetched. */
-    loading: boolean;
-    /** Error message if the last fetch failed, or null. */
-    error: string | null;
-    /** Refetch subscription for the current workspace. Call after plan change (e.g. upgrade) or when subscription was updated elsewhere. */
-    refetch: () => Promise<void>;
-}
-
-/**
- * Provides subscription data for the current workspace to subscription gate components.
- * Fetches when workspace changes; refetches when subscription is invalidated (e.g. after plan change).
- * Must wrap (or be ancestor of) any component that uses WhenSubscription, WhenNoSubscription,
- * WhenSubscriptionToPlans, or useSubscriptionContext. Included in SaaSOSProvider by default.
- *
- * @param props - Component props
- * @param props.children - React tree that may use subscription gates or useSubscriptionContext
- * @returns Provider element that supplies subscription context to descendants
- */
-declare const SubscriptionContextProvider: react__default.FC<{
-    children: ReactNode;
-}>;
-/**
- * Returns subscription data for the current workspace. Must be used within SubscriptionContextProvider.
- *
- * @returns SubscriptionContextValue - { response, loading, refetch }
- * @throws Error if used outside SubscriptionContextProvider
- */
-declare function useSubscriptionContext(): SubscriptionContextValue;
-
-/**
- * Notify all subscribers to refetch subscription (e.g. after update/cancel/resume).
- * Called internally by useUpdateSubscription, useCancelSubscription, useResumeSubscription on success.
- */
-declare function invalidateSubscription(): void;
-
-/**
- * Value provided by QuotaUsageContext and returned by useQuotaUsageContext.
- */
-interface QuotaUsageContextValue {
-    /** Current quota usage statuses keyed by slug, or null if not loaded. */
-    quotas: Record<string, IQuotaUsageStatus> | null;
-    /** True while quota usage is being fetched. */
-    loading: boolean;
-    /** Error message if the last fetch failed, or null. */
-    error: string | null;
-    /** Refetch all quota usage for the current workspace. Call after recording usage or when usage was updated elsewhere. */
-    refetch: () => Promise<void>;
-}
-
-/**
- * Provides quota usage data for the current workspace to quota gate components.
- * Fetches when workspace changes; refetches when quota usage is invalidated (e.g. after recording usage).
- * Must wrap (or be ancestor of) any component that uses WhenQuotaAvailable, WhenQuotaExhausted,
- * WhenQuotaOverage, WhenQuotaThreshold, or useQuotaUsageContext. Included in SaaSOSProvider by default.
- *
- * @param props - Component props
- * @param props.children - React tree that may use quota gates or useQuotaUsageContext
- * @returns Provider element that supplies quota usage context to descendants
- */
-declare const QuotaUsageContextProvider: react__default.FC<{
-    children: ReactNode;
-}>;
-/**
- * Returns quota usage data for the current workspace. Must be used within QuotaUsageContextProvider.
- *
- * @returns QuotaUsageContextValue - { quotas, loading, refetch }
- * @throws Error if used outside QuotaUsageContextProvider
- */
-declare function useQuotaUsageContext(): QuotaUsageContextValue;
-
-/**
- * Notify all subscribers to refetch quota usage (e.g. after recording usage).
- * Called internally by useRecordUsage on success.
- */
-declare function invalidateQuotaUsage(): void;
-
-type WorkspaceSettingsSection = 'profile' | 'general' | 'users' | 'subscription' | 'usage' | 'features' | 'notifications' | 'danger';
-
-declare function useSaaSAuth(): {
-    signIn: () => Promise<void>;
-    signOut: () => Promise<void>;
-    openWorkspaceSettings: (section?: WorkspaceSettingsSection) => void;
-    isAuthenticated: boolean;
-    isLoading: boolean;
-    isRedirecting: boolean;
-    user: AuthUser | undefined;
-    session: AuthSession | null;
-    status: AuthStatus;
-};
-
-/**
- * Hook to access OS (organization) state (serverUrl, version, orgId, auth, settings).
- * Prefer useSaaSSettings() when you only need settings.
- */
-declare function useSaaSOs(): IOsState;
-/**
- * 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]);
- * }
- * ```
- */
-declare function useSaaSSettings(): {
-    settings: ISettings | null | undefined;
-    getSettings: (signal?: AbortSignal) => Promise<ISettings | null>;
-};
-
-interface UserContextValue {
-    attributes: Record<string, string | number | boolean>;
-    features: Record<string, boolean>;
-    isLoading: boolean;
-    error: Error | null;
-    updateAttributes: (updates: Record<string, string | number | boolean>) => Promise<IUser>;
-    updateAttribute: (attributeKey: string, value: string | number | boolean) => Promise<IUser>;
-    refreshAttributes: () => Promise<void>;
-    refreshFeatures: () => Promise<void>;
-}
-
-/**
- * Base API client for SDK endpoints.
- * All domain API classes (WorkspaceApi, UserApi, etc.) extend this to share
- * URL building, auth headers, and request/response handling.
+ * API client for user attributes and features.
+ * Extends BaseApi for shared URL/auth/request handling.
  */
 
-interface IBaseApiConfig {
-    serverUrl: string;
-    version: ApiVersion;
-    orgId?: string;
-    /** When true, ensureReady() also requires orgId. Used by WorkspaceApi and SettingsApi. */
-    requireOrgId?: boolean;
-    /** API path segment after version (default 'public'). e.g. 'public' => .../v1/public, 'beta' => .../v1/beta */
-    basePath?: string;
-}
-/**
- * Base class for SDK API clients.
- * Provides:
- * - baseUrl: `${serverUrl}/api/${version}/public`
- * - getAuthHeaders()
- * - fetchJson<T>(path, init, errorMessage): GET/POST/etc. with handleApiResponse
- * - fetchResponse(path, init): raw Response for custom parsing (e.g. non-JSON or custom error handling)
- */
-declare abstract class BaseApi {
-    protected readonly serverUrl: string;
-    protected readonly version: ApiVersion;
-    protected readonly orgId: string | undefined;
-    private readonly requireOrgId;
-    private readonly basePath;
-    constructor(config: IBaseApiConfig);
-    /** Throws if config is not ready for API calls. Called automatically by fetchJson/fetchResponse. */
-    protected ensureReady(): void;
-    /** Base URL: ${serverUrl}/api/${version}/${basePath} */
-    protected get baseUrl(): string;
-    /** Auth headers (x-session-id). Subclasses can override to add more. */
-    protected getAuthHeaders(): Record<string, string>;
-    /** Build full URL from path (path can be "workspaces" or "/workspaces"). */
-    protected url(path: string): string;
-    /**
-     * Execute request and parse JSON with handleApiResponse (throws on !response.ok).
-     * Use for standard JSON APIs.
-     */
-    protected fetchJson<T>(path: string, init?: RequestInit, errorMessage?: string): Promise<T>;
-    /**
-     * Execute request and return raw Response (for custom parsing or error handling).
-     * Caller is responsible for checking response.ok and parsing body.
-     */
-    protected fetchResponse(path: string, init?: RequestInit): Promise<Response>;
-}
-
-/**
- * Centralized API client for user attributes and features.
- * Extends BaseApi for shared URL/auth/request handling.
- */
 declare class UserApi extends BaseApi {
-    constructor(config: Pick<IOsConfig, 'serverUrl' | 'version'>);
+    constructor(config: Pick<IOsConfig, 'serverUrl' | 'version'> & {
+        sessionId?: string;
+    });
     getAttributes(signal?: AbortSignal): Promise<Record<string, string | number | boolean>>;
     updateAttributes(updates: Record<string, string | number | boolean>): Promise<IUser>;
     updateAttribute(attributeKey: string, value: string | number | boolean): Promise<IUser>;
     getFeatures(signal?: AbortSignal): Promise<Record<string, boolean>>;
 }
 
-/**
- * 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>
- *   );
- * }
- * ```
- */
-declare function useUserAttributes(): 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>
- *   );
- * }
- * ```
- */
-declare function useUserFeatures(): {
-    features: Record<string, boolean>;
-    isLoading: boolean;
-    error: Error | null;
-    refreshFeatures: () => Promise<void>;
-    isFeatureEnabled: (featureId: string) => boolean;
-};
-
 declare class WorkspaceApi extends BaseApi {
-    constructor(config: IOsConfig);
+    constructor(config: IOsConfig & {
+        sessionId?: string;
+    });
     getWorkspaces(): Promise<IWorkspace[]>;
     createWorkspace(data: {
         name: string;
@@ -1720,997 +1013,66 @@ declare class WorkspaceApi extends BaseApi {
      * Create a Stripe Customer Portal session for managing payment methods, invoices, etc.
      * Returns the portal URL — redirect user to it.
      */
-    createBillingPortalSession(workspaceId: string, returnUrl?: string): Promise<{
-        url: string;
-    }>;
-    /**
-     * 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
-     */
-    getInvoice(workspaceId: string, invoiceId: string): Promise<IInvoiceResponse>;
-    /**
-     * Cancel subscription at the end of the current billing period
-     * Sets cancelAtPeriodEnd: true - subscription remains active until period ends
-     * @param workspaceId - The workspace ID
-     * @returns Updated subscription with cancelAtPeriodEnd and stripeCurrentPeriodEnd
-     */
-    cancelSubscriptionAtPeriodEnd(workspaceId: string): Promise<ISubscriptionResponse>;
-    /**
-     * Resume a subscription that was scheduled for cancellation
-     * Sets cancelAtPeriodEnd: false - subscription will continue after period ends
-     * @param workspaceId - The workspace ID
-     * @returns Updated subscription with cancelAtPeriodEnd set to false
-     */
-    resumeSubscription(workspaceId: string): Promise<ISubscriptionResponse>;
-    /**
-     * Record quota usage for a workspace
-     * @param workspaceId - The workspace ID
-     * @param request - Usage request with quotaSlug, quantity, and optional metadata/source
-     * @returns Usage result with consumed/included/available/overage
-     */
-    recordUsage(workspaceId: string, request: IRecordUsageRequest): Promise<IRecordUsageResponse>;
-    /**
-     * Get usage status for a single quota
-     * @param workspaceId - The workspace ID
-     * @param quotaSlug - The quota slug to check
-     * @returns Quota usage status with consumed/included/available/overage/hasOverage
-     */
-    getQuotaUsageStatus(workspaceId: string, quotaSlug: string): Promise<IQuotaUsageStatusResponse>;
-    /**
-     * Get usage status for all quotas in the workspace's current plan
-     * @param workspaceId - The workspace ID
-     * @returns All quota usage statuses keyed by quota slug
-     */
-    getAllQuotaUsage(workspaceId: string): Promise<IAllQuotaUsageResponse>;
-    /**
-     * Get paginated usage logs for a workspace
-     * @param workspaceId - The workspace ID
-     * @param query - Optional filters: quotaSlug, from, to, source, page, limit
-     * @returns Paginated usage log entries
-     */
-    getUsageLogs(workspaceId: string, query?: IUsageLogsQuery): Promise<IUsageLogsResponse>;
-}
-
-declare const useSaaSWorkspaces: () => {
-    workspaces: IWorkspace[];
-    loading: boolean;
-    error: string | null;
-    fetchWorkspaces: () => Promise<void>;
-    refreshWorkspaces: () => Promise<void>;
-    refreshing: boolean;
-    currentWorkspace: IWorkspace | null;
-    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: IWorkspaceFeature[];
-    getFeatures: () => Promise<IWorkspaceFeature[] | null>;
-    updateFeature: (workspaceId: string, key: string, value: boolean) => Promise<IWorkspace>;
-    getWorkspace: (workspaceId: string) => Promise<IWorkspace>;
-    updateWorkspace: (ws: IWorkspace, _data: Partial<IWorkspace>) => Promise<void>;
-    getUsers: (workspaceId: string) => Promise<IWorkspaceUser[]>;
-    addUser: (workspaceId: string, email: string, role: string) => Promise<{
-        userId: string;
-        workspace: IWorkspace;
-        message: string;
-    }>;
-    removeUser: (workspaceId: string, userId: string) => Promise<{
-        userId: string;
-        workspace: IWorkspace;
-        message: string;
-    }>;
-    updateUser: (workspaceId: string, userId: string, config: Partial<IWorkspaceUser>) => Promise<{
-        userId: string;
-        workspace: IWorkspace;
-        message: string;
-    }>;
-    getProfile: () => Promise<IUser>;
-    updateUserProfile: (config: Partial<IUser>) => Promise<IUser>;
-    deleteWorkspace: (workspaceId: string) => Promise<{
-        success: boolean;
-    }>;
-    switching: boolean;
-    switchingToId: string | null;
-};
-
-declare function WorkspaceSwitcher(props: {
-    trigger: (isLoading: boolean, currentWorkspace: IWorkspace | null) => ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-/**
- * Hook to get public plans by slug (no auth required).
- * Returns items (features, limits, quotas) and plans (with pricing).
- * Uses orgId from SaaSOSProvider - must be inside provider.
- *
- * @param slug - Plan group slug (e.g. 'main-pricing', 'enterprise')
- * @returns { items, plans, loading, error, refetch }
- */
-declare const usePublicPlans: (slug: string) => {
-    items: IPublicPlanItem[];
-    plans: IPublicPlanVersion[];
-    notes: string | undefined;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to get a single plan group version by ID (no auth required).
- * Use this for public pricing pages when you have the groupVersionId (e.g. from config or URL).
- *
- * @param groupVersionId - The plan group version ID to fetch. Pass null/undefined to disable fetching.
- * @returns An object containing:
- * - `planGroupVersion`: Plan group version data (null if not loaded)
- * - `loading`: Boolean indicating if data is being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch
- *
- * @example
- * ```tsx
- * function PublicPricingPage() {
- *   const groupVersionId = 'your-plan-group-version-id'; // from config or URL
- *   const { planGroupVersion, loading } = usePublicPlanGroupVersion(groupVersionId);
- *
- *   if (loading) return <Loading />;
- *   if (!planGroupVersion) return null;
- *
- *   const plans = Array.isArray(planGroupVersion.planVersionIds)
- *     ? planGroupVersion.planVersionIds.filter((p): p is IPlanVersionWithPlan => typeof p !== 'string')
- *     : [];
- *
- *   return (
- *     <div>
- *       {plans.map(plan => <PlanCard key={plan._id} plan={plan} />)}
- *     </div>
- *   );
- * }
- * ```
- */
-declare const usePublicPlanGroupVersion: (groupVersionId: string | null | undefined) => {
-    planGroupVersion: IPlanGroupVersion | null;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to get and manage the current subscription for a workspace.
- * Automatically fetches subscription when workspaceId changes.
- *
- * @param workspaceId - The workspace ID to get subscription for. Can be null/undefined to disable fetching.
- * @returns An object containing:
- * - `subscription`: Current subscription data (null if no subscription or not loaded)
- * - `loading`: Boolean indicating if subscription is being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch the subscription
- *
- * @example
- * ```tsx
- * function SubscriptionStatus() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { subscription, loading, error } = useSubscription(currentWorkspace?._id);
- *
- *   if (loading) return <Loading />;
- *   if (error) return <Error message={error} />;
- *   if (!subscription) return <p>No active subscription</p>;
- *
- *   return <p>Plan: {subscription.plan.name}</p>;
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Edge case: Workspace ID changes
- * function SubscriptionComponent({ workspaceId }) {
- *   const { subscription, refetch } = useSubscription(workspaceId);
- *
- *   // Subscription automatically refetches when workspaceId changes
- *   // Use refetch() to manually refresh after mutations
- *   return <SubscriptionDetails subscription={subscription} />;
- * }
- * ```
- */
-declare const useSubscription: (workspaceId: string | null | undefined) => {
-    subscription: ISubscriptionResponse | null;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to get the plan group for a workspace.
- * Returns the plan group containing the current plan if subscription exists,
- * otherwise returns the latest published group.
- * Automatically fetches when workspaceId or groupVersionId changes.
- *
- * @param workspaceId - The workspace ID to get plan group for. Can be null/undefined to disable fetching.
- * @param groupVersionId - Optional: specific group version ID to fetch (for viewing historical versions)
- * @returns An object containing:
- * - `planGroup`: Plan group data (null if not loaded)
- * - `loading`: Boolean indicating if plan group is being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch the plan group
- *
- * @example
- * ```tsx
- * function PlanGroupDisplay() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { planGroup, loading } = usePlanGroup(currentWorkspace?._id);
- *
- *   if (loading) return <Loading />;
- *   if (!planGroup) return <p>No plan group available</p>;
- *
- *   return (
- *     <div>
- *       <h3>{planGroup.group.name}</h3>
- *       {planGroup.plans.map(plan => (
- *         <PlanCard key={plan._id} plan={plan} />
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Fetch specific version for comparison
- * function PlanVersionComparison() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const current = usePlanGroup(currentWorkspace?._id);
- *   const previous = usePlanGroup(currentWorkspace?._id, 'previous-version-id');
- *
- *   return <ComparePlans current={current.planGroup} previous={previous.planGroup} />;
- * }
- * ```
- */
-declare const usePlanGroup: (workspaceId: string | null | undefined, groupVersionId?: string | null) => {
-    planGroup: IPlanGroupResponse | null;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to get all available versions of a plan group for a workspace.
- * Shows current version and available newer versions for upgrade paths.
- * Automatically fetches when workspaceId changes.
- *
- * @param workspaceId - The workspace ID to get plan group versions for. Can be null/undefined to disable fetching.
- * @returns An object containing:
- * - `versions`: Plan group versions response with currentVersion and availableVersions
- * - `loading`: Boolean indicating if versions are being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch the versions
- *
- * @example
- * ```tsx
- * function UpgradeOptions() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { versions, loading } = usePlanGroupVersions(currentWorkspace?._id);
- *
- *   if (loading) return <Loading />;
- *
- *   return (
- *     <div>
- *       <p>Current: {versions?.currentVersion.name}</p>
- *       <h4>Available Upgrades:</h4>
- *       {versions?.availableVersions.map(version => (
- *         <UpgradeCard key={version._id} version={version} />
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- */
-declare const usePlanGroupVersions: (workspaceId: string | null | undefined) => {
-    versions: IPlanGroupVersionsResponse | null;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to create a checkout session for a new subscription.
- * Returns a function to initiate the checkout process.
- *
- * @param workspaceId - The workspace ID to create checkout session for. Can be null/undefined.
- * @returns An object containing:
- * - `createCheckoutSession(request)`: Function to create checkout session (throws if workspaceId is null)
- * - `loading`: Boolean indicating if checkout session is being created
- * - `error`: Error message string (null if no error)
- *
- * @example
- * ```tsx
- * function SubscribeButton({ planVersionId }) {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { createCheckoutSession, loading } = useCreateCheckoutSession(currentWorkspace?._id);
- *
- *   const handleSubscribe = async () => {
- *     try {
- *       const result = await createCheckoutSession({
- *         planVersionId,
- *         successUrl: window.location.href,
- *         cancelUrl: window.location.href,
- *       });
- *       // Redirect to checkout
- *       window.location.href = result.checkoutUrl;
- *     } catch (error) {
- *       console.error('Failed to create checkout:', error);
- *     }
- *   };
- *
- *   return (
- *     <button onClick={handleSubscribe} disabled={loading}>
- *       {loading ? 'Loading...' : 'Subscribe'}
- *     </button>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Edge case: Workspace ID not available
- * function SubscribeButton() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { createCheckoutSession } = useCreateCheckoutSession(currentWorkspace?._id);
- *
- *   const handleSubscribe = async () => {
- *     try {
- *       await createCheckoutSession({ planVersionId: 'plan-123' });
- *     } catch (error) {
- *       // Error: "Workspace ID is required"
- *       alert('Please select a workspace first');
- *     }
- *   };
- *
- *   return <button onClick={handleSubscribe}>Subscribe</button>;
- * }
- * ```
- */
-declare const useCreateCheckoutSession: (workspaceId: string | null | undefined) => {
-    createCheckoutSession: (request: ICheckoutSessionRequest) => Promise<CheckoutResult>;
-    loading: boolean;
-    error: string | null;
-};
-/**
- * Hook to update subscription (upgrade/downgrade).
- * Returns checkout session if payment is required, otherwise returns subscription update response.
- *
- * @param workspaceId - The workspace ID to update subscription for. Can be null/undefined.
- * @returns An object containing:
- * - `updateSubscription(planVersionId, options?)`: Function to update subscription (throws if workspaceId is null)
- * - `loading`: Boolean indicating if subscription is being updated
- * - `error`: Error message string (null if no error)
- *
- * @example
- * ```tsx
- * function UpgradeButton({ planVersionId }) {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { updateSubscription, loading } = useUpdateSubscription(currentWorkspace?._id);
- *
- *   const handleUpgrade = async () => {
- *     try {
- *       const result = await updateSubscription(planVersionId, {
- *         billingInterval: 'monthly',
- *         successUrl: window.location.href,
- *         cancelUrl: window.location.href,
- *       });
- *
- *       // Check if payment is required
- *       if ('checkoutUrl' in result) {
- *         window.location.href = result.checkoutUrl;
- *       } else {
- *         // Subscription updated without payment
- *         alert('Subscription updated successfully!');
- *       }
- *     } catch (error) {
- *       console.error('Failed to update subscription:', error);
- *     }
- *   };
- *
- *   return (
- *     <button onClick={handleUpgrade} disabled={loading}>
- *       {loading ? 'Upgrading...' : 'Upgrade'}
- *     </button>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Handle both checkout and direct update responses
- * function SubscriptionUpdater({ planVersionId }) {
- *   const { updateSubscription } = useUpdateSubscription(workspaceId);
- *
- *   const handleUpdate = async () => {
- *     const result = await updateSubscription(planVersionId);
- *
- *     // Type guard to check response type
- *     if ('checkoutUrl' in result) {
- *       // Redirect to payment
- *       window.location.href = result.checkoutUrl;
- *     } else {
- *       // Direct update successful
- *       console.log('Updated subscription:', result.subscription);
- *     }
- *   };
- *
- *   return <button onClick={handleUpdate}>Update</button>;
- * }
- * ```
- */
-declare const useUpdateSubscription: (workspaceId: string | null | undefined) => {
-    updateSubscription: (planVersionId: string, options?: {
-        billingInterval?: BillingInterval;
-        successUrl?: string;
-        cancelUrl?: string;
-    }) => Promise<ISubscriptionUpdateResponse | ICheckoutSessionResponse>;
-    loading: boolean;
-    error: string | null;
-};
-/**
- * Combined hook that provides both subscription and plan group data.
- * Useful for subscription management pages that need both pieces of data.
- * Combines useSubscription, usePlanGroup, and useUpdateSubscription.
- *
- * @param workspaceId - The workspace ID. Can be null/undefined to disable fetching.
- * @param groupVersionId - Optional: specific group version ID to fetch
- * @returns An object containing:
- * - `subscription`: Current subscription data (from useSubscription)
- * - `planGroup`: Plan group data (from usePlanGroup)
- * - `loading`: Boolean indicating if any operation is in progress
- * - `error`: Error message string (null if no error)
- * - `updateSubscription(planVersionId, options?)`: Function to update subscription
- * - `refetch()`: Function to refetch both subscription and plan group
- *
- * @example
- * ```tsx
- * function SubscriptionManagementPage() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const {
- *     subscription,
- *     planGroup,
- *     loading,
- *     updateSubscription,
- *     refetch,
- *   } = useSubscriptionManagement(currentWorkspace?._id);
- *
- *   if (loading) return <Loading />;
- *
- *   return (
- *     <div>
- *       <CurrentPlan subscription={subscription} />
- *       <AvailablePlans planGroup={planGroup} onSelect={updateSubscription} />
- *       <button onClick={refetch}>Refresh</button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useSubscriptionManagement: (workspaceId: string | null | undefined, groupVersionId?: string | null) => {
-    subscription: ISubscriptionResponse | null;
-    planGroup: IPlanGroupResponse | null;
-    loading: boolean;
-    error: string | null;
-    updateSubscription: (planVersionId: string, options?: {
-        billingInterval?: BillingInterval;
-        successUrl?: string;
-        cancelUrl?: string;
-    }) => Promise<ISubscriptionUpdateResponse | ICheckoutSessionResponse>;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to list invoices for a workspace subscription with pagination support.
- * Automatically fetches when workspaceId, limit, or startingAfter changes.
- *
- * @param workspaceId - The workspace ID to get invoices for. Can be null/undefined to disable fetching.
- * @param limit - Number of invoices to return (default: 10)
- * @param startingAfter - Invoice ID to start after (for pagination)
- * @returns An object containing:
- * - `invoices`: Array of invoice objects
- * - `hasMore`: Boolean indicating if there are more invoices to load
- * - `loading`: Boolean indicating if invoices are being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch invoices
- *
- * @example
- * ```tsx
- * function InvoiceList() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { invoices, hasMore, loading, refetch } = useInvoices(currentWorkspace?._id, 10);
- *
- *   if (loading) return <Loading />;
- *
- *   return (
- *     <div>
- *       {invoices.map(invoice => (
- *         <InvoiceCard key={invoice._id} invoice={invoice} />
- *       ))}
- *       {hasMore && <button onClick={() => refetch()}>Load More</button>}
- *     </div>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Pagination example
- * function PaginatedInvoices() {
- *   const [lastInvoiceId, setLastInvoiceId] = useState<string | undefined>();
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { invoices, hasMore, refetch } = useInvoices(
- *     currentWorkspace?._id,
- *     10,
- *     lastInvoiceId
- *   );
- *
- *   const loadMore = () => {
- *     if (invoices.length > 0) {
- *       setLastInvoiceId(invoices[invoices.length - 1]._id);
- *     }
- *   };
- *
- *   return (
- *     <div>
- *       {invoices.map(invoice => <InvoiceCard key={invoice._id} invoice={invoice} />)}
- *       {hasMore && <button onClick={loadMore}>Load More</button>}
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useInvoices: (workspaceId: string | null | undefined, limit?: number, startingAfter?: string) => {
-    invoices: IInvoice[];
-    hasMore: boolean;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to open the Stripe Customer Portal for managing payment methods, invoices, and subscription.
- *
- * @example
- * ```tsx
- * const { openBillingPortal, loading } = useBillingPortal(workspaceId);
- * <Button onClick={() => openBillingPortal()} disabled={loading}>
- *   Manage Payment Method
- * </Button>
- * ```
- */
-declare const useBillingPortal: (workspaceId: string | null | undefined) => {
-    openBillingPortal: (returnUrl?: string) => Promise<{
-        url: string;
-    }>;
-    loading: boolean;
-    error: string | null;
-};
-/**
- * Hook to get a single invoice by ID.
- * Automatically fetches when workspaceId or invoiceId changes.
- *
- * @param workspaceId - The workspace ID. Can be null/undefined to disable fetching.
- * @param invoiceId - The invoice ID to fetch. Can be null/undefined to disable fetching.
- * @returns An object containing:
- * - `invoice`: Invoice data object (null if not loaded)
- * - `loading`: Boolean indicating if invoice is being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch the invoice
- *
- * @example
- * ```tsx
- * function InvoiceDetails({ invoiceId }) {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { invoice, loading, error } = useInvoice(currentWorkspace?._id, invoiceId);
- *
- *   if (loading) return <Loading />;
- *   if (error) return <Error message={error} />;
- *   if (!invoice) return <p>Invoice not found</p>;
- *
- *   return (
- *     <div>
- *       <h2>Invoice #{invoice.invoiceNumber}</h2>
- *       <p>Amount: ${invoice.amount}</p>
- *       <p>Status: {invoice.status}</p>
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useInvoice: (workspaceId: string | null | undefined, invoiceId: string | null | undefined) => {
-    invoice: IInvoice | null;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to cancel a subscription at the end of the current billing period.
- * Sets cancelAtPeriodEnd: true - subscription remains active until period ends.
- *
- * @param workspaceId - The workspace ID. Can be null/undefined.
- * @returns An object containing:
- * - `cancelSubscription()`: Function to cancel subscription at period end
- * - `loading`: Boolean indicating if cancellation is in progress
- * - `error`: Error message string (null if no error)
- *
- * @example
- * ```tsx
- * function CancelSubscriptionButton() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { cancelSubscription, loading } = useCancelSubscription(currentWorkspace?._id);
- *   const { refetch } = useSubscription(currentWorkspace?._id);
- *
- *   const handleCancel = async () => {
- *     try {
- *       await cancelSubscription();
- *       await refetch(); // Refresh subscription data
- *       alert('Subscription will be canceled at the end of the billing period');
- *     } catch (error) {
- *       console.error('Failed to cancel:', error);
- *     }
- *   };
- *
- *   return (
- *     <button onClick={handleCancel} disabled={loading}>
- *       {loading ? 'Canceling...' : 'Cancel Subscription'}
- *     </button>
- *   );
- * }
- * ```
- */
-declare const useCancelSubscription: (workspaceId: string | null | undefined) => {
-    cancelSubscription: () => Promise<ISubscriptionResponse>;
-    loading: boolean;
-    error: string | null;
-};
-/**
- * Hook to resume a subscription that was scheduled for cancellation.
- * Sets cancelAtPeriodEnd: false - subscription will continue after period ends.
- *
- * @param workspaceId - The workspace ID. Can be null/undefined.
- * @returns An object containing:
- * - `resumeSubscription()`: Function to resume subscription
- * - `loading`: Boolean indicating if resume is in progress
- * - `error`: Error message string (null if no error)
- *
- * @example
- * ```tsx
- * function ResumeSubscriptionButton() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { resumeSubscription, loading } = useResumeSubscription(currentWorkspace?._id);
- *   const { refetch } = useSubscription(currentWorkspace?._id);
- *
- *   const handleResume = async () => {
- *     try {
- *       await resumeSubscription();
- *       await refetch(); // Refresh subscription data
- *       alert('Subscription has been resumed');
- *     } catch (error) {
- *       console.error('Failed to resume:', error);
- *     }
- *   };
- *
- *   return (
- *     <button onClick={handleResume} disabled={loading}>
- *       {loading ? 'Resuming...' : 'Resume Subscription'}
- *     </button>
- *   );
- * }
- * ```
- */
-declare const useResumeSubscription: (workspaceId: string | null | undefined) => {
-    resumeSubscription: () => Promise<ISubscriptionResponse>;
-    loading: boolean;
-    error: string | null;
-};
-/**
- * Hook to record quota usage for a workspace.
- * Returns a function to record usage (mutation pattern).
- *
- * @param workspaceId - The workspace ID. Can be null/undefined.
- * @returns An object containing:
- * - `recordUsage(request)`: Function to record usage (throws if workspaceId is null)
- * - `loading`: Boolean indicating if recording is in progress
- * - `error`: Error message string (null if no error)
- *
- * @example
- * ```tsx
- * function RecordUsageButton() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { recordUsage, loading } = useRecordUsage(currentWorkspace?._id);
- *
- *   const handleRecord = async () => {
- *     try {
- *       const result = await recordUsage({
- *         quotaSlug: 'api_calls',
- *         quantity: 1,
- *         source: 'web-app',
- *       });
- *       console.log(`Used: ${result.consumed}/${result.included}`);
- *     } catch (error) {
- *       console.error('Failed to record usage:', error);
- *     }
- *   };
- *
- *   return (
- *     <button onClick={handleRecord} disabled={loading}>
- *       {loading ? 'Recording...' : 'Record Usage'}
- *     </button>
- *   );
- * }
- * ```
- */
-declare const useRecordUsage: (workspaceId: string | null | undefined) => {
-    recordUsage: (request: IRecordUsageRequest) => Promise<IRecordUsageResponse>;
-    loading: boolean;
-    error: string | null;
-};
-/**
- * Hook to get usage status for a single quota.
- * Automatically fetches when workspaceId or quotaSlug changes.
- *
- * @param workspaceId - The workspace ID. Can be null/undefined to disable fetching.
- * @param quotaSlug - The quota slug to check. Can be null/undefined to disable fetching.
- * @returns An object containing:
- * - `status`: Quota usage status (null if not loaded)
- * - `loading`: Boolean indicating if status is being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch the status
- *
- * @example
- * ```tsx
- * function QuotaStatusDisplay() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { status, loading } = useQuotaUsageStatus(currentWorkspace?._id, 'api_calls');
- *
- *   if (loading) return <Loading />;
- *   if (!status) return null;
- *
- *   return (
- *     <div>
- *       <p>Used: {status.consumed} / {status.included}</p>
- *       <p>Available: {status.available}</p>
- *       {status.hasOverage && <p>Overage: {status.overage}</p>}
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useQuotaUsageStatus: (workspaceId: string | null | undefined, quotaSlug: string | null | undefined) => {
-    status: IQuotaUsageStatusResponse | null;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to get usage status for all quotas in the workspace's current plan.
- * Automatically fetches when workspaceId changes.
- *
- * @param workspaceId - The workspace ID. Can be null/undefined to disable fetching.
- * @returns An object containing:
- * - `quotas`: Record of quota usage statuses keyed by slug (null if not loaded)
- * - `loading`: Boolean indicating if statuses are being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch all statuses
- *
- * @example
- * ```tsx
- * function AllQuotasDisplay() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { quotas, loading } = useAllQuotaUsage(currentWorkspace?._id);
- *
- *   if (loading) return <Loading />;
- *   if (!quotas) return null;
- *
- *   return (
- *     <div>
- *       {Object.entries(quotas).map(([slug, usage]) => (
- *         <div key={slug}>
- *           <p>{slug}: {usage.consumed}/{usage.included}</p>
- *           {usage.hasOverage && <p>Overage: {usage.overage}</p>}
- *         </div>
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useAllQuotaUsage: (workspaceId: string | null | undefined) => {
-    quotas: Record<string, IQuotaUsageStatus> | null;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to get paginated usage logs for a workspace.
- * Automatically fetches when workspaceId or filter params change.
- *
- * @param workspaceId - The workspace ID. Can be null/undefined to disable fetching.
- * @param quotaSlug - Optional quota slug to filter logs by.
- * @param options - Optional filters: from, to, source, page, limit
- * @returns An object containing:
- * - `logs`: Array of usage log entries
- * - `totalDocs`: Total number of log entries matching the query
- * - `totalPages`: Total number of pages
- * - `page`: Current page number
- * - `hasNextPage`: Whether there are more pages after the current one
- * - `hasPrevPage`: Whether there are pages before the current one
- * - `loading`: Boolean indicating if logs are being fetched
- * - `error`: Error message string (null if no error)
- * - `refetch()`: Function to manually refetch logs
- *
- * @example
- * ```tsx
- * function UsageLogsTable() {
- *   const { currentWorkspace } = useSaaSWorkspaces();
- *   const { logs, totalPages, page, hasNextPage, loading } = useUsageLogs(
- *     currentWorkspace?._id,
- *     'api_calls',
- *     { limit: 20 }
- *   );
- *
- *   if (loading) return <Loading />;
- *
- *   return (
- *     <div>
- *       {logs.map(log => (
- *         <div key={log._id}>
- *           {log.quotaSlug}: {log.quantity} ({log.createdAt})
- *         </div>
- *       ))}
- *       <p>Page {page} of {totalPages}</p>
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useUsageLogs: (workspaceId: string | null | undefined, quotaSlug?: string, options?: {
-    from?: string;
-    to?: string;
-    source?: string;
-    page?: number;
-    limit?: number;
-}) => {
-    logs: IUsageLogEntry[];
-    totalDocs: number;
-    totalPages: number;
-    page: number;
-    hasNextPage: boolean;
-    hasPrevPage: boolean;
-    loading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-
-interface TrialStatus {
-    /** Whether the current subscription is in trial. */
-    isTrialing: boolean;
-    /** Number of days remaining in the trial. 0 if not trialing or expired. */
-    daysRemaining: number;
-    /** Trial end date as a Date object. null if not trialing. */
-    trialEndsAt: Date | null;
-    /** Trial start date as a Date object. null if not trialing. */
-    trialStartedAt: Date | null;
-    /** Whether the trial is ending soon (<= 3 days remaining). */
-    isTrialEnding: boolean;
-}
-/**
- * Hook that computes trial status from the current subscription context.
- * Must be used within SubscriptionContextProvider.
- *
- * @returns TrialStatus — computed trial information
- *
- * @example
- * ```tsx
- * const { isTrialing, daysRemaining, isTrialEnding } = useTrialStatus();
- *
- * if (isTrialEnding) {
- *   return <UpgradeBanner daysLeft={daysRemaining} />;
- * }
- * ```
- */
-declare function useTrialStatus(): TrialStatus;
-
-interface SeatStatus {
-    /** Whether the current plan uses seat-based pricing. */
-    hasSeatPricing: boolean;
-    /** Total workspace members. */
-    memberCount: number;
-    /** Seats included in the base price (free). */
-    includedSeats: number;
-    /** Maximum seats allowed. 0 = unlimited. */
-    maxSeats: number;
-    /** Seats beyond included that are being billed. */
-    billableSeats: number;
-    /** Remaining seats before hitting max. Infinity if unlimited. */
-    availableSeats: number;
-    /** Whether workspace is at max seat capacity. */
-    isAtMax: boolean;
-    /** Whether workspace is near max (>= 80% used). */
-    isNearMax: boolean;
-    /** Per-seat price in cents for the current billing interval. Null if not applicable. */
-    perSeatPriceCents: number | null;
-    /** Billing currency. */
-    currency: string;
+    createBillingPortalSession(workspaceId: string, returnUrl?: string): Promise<{
+        url: string;
+    }>;
+    /**
+     * 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
+     */
+    getInvoice(workspaceId: string, invoiceId: string): Promise<IInvoiceResponse>;
+    /**
+     * Cancel subscription at the end of the current billing period
+     * Sets cancelAtPeriodEnd: true - subscription remains active until period ends
+     * @param workspaceId - The workspace ID
+     * @returns Updated subscription with cancelAtPeriodEnd and stripeCurrentPeriodEnd
+     */
+    cancelSubscriptionAtPeriodEnd(workspaceId: string): Promise<ISubscriptionResponse>;
+    /**
+     * Resume a subscription that was scheduled for cancellation
+     * Sets cancelAtPeriodEnd: false - subscription will continue after period ends
+     * @param workspaceId - The workspace ID
+     * @returns Updated subscription with cancelAtPeriodEnd set to false
+     */
+    resumeSubscription(workspaceId: string): Promise<ISubscriptionResponse>;
+    /**
+     * Record quota usage for a workspace
+     * @param workspaceId - The workspace ID
+     * @param request - Usage request with quotaSlug, quantity, and optional metadata/source
+     * @returns Usage result with consumed/included/available/overage
+     */
+    recordUsage(workspaceId: string, request: IRecordUsageRequest): Promise<IRecordUsageResponse>;
+    /**
+     * Get usage status for a single quota
+     * @param workspaceId - The workspace ID
+     * @param quotaSlug - The quota slug to check
+     * @returns Quota usage status with consumed/included/available/overage/hasOverage
+     */
+    getQuotaUsageStatus(workspaceId: string, quotaSlug: string): Promise<IQuotaUsageStatusResponse>;
+    /**
+     * Get usage status for all quotas in the workspace's current plan
+     * @param workspaceId - The workspace ID
+     * @returns All quota usage statuses keyed by quota slug
+     */
+    getAllQuotaUsage(workspaceId: string): Promise<IAllQuotaUsageResponse>;
+    /**
+     * Get paginated usage logs for a workspace
+     * @param workspaceId - The workspace ID
+     * @param query - Optional filters: quotaSlug, from, to, source, page, limit
+     * @returns Paginated usage log entries
+     */
+    getUsageLogs(workspaceId: string, query?: IUsageLogsQuery): Promise<IUsageLogsResponse>;
 }
-/**
- * Hook that computes seat status from subscription context and workspace data.
- * Must be used within SubscriptionContextProvider.
- *
- * @param workspace - The current workspace (needs users array)
- * @returns SeatStatus — computed seat information
- *
- * @example
- * ```tsx
- * const { isAtMax, availableSeats, billableSeats } = useSeatStatus(workspace);
- *
- * if (isAtMax) {
- *   return <UpgradeBanner />;
- * }
- * ```
- */
-declare function useSeatStatus(workspace: {
-    users?: any[];
-    billingCurrency?: string | null;
-} | null): SeatStatus;
-
-interface PushNotificationState {
-    /** Browser's Notification.permission: 'default' | 'granted' | 'denied' */
-    permission: NotificationPermission;
-    /** Whether this device is subscribed to push notifications */
-    isSubscribed: boolean;
-    /** Whether the browser supports push notifications */
-    isSupported: boolean;
-    /** Loading state for subscribe/unsubscribe operations */
-    loading: boolean;
-    /** Error message from the last operation */
-    error: string | null;
-}
-interface PushNotificationContextValue extends PushNotificationState {
-    /** Request notification permission from the browser. Returns true if granted. */
-    requestPermission: () => Promise<boolean>;
-    /** Subscribe this device to push notifications (requests permission if needed). */
-    subscribe: () => Promise<void>;
-    /** Unsubscribe this device from push notifications. */
-    unsubscribe: () => Promise<void>;
-}
-interface PushNotificationProviderProps {
-    children: react__default.ReactNode;
-    /** Path to the service worker file (default: '/push-sw.js') */
-    serviceWorkerPath?: string;
-    /** Automatically subscribe after permission is granted on login (default: false) */
-    autoSubscribe?: boolean;
-}
-declare const PushNotificationProvider: react__default.FC<PushNotificationProviderProps>;
-/**
- * Hook to access push notification state and actions.
- * Must be used within PushNotificationProvider (included in SaaSOSProvider when push config is provided).
- */
-declare function usePushNotifications(): PushNotificationContextValue;
-
-/**
- * Push notification service worker source code.
- * Export this string and write it to a file in your app's `public/` directory.
- *
- * @example
- * ```ts
- * // scripts/generate-sw.ts
- * import { PUSH_SERVICE_WORKER_SCRIPT } from '@buildbase/sdk';
- * import fs from 'fs';
- * fs.writeFileSync('public/push-sw.js', PUSH_SERVICE_WORKER_SCRIPT);
- * ```
- *
- * Or manually create `public/push-sw.js` with this content.
- */
-declare const PUSH_SERVICE_WORKER_SCRIPT = "\n// BuildBase Push Notification Service Worker\n// Place this file in your app's public directory (e.g. public/push-sw.js)\n\nself.addEventListener('push', function(event) {\n  if (!event.data) return;\n\n  try {\n    var payload = event.data.json();\n    var title = payload.title || 'Notification';\n    var options = {\n      body: payload.body || '',\n      icon: payload.icon || undefined,\n      badge: payload.icon || undefined,\n      data: { url: payload.url, ...(payload.data || {}) },\n      tag: 'buildbase-push-' + Date.now(),\n    };\n\n    event.waitUntil(\n      self.registration.showNotification(title, options)\n    );\n  } catch (e) {\n    console.error('[PushSW] Failed to show notification:', e);\n  }\n});\n\nself.addEventListener('notificationclick', function(event) {\n  event.notification.close();\n\n  var url = event.notification.data && event.notification.data.url;\n  if (url) {\n    event.waitUntil(\n      clients.matchAll({ type: 'window', includeUncontrolled: true }).then(function(clientList) {\n        for (var i = 0; i < clientList.length; i++) {\n          var client = clientList[i];\n          if (client.url === url && 'focus' in client) {\n            return client.focus();\n          }\n        }\n        if (clients.openWindow) {\n          return clients.openWindow(url);\n        }\n      })\n    );\n  }\n});\n";
 
 /**
  * EventEmitter class to handle and trigger event callbacks
@@ -2792,14 +1154,16 @@ declare class EventEmitter {
 declare const eventEmitter: EventEmitter;
 
 /**
- * Centralized API client for organization (OS) settings.
- * Extends BaseApi for shared URL/auth/request handling.
+ * Notify all subscribers to refetch subscription (e.g. after update/cancel/resume).
+ * Called internally by useUpdateSubscription, useCancelSubscription, useResumeSubscription on success.
  */
+declare function invalidateSubscription(): void;
 
-declare class SettingsApi extends BaseApi {
-    constructor(config: IOsConfig);
-    getSettings(signal?: AbortSignal): Promise<ISettings>;
-}
+/**
+ * Notify all subscribers to refetch quota usage (e.g. after recording usage).
+ * Called internally by useRecordUsage on success.
+ */
+declare function invalidateQuotaUsage(): void;
 
 /**
  * Centralized formatting for subscription/quota display: cents, overage rates, included + overage text.
@@ -2846,6 +1210,30 @@ declare function getQuotaUnitLabelFromName(nameOrSlug: string): string;
  */
 declare function formatQuotaIncludedOverage(included: number | undefined, overageCents: number | undefined, unitLabel: string, currency: string, unitSize?: number): string;
 
+type QuotaDisplayValue = {
+    included: number;
+    overage?: number;
+    unitSize?: number;
+} | null;
+/**
+ * Normalize a per-interval quota value to a display shape for the given billing interval.
+ */
+declare function getQuotaDisplayValue(value: IQuotaByInterval | null | undefined, interval?: BillingInterval): QuotaDisplayValue;
+/** Options for formatting quota with price. */
+interface FormatQuotaWithPriceOptions {
+    /** If true, overage is in cents (Stripe); format as dollars. Default true. */
+    overageInCents?: boolean;
+    /** Currency symbol override. When omitted, derived from `currency` (empty if no currency). */
+    currencySymbol?: string;
+    /** Stripe currency code (e.g. 'usd', 'inr'). Used to resolve symbol when currencySymbol is not set. */
+    currency?: string;
+}
+/**
+ * Format a quota display value as "X included, then $Y.YY / unit" (e.g. "10 included, then $10.00 / video").
+ * Assumes overage is the per-unit price (in cents when overageInCents is true).
+ */
+declare function formatQuotaWithPrice(value: QuotaDisplayValue, unitName: string, options?: FormatQuotaWithPriceOptions): string;
+
 /**
  * Helpers for multi-currency plan version pricing (pricingVariants).
  */
@@ -2912,30 +1300,361 @@ declare function calculateSeatOverageCents(planVersion: IPlanVersion, currency:
  * Does not include metered usage (billed at period end).
  */
 declare function calculateTotalSubscriptionCents(planVersion: IPlanVersion, currency: string, interval: BillingInterval, currentSeatCount?: number): number | null;
-
-type QuotaDisplayValue = {
-    included: number;
-    overage?: number;
-    unitSize?: number;
-} | null;
+interface MaxUsersConfig {
+    /** The resolved maximum number of users allowed. 0 = unlimited. */
+    maxUsers: number;
+    /** Where the limit comes from. */
+    source: 'seat_pricing' | 'settings' | 'none';
+    /** Seats included in the base plan price (0 if no seat pricing). */
+    includedSeats: number;
+    /** Whether seat-based pricing is active. */
+    hasSeatPricing: boolean;
+}
 /**
- * Normalize a per-interval quota value to a display shape for the given billing interval.
+ * Resolve the effective max users limit from the plan's seat pricing config,
+ * falling back to settings when no seat pricing is configured.
+ *
+ * Priority:
+ * 1. Seat pricing `maxSeats` (from plan version's pricing variant) — the plan controls the limit
+ * 2. Settings fallback (`workspace.maxWorkspaceUsers`) — for workspaces without a subscription
+ *
+ * Returns 0 if no limit is set (unlimited).
  */
-declare function getQuotaDisplayValue(value: IQuotaByInterval | null | undefined, interval?: BillingInterval): QuotaDisplayValue;
-/** Options for formatting quota with price. */
-interface FormatQuotaWithPriceOptions {
-    /** If true, overage is in cents (Stripe); format as dollars. Default true. */
-    overageInCents?: boolean;
-    /** Currency symbol override. When omitted, derived from `currency` (empty if no currency). */
-    currencySymbol?: string;
-    /** Stripe currency code (e.g. 'usd', 'inr'). Used to resolve symbol when currencySymbol is not set. */
+declare function resolveMaxUsers(opts: {
+    planVersion?: IPlanVersion | null;
     currency?: string;
+    settingsMaxUsers?: number | null;
+}): MaxUsersConfig;
+type InviteBlockReason = 'seat_limit_reached' | 'settings_user_limit_reached' | 'no_subscription' | null;
+interface InviteValidation {
+    /** Whether a new user can be invited. */
+    canInvite: boolean;
+    /** Reason the invite is blocked, or null if allowed. */
+    blockReason: InviteBlockReason;
+    /** Human-readable message for the block reason. */
+    blockMessage: string | null;
 }
 /**
- * Format a quota display value as "X included, then $Y.YY / unit" (e.g. "10 included, then $10.00 / video").
- * Assumes overage is the per-unit price (in cents when overageInCents is true).
+ * Validate whether a new member can be invited given current seat/user limits.
  */
-declare function formatQuotaWithPrice(value: QuotaDisplayValue, unitName: string, options?: FormatQuotaWithPriceOptions): string;
+declare function validateInvite(opts: {
+    memberCount: number;
+    maxUsersConfig: MaxUsersConfig;
+    hasSubscription?: boolean;
+    requireSubscription?: boolean;
+}): InviteValidation;
+
+/**
+ * Push notification service worker source code.
+ * Export this string and write it to a file in your app's `public/` directory.
+ *
+ * @example
+ * ```ts
+ * // scripts/generate-sw.ts
+ * import { PUSH_SERVICE_WORKER_SCRIPT } from '@buildbase/sdk';
+ * import fs from 'fs';
+ * fs.writeFileSync('public/push-sw.js', PUSH_SERVICE_WORKER_SCRIPT);
+ * ```
+ *
+ * Or manually create `public/push-sw.js` with this content.
+ */
+declare const PUSH_SERVICE_WORKER_SCRIPT = "\n// BuildBase Push Notification Service Worker\n// Place this file in your app's public directory (e.g. public/push-sw.js)\n\nself.addEventListener('push', function(event) {\n  if (!event.data) return;\n\n  try {\n    var payload = event.data.json();\n    var title = payload.title || 'Notification';\n    var options = {\n      body: payload.body || '',\n      icon: payload.icon || undefined,\n      badge: payload.icon || undefined,\n      data: { url: payload.url, ...(payload.data || {}) },\n      tag: 'buildbase-push-' + Date.now(),\n    };\n\n    event.waitUntil(\n      self.registration.showNotification(title, options)\n    );\n  } catch (e) {\n    console.error('[PushSW] Failed to show notification:', e);\n  }\n});\n\nself.addEventListener('notificationclick', function(event) {\n  event.notification.close();\n\n  var url = event.notification.data && event.notification.data.url;\n  if (url) {\n    event.waitUntil(\n      clients.matchAll({ type: 'window', includeUncontrolled: true }).then(function(clientList) {\n        for (var i = 0; i < clientList.length; i++) {\n          var client = clientList[i];\n          if (client.url === url && 'focus' in client) {\n            return client.focus();\n          }\n        }\n        if (clients.openWindow) {\n          return clients.openWindow(url);\n        }\n      })\n    );\n  }\n});\n";
+
+declare const countries: {
+    value: string;
+    flag: string;
+    text: string;
+    currencyCode: string;
+    currencyIcon: string;
+}[];
+
+declare const uniqueCurrencies: {
+    value: string;
+    text: string;
+    icon: any;
+}[];
+
+declare const languages: {
+    value: string;
+    label: string;
+    flag: string;
+}[];
+
+declare const timezones: {
+    value: string;
+    abbr: string;
+    offset: number;
+    isdst: boolean;
+    text: string;
+    utc: string[];
+}[];
+
+declare const formSchema: z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodString;
+}, z.core.$strip>;
+type formValuesType = z.infer<typeof formSchema>;
+
+interface BetaFormData {
+    name?: string;
+    email: string;
+}
+interface BetaFormResponse {
+    success: boolean;
+    message: string;
+}
+
+/**
+ * Server-side BuildBase SDK — Auth.js-style configuration pattern.
+ *
+ * Configure once, use everywhere. Session is resolved automatically.
+ *
+ * @example 1. Configure once (lib/buildbase.ts)
+ * ```ts
+ * import BuildBase from "@buildbase/sdk"
+ * import { cookies } from "next/headers"
+ *
+ * export const { auth, workspace, subscription, usage } = BuildBase({
+ *   serverUrl: process.env.BUILDBASE_URL!,
+ *   orgId: process.env.BUILDBASE_ORG_ID!,
+ *   getSessionId: async () => {
+ *     const c = await cookies()
+ *     return c.get("bb-session-id")?.value ?? null
+ *   },
+ * })
+ * ```
+ *
+ * @example 2. Use in API routes — no sessionId passing needed
+ * ```ts
+ * import { auth, workspace, subscription } from "@/lib/buildbase"
+ *
+ * export async function GET() {
+ *   const session = await auth()
+ *   if (!session) return Response.json({ error: "Unauthorized" }, { status: 401 })
+ *
+ *   const workspaces = await workspace.list()
+ *   const sub = await subscription.get(workspaceId)
+ *   return Response.json({ workspaces, sub })
+ * }
+ * ```
+ *
+ * @example 3. Background jobs — override session for service accounts
+ * ```ts
+ * import { client } from "@/lib/buildbase"
+ *
+ * const api = client.forSession(process.env.SERVICE_SESSION_ID!)
+ * await api.workspace.recordUsage(workspaceId, { quotaSlug: "uploads", quantity: 1 })
+ * ```
+ */
+
+interface BuildBaseConfig {
+    /** Base URL of the BuildBase API server */
+    serverUrl: string;
+    /** Organization ID */
+    orgId: string;
+    /** API version (default: 'v1') */
+    version?: ApiVersion;
+    /**
+     * Async callback to resolve the current session ID.
+     * Called automatically before each authenticated API call.
+     *
+     * @example Next.js (httpOnly cookie)
+     * ```ts
+     * getSessionId: async () => {
+     *   const c = await cookies()
+     *   return c.get("bb-session-id")?.value ?? null
+     * }
+     * ```
+     *
+     * @example Express (from request — use withSession() instead)
+     * ```ts
+     * // Don't set getSessionId for Express. Use withSession(req.sessionId) per-request.
+     * ```
+     */
+    getSessionId?: () => Promise<string | null>;
+    /**
+     * Request timeout in milliseconds. (default: 30000 — 30 seconds)
+     * Set to 0 to disable timeout.
+     */
+    timeout?: number;
+    /**
+     * Maximum number of automatic retries for transient network failures.
+     * Uses exponential backoff. (default: 0 — no retries)
+     * Only retries on network errors and 5xx responses, never on 4xx.
+     */
+    maxRetries?: number;
+    /**
+     * Enable debug logging. Logs all API requests/responses to console.
+     * (default: false)
+     */
+    debug?: boolean;
+    /**
+     * Custom headers merged into every request.
+     * Useful for proxies, tracing, or custom auth schemes.
+     *
+     * @example
+     * ```ts
+     * headers: {
+     *   'X-Request-Source': 'backend-cron',
+     *   'X-Trace-Id': traceId,
+     * }
+     * ```
+     */
+    headers?: Record<string, string>;
+    /**
+     * Called when any API request fails. Use for centralized error logging.
+     * The error is still thrown after this callback runs.
+     *
+     * @example
+     * ```ts
+     * onError: (error, context) => {
+     *   Sentry.captureException(error, { extra: context })
+     * }
+     * ```
+     */
+    onError?: (error: Error, context: {
+        method: string;
+        path: string;
+    }) => void;
+    /**
+     * Custom fetch implementation. Replaces the global `fetch`.
+     * Useful for testing, proxying, or adding middleware.
+     *
+     * @example Using undici for Node.js
+     * ```ts
+     * import { fetch } from 'undici'
+     * { fetch: fetch as any }
+     * ```
+     */
+    fetch?: typeof globalThis.fetch;
+}
+interface BuildBaseSession {
+    sessionId: string;
+}
+interface WorkspaceActions {
+    list(): Promise<IWorkspace[]>;
+    get(workspaceId: string): Promise<IWorkspace>;
+    create(data: {
+        name: string;
+        image?: string;
+    }): Promise<IWorkspace>;
+    update(workspaceId: string, data: Partial<IWorkspace>): Promise<IWorkspace>;
+    delete(workspaceId: string): Promise<{
+        success: boolean;
+    }>;
+}
+interface UserActions {
+    list(workspaceId: string): Promise<IWorkspaceUser[]>;
+    invite(workspaceId: string, email: string, role: string): Promise<{
+        userId: string;
+        workspace: IWorkspace;
+        message: string;
+    }>;
+    remove(workspaceId: string, userId: string): Promise<{
+        userId: string;
+        workspace: IWorkspace;
+        message: string;
+    }>;
+    updateRole(workspaceId: string, userId: string, role: string): Promise<{
+        userId: string;
+        workspace: IWorkspace;
+        message: string;
+    }>;
+    getProfile(): Promise<IUser>;
+    updateProfile(data: Partial<IUser>): Promise<IUser>;
+}
+interface SubscriptionActions {
+    get(workspaceId: string): Promise<ISubscriptionResponse>;
+    checkout(workspaceId: string, request: ICheckoutSessionRequest): Promise<CheckoutResult | ICheckoutSessionResponse>;
+    update(workspaceId: string, request: ISubscriptionUpdateRequest): Promise<ISubscriptionUpdateResponse | ICheckoutSessionResponse>;
+    cancel(workspaceId: string): Promise<ISubscriptionResponse>;
+    resume(workspaceId: string): Promise<ISubscriptionResponse>;
+    getBillingPortalUrl(workspaceId: string, returnUrl?: string): Promise<{
+        url: string;
+    }>;
+}
+interface PlanActions {
+    getGroup(workspaceId: string): Promise<IPlanGroupResponse>;
+    getVersions(workspaceId: string): Promise<IPlanGroupVersionsResponse>;
+    /** No auth required */
+    getPublic(slug: string): Promise<IPublicPlansResponse>;
+    /** No auth required */
+    getVersion(groupVersionId: string): Promise<IPlanGroupVersion>;
+}
+interface InvoiceActions {
+    list(workspaceId: string, limit?: number, startingAfter?: string): Promise<IInvoiceListResponse>;
+    get(workspaceId: string, invoiceId: string): Promise<IInvoiceResponse>;
+}
+interface UsageActions {
+    record(workspaceId: string, request: IRecordUsageRequest): Promise<IRecordUsageResponse>;
+    getQuota(workspaceId: string, quotaSlug: string): Promise<IQuotaUsageStatusResponse>;
+    getAll(workspaceId: string): Promise<IAllQuotaUsageResponse>;
+    getLogs(workspaceId: string, query?: IUsageLogsQuery): Promise<IUsageLogsResponse>;
+}
+interface SettingsActions {
+    get(): Promise<ISettings>;
+}
+interface FeatureActions {
+    list(): Promise<IWorkspaceFeature[]>;
+    update(workspaceId: string, key: string, value: boolean): Promise<IWorkspace>;
+}
+/** All action modules bound to a specific session. Returned by `withSession()`. */
+interface ScopedActions {
+    workspace: WorkspaceActions;
+    users: UserActions;
+    subscription: SubscriptionActions;
+    plans: PlanActions;
+    invoices: InvoiceActions;
+    usage: UsageActions;
+    settings: SettingsActions;
+    features: FeatureActions;
+}
+interface BuildBaseResult extends ScopedActions {
+    /**
+     * Check authentication. Returns session or null.
+     * Uses the `getSessionId` callback from config.
+     *
+     * ```ts
+     * const session = await auth()
+     * if (!session) return Response.json({ error: "Unauthorized" }, { status: 401 })
+     * ```
+     */
+    auth(): Promise<BuildBaseSession | null>;
+    /**
+     * Create a scoped client bound to a specific session ID.
+     * Returns all the same action modules (workspace, subscription, etc.)
+     * but using the provided session instead of the `getSessionId` callback.
+     *
+     * Use this for frameworks without async request context (Express, Hono, Fastify)
+     * or for background jobs / service accounts.
+     *
+     * @example Express
+     * ```ts
+     * app.get("/api/workspaces", async (req, res) => {
+     *   const bb = withSession(req.headers["x-session-id"])
+     *   const workspaces = await bb.workspace.list()
+     *   res.json(workspaces)
+     * })
+     * ```
+     *
+     * @example Background job
+     * ```ts
+     * const bb = withSession(process.env.SERVICE_SESSION_ID!)
+     * await bb.usage.record(workspaceId, { quotaSlug: "uploads", quantity: 5 })
+     * ```
+     */
+    withSession(sessionId: string): ScopedActions;
+    /** Low-level API classes bound to a specific session */
+    client: {
+        forSession(sessionId: string): {
+            workspace: WorkspaceApi;
+            user: UserApi;
+            settings: SettingsApi;
+            push: PushApi;
+        };
+    };
+}
+declare function BuildBase(config: BuildBaseConfig): BuildBaseResult;
 
-export { ApiVersion, AuthStatus, BaseApi, BetaForm, CURRENCY_DISPLAY, CURRENCY_FLAG, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, PUSH_SERVICE_WORKER_SCRIPT, PricingPage, PushNotificationProvider, QuotaUsageContextProvider, SaaSOSProvider, SettingsApi, SubscriptionContextProvider, UserApi, WhenAuthenticated, WhenNoSubscription, WhenNotTrialing, WhenQuotaAvailable, WhenQuotaExhausted, WhenQuotaOverage, WhenQuotaThreshold, WhenRoles, WhenSubscription, WhenSubscriptionToPlans, WhenTrialEnding, WhenTrialing, WhenUnauthenticated, WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, WhenWorkspaceRoles, WorkspaceApi, WorkspaceSwitcher, calculateBillableSeats, calculateSeatOverageCents, calculateTotalSubscriptionCents, eventEmitter, formatCents, formatOverageRate, formatOverageRateWithLabel, formatQuotaIncludedOverage, formatQuotaWithPrice, getAvailableCurrenciesFromPlans, getBasePriceCents, getBillingIntervalAndCurrencyFromPriceId, getCurrencyFlag, getCurrencySymbol, getDisplayCurrency, getPerSeatPriceCents, getPricingVariant, getQuotaDisplayValue, getQuotaDisplayWithVariant, getQuotaOverageCents, getQuotaUnitLabelFromName, getSeatPricing, getStripePriceIdForInterval, invalidateQuotaUsage, invalidateSubscription, useAllQuotaUsage, useBillingPortal, useCancelSubscription, useCreateCheckoutSession, useInvoice, useInvoices, usePlanGroup, usePlanGroupVersions, usePublicPlanGroupVersion, usePublicPlans, usePushNotifications, useQuotaUsageContext, useQuotaUsageStatus, useRecordUsage, useResumeSubscription, useSaaSAuth, useSaaSOs, useSaaSSettings, useSaaSWorkspaces, useSeatStatus, useSubscription, useSubscriptionContext, useSubscriptionManagement, useTrialStatus, useUpdateSubscription, useUsageLogs, useUserAttributes, useUserFeatures };
-export type { BillingInterval, CheckoutResult, EventData, EventType, FormatQuotaWithPriceOptions, IAllQuotaUsageResponse, IBaseApiConfig, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, IEventCallbacks, IInvoice, IInvoiceListResponse, IInvoiceResponse, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPricingVariant, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaOveragePriceIdsByInterval, IQuotaOveragesByInterval, IQuotaUsageStatus, IQuotaUsageStatusResponse, IRecordUsageRequest, IRecordUsageResponse, IStripePricesByInterval, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, IUsageLogEntry, IUsageLogsQuery, IUsageLogsResponse, InvoiceStatus, OnWorkspaceChangeParams, PlanVersionWithPricingVariants, PricingPageDetails, PricingPageProps, QuotaDisplayValue, QuotaDisplayWithOverage, QuotaUsageContextValue, SeatStatus, SubscriptionContextValue, TrialStatus, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };
+export { ApiVersion, AuthApi, AuthStatus, BaseApi, BetaForm, BuildBase, CURRENCY_DISPLAY, CURRENCY_FLAG, EventEmitter, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, PUSH_SERVICE_WORKER_SCRIPT, PushApi, SettingsApi, UserApi, WorkspaceApi, formSchema as betaFormSchema, calculateBillableSeats, calculateSeatOverageCents, calculateTotalSubscriptionCents, countries, uniqueCurrencies as currencies, BuildBase as default, eventEmitter, formatCents, formatOverageRate, formatOverageRateWithLabel, formatQuotaIncludedOverage, formatQuotaWithPrice, getAvailableCurrenciesFromPlans, getBasePriceCents, getBillingIntervalAndCurrencyFromPriceId, getCurrencyFlag, getCurrencySymbol, getDisplayCurrency, getPerSeatPriceCents, getPricingVariant, getQuotaDisplayValue, getQuotaDisplayWithVariant, getQuotaOverageCents, getQuotaUnitLabelFromName, getSeatPricing, getStripePriceIdForInterval, invalidateQuotaUsage, invalidateSubscription, languages, resolveMaxUsers, timezones, validateInvite };
+export type { BetaFormData, BetaFormResponse, formValuesType as BetaFormValues, BillingInterval, BuildBaseConfig, BuildBaseResult, BuildBaseSession, CheckoutResult, EventData, EventType, FeatureActions, FormatQuotaWithPriceOptions, IAllQuotaUsageResponse, IBaseApiConfig, IBasePricing, IBetaConfig, ICheckoutSessionRequest, ICheckoutSessionResponse, IEventCallbacks, IInvoice, IInvoiceListResponse, IInvoiceResponse, IOsConfig, IOsState, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPricingVariant, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaOveragePriceIdsByInterval, IQuotaOveragesByInterval, IQuotaUsageStatus, IQuotaUsageStatusResponse, IRecordUsageRequest, IRecordUsageResponse, IStripePricesByInterval, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, IUsageLogEntry, IUsageLogsQuery, IUsageLogsResponse, InviteBlockReason, InviteValidation, InvoiceActions, InvoiceStatus, MaxUsersConfig, OnWorkspaceChangeParams, PlanActions, PlanVersionWithPricingVariants, QuotaDisplayValue, QuotaDisplayWithOverage, ScopedActions, SettingsActions, SubscriptionActions, UsageActions, UserActions, UserCreatedEventData, UserUpdatedEventData, WorkspaceActions, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };