@buildbase/sdk 0.0.18 → 0.0.19

package/README.md

@@ -318,6 +318,18 @@ function FeatureExample() {
 
 Use the `useUserFeatures` hook to check feature flags programmatically:
 
+```tsx
+import { useUserFeatures } from '@buildbase/sdk';
+
+function FeatureCheck() {
+  const { features, isFeatureEnabled, refreshFeatures } = useUserFeatures();
+
+  return (
+    <div>{isFeatureEnabled('premium-features') ? <PremiumContent /> : <StandardContent />}</div>
+  );
+}
+```
+
 ## 📋 Subscription Gates
 
 Control UI visibility based on the current workspace’s subscription. Subscription data is loaded once per workspace and refetched when the workspace changes or when the subscription is updated (e.g. upgrade, cancel, resume).
@@ -411,22 +423,6 @@ function SubscriptionStatus() {
 - When subscription is updated via SDK (e.g. `useUpdateSubscription`, cancel, resume) — refetch is triggered automatically.
 - When you call `refetch()` (e.g. after redirect from checkout).
 
-### Feature Flags Hook
-
-Use the `useUserFeatures` hook to check feature flags programmatically:
-
-```tsx
-import { useUserFeatures } from '@buildbase/sdk';
-
-function FeatureCheck() {
-  const { features, isFeatureEnabled, refreshFeatures } = useUserFeatures();
-
-  return (
-    <div>{isFeatureEnabled('premium-features') ? <PremiumContent /> : <StandardContent />}</div>
-  );
-}
-```
-
 ## 👤 User Management
 
 ### User Attributes
@@ -640,7 +636,7 @@ import { SaaSOSProvider, eventEmitter } from '@buildbase/sdk';
 
 ## 🛡️ Error Handling
 
-The SDK handles errors internally: API failures, auth errors, and component errors are logged and surfaced through hook states (e.g. `error` from `useSaaSWorkspaces`) and callbacks. Wrap your app in an error boundary of your choice to catch React errors. For failed operations, check the `error` property on hooks and handle it in your UI (e.g. toast or inline message).
+The SDK handles errors internally: API failures, auth errors, and component errors are logged and surfaced through hook states (e.g. `error` from `useSaaSWorkspaces`) and callbacks. **SaaSOSProvider** wraps its children in an internal **SDKErrorBoundary** to catch React render errors inside the SDK tree. For app-level errors, wrap your app (or routes) in your own error boundary (e.g. React’s `ErrorBoundary` or your framework’s error UI). For failed async operations, check the `error` property on hooks and show user feedback (e.g. toast or inline message). See [Error codes](docs/ERROR_CODES.md) for SDK error codes and HTTP mappings.
 
 ## ⚙️ Settings
 
@@ -674,21 +670,18 @@ All SDK API clients extend a shared base class and are exported from the package
 | `WorkspaceApi`   | Workspaces, subscription, invoices, users                                       |
 | `SettingsApi`    | Organization settings                                                           |
 
-Use the hooks (`useUserApi`, `useWorkspaceApi`, etc.) for a ready-made instance with OS config, or instantiate with your own config:
+Get OS config from `useSaaSOs()` and instantiate API classes when you need low-level access; otherwise prefer the high-level hooks (`useSaaSWorkspaces`, `useUserAttributes`, `useSaaSSettings`, etc.):
 
 ```tsx
 import { UserApi, WorkspaceApi, SettingsApi, useSaaSOs } from '@buildbase/sdk';
 
-// Via hook (uses OS config from context)
-const api = useWorkspaceApi(); // or useUserApi(), etc.
-
-// Or instantiate with config
 const os = useSaaSOs();
 const workspaceApi = new WorkspaceApi({
   serverUrl: os.serverUrl,
   version: os.version,
   orgId: os.orgId,
 });
+// Similarly: new UserApi({ ... }), new SettingsApi({ ... })
 ```
 
 ### Hooks
@@ -719,7 +712,7 @@ All TypeScript types are exported for type safety. See the [TypeScript definitio
 
 ### Further documentation
 
-- [Architecture](docs/ARCHITECTURE.md) – Layers, APIs (BaseApi, UserApi, WorkspaceApi, SettingsApi), state, auth flow
+- [Architecture](docs/ARCHITECTURE.md) – Layers, providers, APIs (BaseApi, UserApi, WorkspaceApi, SettingsApi), state, auth flow
 - [Error codes](docs/ERROR_CODES.md) – SDK error codes and HTTP status mappings
 
 ## ⚙️ Configuration Reference

package/dist/index.d.ts

@@ -4,7 +4,8 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 
 interface IDocument {
     _id: string;
-    id: string;
+    /** Optional; some APIs only return _id. Prefer _id for identity. */
+    id?: string;
     createdAt: string;
     updatedAt: string;
     deleted: boolean;
@@ -13,12 +14,17 @@ interface IUser extends IDocument {
     _id: string;
     name: string;
     email: string;
-    image: string;
+    /** Profile image URL. Often omitted or empty from API. */
+    image?: string;
     role: string;
-    country: string;
-    timezone: string;
-    language: string;
-    currency: string;
+    /** ISO country code. May be omitted. */
+    country?: string;
+    /** IANA timezone. May be omitted. */
+    timezone?: string;
+    /** Language code. May be omitted. */
+    language?: string;
+    /** Currency code. May be omitted. */
+    currency?: string;
     attributes?: Record<string, string | number | boolean>;
 }
 type BillingInterval = 'monthly' | 'yearly' | 'quarterly';
@@ -36,6 +42,8 @@ interface ISubscription {
         name: string;
         slug: string;
         description?: string;
+        /** Stripe currency code (e.g. 'usd', 'inr', 'eur'). */
+        currency?: string;
     };
 }
 interface ISubscriptionItem {
@@ -46,17 +54,14 @@ interface ISubscriptionItem {
     description?: string;
     category: string;
 }
-interface IQuotaValue {
-    included: number;
-    overage?: number;
-    stripePriceId?: string;
-}
-/** Per-interval quota value (new plan-group/versions schema) */
+/** Per-interval quota value (plan-group/versions and public plans schema). */
 interface IQuotaIntervalValue {
     included: number;
-    overage: number;
-    priceId: string;
-    /** Optional unit size for overage pricing (e.g. 1000 = price per 1000 units). */
+    /** Overage price in cents. Omitted in public plans; use pricingVariant.quotaOverages for display. */
+    overage?: number;
+    /** Stripe price ID for overage. Omitted in public plans; use pricingVariant.quotaOveragePriceIds. */
+    priceId?: string;
+    /** Unit size for overage pricing (e.g. 1000 = price per 1000 units). */
     unitSize?: number;
 }
 /** Quota defined per billing interval (new plan-group/versions schema) */
@@ -65,11 +70,46 @@ interface IQuotaByInterval {
     yearly?: IQuotaIntervalValue;
     quarterly?: IQuotaIntervalValue;
 }
+/** Base pricing per interval. Values are often in cents (Stripe); convert for display. */
 interface IBasePricing {
     monthly: number;
     yearly: number;
     quarterly: number;
 }
+/** Stripe price IDs per billing interval (for a single currency variant). */
+interface IStripePricesByInterval {
+    monthlyPriceId?: string;
+    yearlyPriceId?: string;
+    quarterlyPriceId?: string;
+    monthly?: string;
+    yearly?: string;
+}
+/** Overage amounts in cents per interval, keyed by quota slug. Used in pricing variants. */
+type IQuotaOveragesByInterval = Record<string, {
+    monthly?: number;
+    yearly?: number;
+    quarterly?: number;
+}>;
+/** Overage Stripe price IDs per interval, keyed by quota slug. Used in pricing variants. */
+type IQuotaOveragePriceIdsByInterval = Record<string, {
+    monthly?: string;
+    yearly?: string;
+    quarterly?: string;
+}>;
+/**
+ * Multi-currency pricing variant at plan version level.
+ * Each plan version can have multiple variants (e.g. usd, eur, inr, sgd).
+ */
+interface IPricingVariant {
+    _id: string;
+    currency: string;
+    basePricing: IBasePricing;
+    stripePrices: IStripePricesByInterval;
+    /** Overage cents per quota slug per interval. */
+    quotaOverages?: IQuotaOveragesByInterval;
+    /** Stripe price IDs for overage per quota slug per interval. */
+    quotaOveragePriceIds?: IQuotaOveragePriceIdsByInterval;
+}
 interface IPlanVersion {
     _id: string;
     version: number;
@@ -77,16 +117,10 @@ interface IPlanVersion {
     status: 'draft' | 'published';
     features?: Record<string, boolean>;
     limits?: Record<string, number>;
-    /** Legacy: number | IQuotaValue. New schema: IQuotaByInterval (per-interval included/overage/priceId) */
-    quotas?: Record<string, number | IQuotaValue | IQuotaByInterval>;
-    basePricing?: IBasePricing;
-    stripePrices?: {
-        monthlyPriceId?: string;
-        yearlyPriceId?: string;
-        quarterlyPriceId?: string;
-        monthly?: string;
-        yearly?: string;
-    };
+    /** Per-interval quotas (included, unitSize; overage from pricingVariant.quotaOverages). */
+    quotas?: Record<string, IQuotaByInterval>;
+    /** Multi-currency pricing. Each variant has currency, basePricing, stripePrices, quotaOverages. */
+    pricingVariants?: IPricingVariant[];
     subscriptionItems?: ISubscriptionItem[];
     isCurrent?: boolean;
     isLegacy?: boolean;
@@ -106,6 +140,8 @@ interface IPlan {
     name: string;
     slug: string;
     description?: string;
+    /** Stripe currency code (e.g. 'usd', 'inr', 'eur'). Used for pricing display. */
+    currency?: string;
     latestVersion?: IPlanVersionSummary;
     archived?: boolean;
     deleted?: boolean;
@@ -166,13 +202,19 @@ interface ISubscriptionResponse {
     group: IPlanGroup | null;
     groupVersion: IPlanGroupVersion | null;
 }
+/** Plan version with nested plan info (name, slug, currency for display). */
 interface IPlanVersionWithPlan extends IPlanVersion {
     plan: IPlan;
 }
+/**
+ * Plan group version with full plan versions (for GET .../plan-group/versions).
+ * Each plan has plan, subscriptionItems, quotas (per-interval), pricingVariants.
+ */
 interface IPlanGroupVersionWithPlans {
     _id: string;
     version: number;
     description?: string;
+    /** Full plan versions with nested plan (name, slug, currency). */
     plans: IPlanVersionWithPlan[];
     isCurrent?: boolean;
     whatsNew?: {
@@ -189,18 +231,27 @@ interface IPlanGroupInfo {
 }
 /** Response from GET workspaces/:id/subscription/plan-group (and by version). */
 interface IPlanGroupResponse {
-    /** Plan group with latestVersion, archived, deleted, timestamps. */
-    group: IPlanGroup;
+    /** Plan group with latestVersion, archived, deleted, timestamps. May be null in some API responses. */
+    group: IPlanGroup | null;
     /** Current group version with populated planVersionIds (or IDs). */
     groupVersion: IPlanGroupVersion;
-    /** Full plan versions for display (subscriptionItems, basePricing, quotas, etc.). */
+    /** Full plan versions for display (subscriptionItems, pricingVariants, quotas). */
     plans: IPlanVersionWithPlan[];
 }
+/**
+ * Response from GET workspaces/:workspaceId/subscription/plan-group/versions.
+ * Group summary plus current and available group versions; each version has plans with
+ * per-interval quotas and pricingVariants.
+ */
 interface IPlanGroupVersionsResponse {
+    /** Plan group summary (_id, name, slug). */
     group: IPlanGroupInfo;
+    /** Current group version (user's version when subscribed, or latest published when not). */
     currentVersion: IPlanGroupVersionWithPlans;
+    /** Newer versions when user has subscription; empty when no subscription. */
     availableVersions: IPlanGroupVersionWithPlans[];
 }
+/** Request body for POST .../workspaces/:id/subscription/checkout. Only these fields are allowed. */
 interface ICheckoutSessionRequest {
     planVersionId: string;
     billingInterval?: BillingInterval;
@@ -218,6 +269,7 @@ interface ICheckoutSessionResponse {
         name: string;
     };
 }
+/** Request body for PATCH .../workspaces/:id/subscription. Only these fields are allowed. */
 interface ISubscriptionUpdateRequest {
     planVersionId: string;
     billingInterval?: BillingInterval;
@@ -244,33 +296,33 @@ interface IPublicPlanItem {
     _id: string;
     name: string;
     slug: string;
-    description: string;
+    description?: string;
     type: 'feature' | 'limit' | 'quota';
     category: IPublicPlanItemCategory;
 }
-interface IPublicPlanPricing {
-    monthly: number;
-    yearly: number;
-    quarterly: number;
-}
-interface IPublicPlanQuotaValue {
-    included: number;
-    overage: number;
-    stripePriceId?: string;
-}
+/**
+ * Public plan version (e.g. from GET /api/v1/public/:orgId/plans/:slug).
+ * Each plan has _id, name (plan display name), version, status, pricingVariants, quotas, features, limits.
+ * Pricing is in cents (see response.notes).
+ */
 interface IPublicPlanVersion {
     _id: string;
+    /** Plan display name (e.g. "Pro", "Base Plan"). */
     name: string;
     version: number;
     status: 'draft' | 'published';
-    pricing: IPublicPlanPricing;
-    quotas: Record<string, IPublicPlanQuotaValue>;
+    /** Multi-currency pricing. Use getBasePriceCents(plan, currency, interval) and getQuotaDisplayWithVariant for display. */
+    pricingVariants?: IPricingVariant[];
+    /** Keyed by item slug. Per-interval: included, unitSize; overage from pricingVariant.quotaOverages. */
+    quotas: Record<string, IQuotaByInterval>;
     features: Record<string, boolean>;
     limits: Record<string, number>;
 }
 interface IPublicPlansResponse {
     items: IPublicPlanItem[];
     plans: IPublicPlanVersion[];
+    /** Optional note from API (e.g. "Pricing is in cents. Please convert to dollars for display."). */
+    notes?: string;
 }
 type InvoiceStatus = 'draft' | 'open' | 'paid' | 'uncollectible' | 'void';
 interface IInvoice {
@@ -306,7 +358,24 @@ 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;
 }
 interface IWorkspaceFeature {
     _id: string;
@@ -500,6 +569,8 @@ interface PricingPageDetails {
     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>;
 }
@@ -1300,7 +1371,7 @@ declare const useSaaSWorkspaces: () => {
         forceEmit?: boolean;
     }) => Promise<void>;
     resetCurrentWorkspace: () => void;
-    createWorkspace: (name: string, image: string) => Promise<void>;
+    createWorkspace: (name: string, image?: string) => Promise<void>;
     allFeatures: IWorkspaceFeature[];
     getFeatures: () => Promise<IWorkspaceFeature[] | null>;
     updateFeature: (workspaceId: string, key: string, value: boolean) => Promise<IWorkspace>;
@@ -1346,6 +1417,7 @@ declare function WorkspaceSwitcher(props: {
 declare const usePublicPlans: (slug: string) => {
     items: IPublicPlanItem[];
     plans: IPublicPlanVersion[];
+    notes: string | undefined;
     loading: boolean;
     error: string | null;
     refetch: () => Promise<void>;
@@ -1906,23 +1978,122 @@ declare class SettingsApi extends BaseApi {
     getSettings(signal?: AbortSignal): Promise<ISettings>;
 }
 
+/**
+ * Centralized formatting for subscription/quota display: cents, overage rates, included + overage text.
+ * Currency must be provided by the caller (e.g. workspace.billingCurrency, plan.currency, or selected currency).
+ */
+/** Common currency display (code or symbol). Use lowercase Stripe codes (usd, eur, etc.). */
+declare const CURRENCY_DISPLAY: Record<string, string>;
+/** Currency code to flag emoji (country/region associated with the currency). Use for dropdowns. */
+declare const CURRENCY_FLAG: Record<string, string>;
+/** Get flag emoji for a currency code. Returns empty string when unknown or empty. */
+declare function getCurrencyFlag(currency: string): string;
+/** Get currency symbol for display. Use lowercase Stripe codes (usd, eur). Returns code when unknown; empty string when currency is empty. */
+declare function getCurrencySymbol(currency: string): string;
+/** Allowed plan/pricing currency codes (must match server ALLOWED_BILLING_CURRENCIES). Use for dropdowns and validation. */
+declare const PLAN_CURRENCY_CODES: readonly ["usd", "eur", "gbp", "jpy", "cad", "aud", "chf", "cny", "hkd", "sgd", "inr", "mxn", "brl", "nzd", "sek", "nok", "dkk", "pln", "thb"];
+/** Options for plan currency select: { value, label } with symbol. Use in CreateOrEditPlan and anywhere a currency dropdown is needed. */
+declare const PLAN_CURRENCY_OPTIONS: {
+    value: "usd" | "eur" | "gbp" | "jpy" | "cad" | "aud" | "chf" | "cny" | "hkd" | "sgd" | "inr" | "mxn" | "brl" | "nzd" | "sek" | "nok" | "dkk" | "pln" | "thb";
+    label: string;
+}[];
+/** Format cents as money string (e.g. 1999, "usd" -> "$19.99"). Caller must pass currency (e.g. from plan or workspace). */
+declare function formatCents(cents: number, currency: string): string;
+/**
+ * Format overage rate for display. When unitSize > 1: "$1.00/1,000 units"; else "$1.00/unit".
+ * Returns null if overageCents is missing or negative.
+ */
+declare function formatOverageRate(overageCents: number | undefined, unitSize: number | undefined, currency: string): string | null;
+/**
+ * Format overage rate with optional unit label for comparison/preview UIs.
+ * e.g. formatOverageRateWithLabel(50, 1000, "video") -> "$0.50/1,000 videos"
+ *      formatOverageRateWithLabel(46, 1, "video") -> "$0.46/video"
+ * When unitLabel is omitted, falls back to formatOverageRate behavior.
+ */
+declare function formatOverageRateWithLabel(overageCents: number | undefined, unitSize: number | undefined, unitLabel: string | undefined, currency: string): string | null;
+/**
+ * Get singular unit label from item name or slug (e.g. "Videos" -> "video", "reels" -> "reel").
+ * Used for quota display in comparison and preview.
+ */
+declare function getQuotaUnitLabelFromName(nameOrSlug: string): string;
+/**
+ * Format quota "included + overage" for display.
+ * When unitSize >= 2: "Included: 1,000, after that $1.00/1,000 emails".
+ * Otherwise: "Included: 5, after that $0.30/image".
+ */
+declare function formatQuotaIncludedOverage(included: number | undefined, overageCents: number | undefined, unitLabel: string, currency: string, unitSize?: number): string;
+
+/**
+ * Helpers for multi-currency plan version pricing (pricingVariants).
+ */
+
+/** Get the pricing variant for a currency, or null if not available. */
+declare function getPricingVariant(planVersion: IPlanVersion, currency: string): IPricingVariant | null;
+/**
+ * Get base price in cents for a plan version and currency/interval.
+ */
+declare function getBasePriceCents(planVersion: IPlanVersion, currency: string, interval: BillingInterval): number | null;
+/**
+ * Get Stripe price ID for the given plan version, currency, and interval.
+ */
+declare function getStripePriceIdForInterval(planVersion: IPlanVersion, currency: string, interval: BillingInterval): string | null;
+/**
+ * Get overage amount in cents for a quota in a given currency and interval.
+ * Returns undefined if not defined in the pricing variant.
+ */
+declare function getQuotaOverageCents(planVersion: IPlanVersion, currency: string, quotaSlug: string, interval: BillingInterval): number | undefined;
+/**
+ * Get display currency for a plan version when using a given currency.
+ * Returns the requested currency if the variant exists; otherwise plan.currency or null.
+ */
+declare function getDisplayCurrency(planVersion: IPlanVersionWithPlan, currency: string): string;
+/** Minimal shape for extracting currencies (IPlanVersionWithPlan or IPublicPlanVersion). */
+type PlanVersionWithPricingVariants = {
+    pricingVariants?: IPricingVariant[];
+};
+/**
+ * Collect all unique currency codes from plan versions (from their pricingVariants).
+ * Use for currency selector. Accepts IPlanVersionWithPlan[] or IPublicPlanVersion[].
+ */
+declare function getAvailableCurrenciesFromPlans(planVersions: PlanVersionWithPricingVariants[]): string[];
+/**
+ * Quota display shape: included count and optional overage (cents) and unitSize from plan + variant.
+ */
+type QuotaDisplayWithOverage = {
+    included: number;
+    overage?: number;
+    unitSize?: number;
+} | null;
+/**
+ * Get quota display value for a slug/interval, merging plan version quotas (included, unitSize)
+ * with pricing variant overage (cents) when available.
+ */
+declare function getQuotaDisplayWithVariant(planVersion: IPlanVersion, currency: string, quotaSlug: string, interval: BillingInterval): QuotaDisplayWithOverage;
+/**
+ * Resolve billing interval and currency from a Stripe price ID by checking all plan versions' pricingVariants.
+ */
+declare function getBillingIntervalAndCurrencyFromPriceId(priceId: string | null | undefined, planVersions: IPlanVersionWithPlan[]): {
+    interval: BillingInterval;
+    currency: string;
+} | null;
+
 type QuotaDisplayValue = {
     included: number;
     overage?: number;
     unitSize?: number;
-} | number | null;
+} | null;
 /**
- * Normalize a quota value (legacy or per-interval) to a display shape for a given billing interval.
- * - Legacy: number or IQuotaValue → use as-is (interval ignored).
- * - New schema: IQuotaByInterval → pick the interval slice (e.g. monthly, yearly, quarterly).
+ * Normalize a per-interval quota value to a display shape for the given billing interval.
  */
-declare function getQuotaDisplayValue(value: number | IQuotaValue | IQuotaByInterval | null | undefined, interval?: BillingInterval): QuotaDisplayValue;
+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. Default '$'. */
+    /** 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").
@@ -1930,5 +2101,5 @@ interface FormatQuotaWithPriceOptions {
  */
 declare function formatQuotaWithPrice(value: QuotaDisplayValue, unitName: string, options?: FormatQuotaWithPriceOptions): string;
 
-export { ApiVersion, AuthStatus, BaseApi, BetaForm, PricingPage, SaaSOSProvider, SettingsApi, SubscriptionContextProvider, UserApi, WhenAuthenticated, WhenNoSubscription, WhenRoles, WhenSubscription, WhenSubscriptionToPlans, WhenUnauthenticated, WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, WhenWorkspaceRoles, WorkspaceApi, WorkspaceSwitcher, eventEmitter, formatQuotaWithPrice, getQuotaDisplayValue, useCreateCheckoutSession, useInvoice, useInvoices, usePlanGroup, usePlanGroupVersions, usePublicPlanGroupVersion, usePublicPlans, useSaaSAuth, useSaaSOs, useSaaSSettings, useSaaSWorkspaces, useSubscription, useSubscriptionContext, useSubscriptionManagement, useUpdateSubscription, useUserAttributes, useUserFeatures };
-export type { BillingInterval, EventData, EventType, FormatQuotaWithPriceOptions, IBaseApiConfig, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, IEventCallbacks, IInvoice, IInvoiceListResponse, IInvoiceResponse, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanPricing, IPublicPlanQuotaValue, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaValue, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, InvoiceStatus, OnWorkspaceChangeParams, PricingPageDetails, PricingPageProps, QuotaDisplayValue, SubscriptionContextValue, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };
+export { ApiVersion, AuthStatus, BaseApi, BetaForm, CURRENCY_DISPLAY, CURRENCY_FLAG, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, PricingPage, SaaSOSProvider, SettingsApi, SubscriptionContextProvider, UserApi, WhenAuthenticated, WhenNoSubscription, WhenRoles, WhenSubscription, WhenSubscriptionToPlans, WhenUnauthenticated, WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, WhenWorkspaceRoles, WorkspaceApi, WorkspaceSwitcher, eventEmitter, formatCents, formatOverageRate, formatOverageRateWithLabel, formatQuotaIncludedOverage, formatQuotaWithPrice, getAvailableCurrenciesFromPlans, getBasePriceCents, getBillingIntervalAndCurrencyFromPriceId, getCurrencyFlag, getCurrencySymbol, getDisplayCurrency, getPricingVariant, getQuotaDisplayValue, getQuotaDisplayWithVariant, getQuotaOverageCents, getQuotaUnitLabelFromName, getStripePriceIdForInterval, useCreateCheckoutSession, useInvoice, useInvoices, usePlanGroup, usePlanGroupVersions, usePublicPlanGroupVersion, usePublicPlans, useSaaSAuth, useSaaSOs, useSaaSSettings, useSaaSWorkspaces, useSubscription, useSubscriptionContext, useSubscriptionManagement, useUpdateSubscription, useUserAttributes, useUserFeatures };
+export type { BillingInterval, EventData, EventType, FormatQuotaWithPriceOptions, 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, IStripePricesByInterval, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, InvoiceStatus, OnWorkspaceChangeParams, PlanVersionWithPricingVariants, PricingPageDetails, PricingPageProps, QuotaDisplayValue, QuotaDisplayWithOverage, SubscriptionContextValue, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };