@buildbase/sdk 0.0.16 → 0.0.19

package/dist/types/components/subscription/index.d.ts

@@ -0,0 +1,108 @@
+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;
+}
+/**
+ * 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>
+ * ```
+ */
+export declare const WhenSubscription: (props: IWhenSubscriptionProps) => import("react").ReactNode;
+/**
+ * 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>
+ * ```
+ */
+export declare const WhenNoSubscription: (props: IWhenSubscriptionProps) => import("react").ReactNode;
+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;
+}
+/**
+ * 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>
+ * ```
+ */
+export declare const WhenSubscriptionToPlans: (props: IWhenSubscriptionToPlansProps) => import("react").ReactNode;
+export {};

package/dist/types/contexts/SubscriptionContext/SubscriptionContext.d.ts

@@ -0,0 +1,22 @@
+import React, { type ReactNode } from 'react';
+import type { SubscriptionContextValue } from './types';
+/**
+ * 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
+ */
+export declare const SubscriptionContextProvider: React.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
+ */
+export declare function useSubscriptionContext(): SubscriptionContextValue;

package/dist/types/contexts/SubscriptionContext/index.d.ts

@@ -0,0 +1,2 @@
+export { SubscriptionContextProvider, useSubscriptionContext } from './SubscriptionContext';
+export type { SubscriptionContextValue } from './types';

package/dist/types/contexts/SubscriptionContext/subscriptionInvalidation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Internal notifier for subscription data invalidation.
+ * When subscription is updated (plan change, cancel, resume), call invalidateSubscription()
+ * so SubscriptionContextProvider refetches and gates stay in sync.
+ */
+type Listener = () => void;
+/**
+ * Subscribe a refetch callback to be called when subscription is invalidated.
+ *
+ * @param fn - Callback (e.g. refetch) to run when invalidateSubscription() is called
+ * @returns Unsubscribe function to remove the callback
+ */
+export declare function subscribeSubscriptionInvalidate(fn: Listener): () => void;
+/**
+ * Notify all subscribers to refetch subscription (e.g. after update/cancel/resume).
+ * Called internally by useUpdateSubscription, useCancelSubscription, useResumeSubscription on success.
+ */
+export declare function invalidateSubscription(): void;
+export {};

package/dist/types/contexts/SubscriptionContext/types.d.ts

@@ -0,0 +1,12 @@
+import type { ISubscriptionResponse } from '../../api/types';
+/**
+ * Value provided by SubscriptionContext and returned by useSubscriptionContext.
+ */
+export 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;
+    /** Refetch subscription for the current workspace. Call after plan change (e.g. upgrade) or when subscription was updated elsewhere. */
+    refetch: () => Promise<void>;
+}

package/dist/types/contexts/index.d.ts

@@ -6,6 +6,8 @@ export { WorkspaceContextProvider, getInitialWorkspaceState, useWorkspaceContext
 export type { WorkspaceAction, WorkspaceContextValue, WorkspaceState } from './WorkspaceContext';
 export { SDKContextProvider } from './SDKContext';
 export type { SDKContextValue } from './SDKContext';
+export { SubscriptionContextProvider, useSubscriptionContext } from './SubscriptionContext';
+export type { SubscriptionContextValue } from './SubscriptionContext';
 export { useAppSelector } from './shared/useAppSelector';
 export type { SDKState } from './shared/useAppSelector';
 export { useAppDispatch } from './shared/useAppDispatch';

package/dist/types/contexts/shared/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Combined SDK state and dispatch types.
+ * Single source of truth for the shape used by useAppSelector and useAppDispatch.
+ */
+import type { IAuthState } from '../../providers/auth/types';
+import type { IOsState } from '../../providers/os/types';
+import type { AuthAction } from '../AuthContext/types';
+import type { OSAction } from '../OSContext/types';
+import type { WorkspaceAction, WorkspaceState } from '../WorkspaceContext/types';
+/** Combined SDK state (state only, no dispatch). Used by useAppSelector. */
+export interface SDKState {
+    os: IOsState;
+    auth: IAuthState;
+    workspaces: WorkspaceState;
+}
+/** Combined SDK dispatch. Used by useAppDispatch. */
+export interface SDKDispatch {
+    auth: (action: AuthAction) => void;
+    os: (action: OSAction) => void;
+    workspaces: (action: WorkspaceAction) => void;
+}

package/dist/types/contexts/shared/useAppDispatch.d.ts

@@ -1,15 +1,5 @@
-import type { AuthAction } from '../AuthContext/types';
-import type { OSAction } from '../OSContext/types';
-import type { WorkspaceAction } from '../WorkspaceContext/types';
-/**
- * Combined SDK Dispatch
- * Provides dispatch functions for all contexts
- */
-export interface SDKDispatch {
-    auth: (action: AuthAction) => void;
-    os: (action: OSAction) => void;
-    workspaces: (action: WorkspaceAction) => void;
-}
+import type { SDKDispatch } from './types';
+export type { SDKDispatch } from './types';
 /**
  * Combined dispatch hook - dispatch actions to all contexts
  *

package/dist/types/contexts/shared/useAppSelector.d.ts

@@ -1,15 +1,5 @@
-import type { IAuthState } from '../../providers/auth/types';
-import type { IOsState } from '../../providers/os/types';
-import type { WorkspaceState } from '../WorkspaceContext/types';
-/**
- * Combined SDK State
- * Represents the complete state structure across all contexts
- */
-export interface SDKState {
-    os: IOsState;
-    auth: IAuthState;
-    workspaces: WorkspaceState;
-}
+import type { SDKState } from './types';
+export type { SDKState } from './types';
 /**
  * Combined selector hook - select from all contexts at once
  *

package/dist/types/contexts/shared/utils/reducerHelpers.d.ts

@@ -4,8 +4,8 @@
 /**
  * Creates a simple reducer case that updates a single field
  */
-export declare function updateField<State extends Record<string, any>>(state: State, field: keyof State, value: any): State;
+export declare function updateField<State, K extends keyof State>(state: State, field: K, value: State[K]): State;
 /**
  * Creates a reducer case that updates multiple fields
  */
-export declare function updateFields<State extends Record<string, any>>(state: State, updates: Partial<State>): State;
+export declare function updateFields<State extends object>(state: State, updates: Partial<State>): State;

package/dist/types/index.d.ts

@@ -7,14 +7,24 @@ export type { PricingPageDetails, PricingPageProps } from './components/pricing'
 export { WhenAuthenticated, WhenUnauthenticated } from './components/user/auth';
 export { WhenRoles, WhenWorkspaceRoles } from './components/user/role';
 export { WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, } from './components/features';
+export { WhenNoSubscription, WhenSubscription, WhenSubscriptionToPlans, } from './components/subscription';
+export { SubscriptionContextProvider, useSubscriptionContext, } from './contexts/SubscriptionContext';
+export type { SubscriptionContextValue } from './contexts/SubscriptionContext';
 export { AuthStatus } from './providers/auth/types';
 export type { OnWorkspaceChangeParams } from './providers/auth/types';
 export { useSaaSAuth } from './providers/auth/hooks';
-export { useSaaSSettings } from './providers/os/hooks';
+export { useSaaSOs, useSaaSSettings } from './providers/os/hooks';
 export { useUserAttributes, useUserFeatures } from './providers/user/hooks';
 export { useSaaSWorkspaces } from './providers/workspace/hooks';
 export { WorkspaceSwitcher } from './providers/workspace/provider';
 export { useCreateCheckoutSession, useInvoice, useInvoices, usePlanGroup, usePlanGroupVersions, usePublicPlanGroupVersion, usePublicPlans, useSubscription, useSubscriptionManagement, useUpdateSubscription, } from './providers/workspace/subscription-hooks';
 export { eventEmitter } from './providers/events';
 export type { EventData, EventType, IEventCallbacks, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData, } from './providers/events/types';
-export type { BillingInterval, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, IInvoice, IInvoiceListResponse, IInvoiceResponse, InvoiceStatus, IPlan, IPlanGroup, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionsResponse, IPlanGroupVersionWithPlans, IPlanVersion, IPlanVersionWithPlan, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanPricing, IPublicPlanQuotaValue, IPublicPlansResponse, IPublicPlanVersion, IQuotaValue, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, } from './api/types';
+export { BaseApi, SettingsApi, UserApi, WorkspaceApi } from './api';
+export type { IBaseApiConfig } from './api';
+export { CURRENCY_DISPLAY, CURRENCY_FLAG, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, formatCents, formatOverageRate, formatOverageRateWithLabel, formatQuotaIncludedOverage, getCurrencyFlag, getCurrencySymbol, getQuotaUnitLabelFromName, } from './api/currency-utils';
+export { formatQuotaWithPrice, getQuotaDisplayValue } from './api/quota-utils';
+export type { FormatQuotaWithPriceOptions, QuotaDisplayValue } from './api/quota-utils';
+export { getAvailableCurrenciesFromPlans, getBasePriceCents, getBillingIntervalAndCurrencyFromPriceId, getDisplayCurrency, getPricingVariant, getQuotaDisplayWithVariant, getQuotaOverageCents, getStripePriceIdForInterval, } from './api/pricing-variant-utils';
+export type { PlanVersionWithPricingVariants, QuotaDisplayWithOverage, } from './api/pricing-variant-utils';
+export type { BillingInterval, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, IInvoice, IInvoiceListResponse, IInvoiceResponse, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPricingVariant, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaOveragePriceIdsByInterval, IQuotaOveragesByInterval, IStripePricesByInterval, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, InvoiceStatus, } from './api/types';

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

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+import type { ApiVersion } from '../providers/os/types';
+export 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)
+ */
+export 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>;
+}

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { IAuthConfig } from './auth/types';
-import type { IOsState } from './os/types';
+import { type IOsState } from './os/types';
 interface ContextConfigProviderProps {
     config: IOsState;
     auth?: IAuthConfig;

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

@@ -0,0 +1,12 @@
+/**
+ * Centralized API client for auth (profile).
+ * Extends BaseApi; uses explicit sessionId for profile (e.g. after redirect or hydration).
+ */
+import { IUser } from '../../api/types';
+import { BaseApi } from '../../lib/api-base';
+import type { IOsConfig } from '../os/types';
+export declare class AuthApi extends BaseApi {
+    constructor(config: Pick<IOsConfig, 'serverUrl' | 'version'>);
+    /** Fetch user profile with the given session ID (used after OAuth redirect or from storage). */
+    getProfile(sessionId: string, signal?: AbortSignal): Promise<IUser>;
+}

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

@@ -60,6 +60,8 @@ import { WorkspaceSettingsSection } from '../workspace/ui/SettingsDialog';
  * }
  * ```
  */
+/** Internal: select auth slice. Used by AuthProviderWrapper and useSaaSAuth. */
+export declare function useAuthState(): import("./types").IAuthState;
 export declare function useSaaSAuth(): {
     signIn: () => Promise<void>;
     signOut: () => Promise<void>;

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

@@ -0,0 +1,11 @@
+/**
+ * Centralized API client for organization (OS) settings.
+ * Extends BaseApi for shared URL/auth/request handling.
+ */
+import { BaseApi } from '../../lib/api-base';
+import type { ISettings } from '../types';
+import type { IOsConfig } from './types';
+export declare class SettingsApi extends BaseApi {
+    constructor(config: IOsConfig);
+    getSettings(signal?: AbortSignal): Promise<ISettings>;
+}

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

@@ -1,4 +1,10 @@
 import type { ISettings } from '../types';
+import { type IOsState } from './types';
+/**
+ * Hook to access OS (organization) state (serverUrl, version, orgId, auth, settings).
+ * Prefer useSaaSSettings() when you only need settings.
+ */
+export declare function useSaaSOs(): IOsState;
 /**
  * Hook to access organization settings from the OS context.
  * Automatically fetches settings when OS config is ready.

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

@@ -11,6 +11,8 @@ export interface IOsConfig {
     version: ApiVersion;
     orgId: string;
 }
+/** True when OS config has serverUrl, version, and orgId (ready for API calls). */
+export declare function isOsConfigReady(config: Pick<IOsConfig, 'serverUrl' | 'version' | 'orgId'> | null | undefined): boolean;
 export interface IOsState extends IOsConfig {
     auth?: IAuthConfig;
     settings?: ISettings | null;

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

@@ -0,0 +1,16 @@
+import { IUser } from '../../api/types';
+import { BaseApi } from '../../lib/api-base';
+import type { IOsConfig } from '../os/types';
+/**
+ * Centralized API client for user attributes and features.
+ * Extends BaseApi for shared URL/auth/request handling.
+ */
+export declare class UserApi extends BaseApi {
+    constructor(config: Pick<IOsConfig, 'serverUrl' | 'version'>);
+    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>>;
+}
+/** Memoized UserApi instance. Recreates only when serverUrl or version change. BaseApi.ensureReady() throws if config is not set. */
+export declare function useUserApi(): UserApi;

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

@@ -1,3 +1,4 @@
+export { useUserApi } from './api';
 /**
  * Hook to access user attributes from the UserProvider.
  * Must be used within a UserProvider component.

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

@@ -1,12 +1,9 @@
 import { ICheckoutSessionRequest, ICheckoutSessionResponse, IInvoiceListResponse, IInvoiceResponse, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionsResponse, IPublicPlansResponse, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, IUser } from '../../api/types';
+import { BaseApi } from '../../lib/api-base';
 import { IOsConfig } from '../os/types';
 import type { IWorkspace, IWorkspaceFeature, IWorkspaceUser } from './types';
-export declare class WorkspaceApi {
-    private version;
-    private orgId;
-    private serverUrl;
+export declare class WorkspaceApi extends BaseApi {
     constructor(config: IOsConfig);
-    getAuthHeader(): Record<string, string>;
     getWorkspaces(): Promise<IWorkspace[]>;
     createWorkspace(data: {
         name: string;

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

@@ -1,4 +1,6 @@
 import { IUser } from '../../api/types';
+import type { IOsConfig, IOsState } from '../os/types';
+import { WorkspaceApi } from './api';
 import { IWorkspace, IWorkspaceUser } from './types';
 /**
  * Main workspace management hook for the SDK.
@@ -105,6 +107,13 @@ import { IWorkspace, IWorkspaceUser } from './types';
  * }
  * ```
  */
+/** Memoized WorkspaceApi instance. Recreates only when serverUrl, version, or orgId change. */
+export declare function useWorkspaceApi(os: IOsConfig): WorkspaceApi;
+/** OS state + memoized WorkspaceApi. BaseApi.ensureReady() throws if config is not set. Use when a hook needs both (e.g. subscription hooks, useSaaSWorkspaces). */
+export declare function useWorkspaceApiWithOs(): {
+    os: IOsState;
+    api: WorkspaceApi;
+};
 export declare const useSaaSWorkspaces: () => {
     workspaces: IWorkspace[];
     loading: boolean;
@@ -120,7 +129,7 @@ export declare const useSaaSWorkspaces: () => {
         forceEmit?: boolean;
     }) => Promise<void>;
     resetCurrentWorkspace: () => void;
-    createWorkspace: (name: string, image: string) => Promise<void>;
+    createWorkspace: (name: string, image?: string) => Promise<void>;
     allFeatures: import("./types").IWorkspaceFeature[];
     getFeatures: () => Promise<import("./types").IWorkspaceFeature[] | null>;
     updateFeature: (workspaceId: string, key: string, value: boolean) => Promise<IWorkspace>;
@@ -148,4 +157,5 @@ export declare const useSaaSWorkspaces: () => {
         success: boolean;
     }>;
     switching: boolean;
+    switchingToId: string | null;
 };

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

@@ -10,6 +10,7 @@ import { BillingInterval, ICheckoutSessionRequest, ICheckoutSessionResponse, IIn
 export declare const usePublicPlans: (slug: string) => {
     items: import("../..").IPublicPlanItem[];
     plans: import("../..").IPublicPlanVersion[];
+    notes: string | undefined;
     loading: boolean;
     error: string | null;
     refetch: () => Promise<void>;
@@ -120,7 +121,7 @@ export declare const useSubscription: (workspaceId: string | null | undefined) =
  *
  *   return (
  *     <div>
- *       <h3>{planGroup.name}</h3>
+ *       <h3>{planGroup.group.name}</h3>
  *       {planGroup.plans.map(plan => (
  *         <PlanCard key={plan._id} plan={plan} />
  *       ))}

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

@@ -7,7 +7,24 @@ export interface IWorkspace {
     roles: string[];
     createdBy: string | IUser;
     features: Record<string, boolean>;
-    subscription?: ISubscription | null;
+    /**
+     * Quota usage tracking: { [quotaSlug]: number } – how much of each quota has been used.
+     */
+    quotas?: Record<string, number>;
+    /**
+     * Subscription limits snapshot: { [limitSlug]: number | null } – synced from subscription plan.
+     * Limits are maximum values (e.g. max-users, max-workspaces). Updated when subscription is assigned/updated.
+     */
+    limits?: Record<string, number | null>;
+    subscription?: ISubscription | string | null;
+    /** Stripe Customer ID for this workspace. */
+    stripeCustomerId?: string;
+    /**
+     * Billing currency locked for this workspace (set on first subscription).
+     * Stripe allows one currency per customer; all future subscriptions must use this currency.
+     * When set, subscription UI only shows/uses this currency.
+     */
+    billingCurrency?: string | null;
 }
 export interface IWorkspaceFeature {
     _id: string;

package/dist/types/providers/workspace/ui/SubscriptionDialog.d.ts

@@ -6,7 +6,13 @@ interface SubscriptionDialogProps {
     planVersions: IPlanVersionWithPlan[];
     currentPlanVersionId?: string | null;
     currentStripePriceId?: string | null;
-    onSelectPlan: (planVersionId: string, billingInterval: BillingInterval) => Promise<void>;
+    /**
+     * When set, only this currency is allowed (workspace has existing Stripe billing; Stripe does not allow multiple currencies per customer).
+     * When null/undefined, all plan currencies are available.
+     */
+    billingCurrency?: string | null;
+    /** Called when user selects a plan. Currency is optional (for display/logging only; not sent to API). */
+    onSelectPlan: (planVersionId: string, billingInterval: BillingInterval, currency?: string) => Promise<void>;
     loading?: boolean;
 }
 declare const SubscriptionDialog: React.FC<SubscriptionDialogProps>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildbase/sdk",
-  "version": "0.0.16",
+  "version": "0.0.19",
   "type": "module",
   "description": "A SDK for Buildbase",
   "main": "dist/index.js",