@buildbase/sdk 0.0.16 → 0.0.18

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

@@ -1 +1,7 @@
 export type { IBetaConfig } from '../components/beta/api';
+/** Central SDK APIs – all extend BaseApi for shared URL/auth/request handling. */
+export { BaseApi } from '../lib/api-base';
+export type { IBaseApiConfig } from '../lib/api-base';
+export { SettingsApi } from '../providers/os/api';
+export { UserApi } from '../providers/user/api';
+export { WorkspaceApi } from '../providers/workspace/api';

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

@@ -0,0 +1,24 @@
+import type { BillingInterval, IQuotaByInterval, IQuotaValue } from './types';
+export type QuotaDisplayValue = {
+    included: number;
+    overage?: number;
+    unitSize?: number;
+} | number | 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).
+ */
+export declare function getQuotaDisplayValue(value: number | IQuotaValue | IQuotaByInterval | null | undefined, interval?: BillingInterval): QuotaDisplayValue;
+/** Options for formatting quota with price. */
+export interface FormatQuotaWithPriceOptions {
+    /** If true, overage is in cents (Stripe); format as dollars. Default true. */
+    overageInCents?: boolean;
+    /** Currency symbol. Default '$'. */
+    currencySymbol?: 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).
+ */
+export declare function formatQuotaWithPrice(value: QuotaDisplayValue, unitName: string, options?: FormatQuotaWithPriceOptions): string;

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

@@ -55,6 +55,7 @@ export interface ISubscription {
     stripePriceId?: string;
     stripeCurrentPeriodEnd?: string;
     cancelAtPeriodEnd: boolean;
+    billingInterval?: BillingInterval;
     createdAt: string;
     updatedAt: string;
     plan?: {
@@ -77,6 +78,20 @@ export interface IQuotaValue {
     overage?: number;
     stripePriceId?: string;
 }
+/** Per-interval quota value (new plan-group/versions schema) */
+export interface IQuotaIntervalValue {
+    included: number;
+    overage: number;
+    priceId: string;
+    /** Optional unit size for overage pricing (e.g. 1000 = price per 1000 units). */
+    unitSize?: number;
+}
+/** Quota defined per billing interval (new plan-group/versions schema) */
+export interface IQuotaByInterval {
+    monthly?: IQuotaIntervalValue;
+    yearly?: IQuotaIntervalValue;
+    quarterly?: IQuotaIntervalValue;
+}
 export interface IBasePricing {
     monthly: number;
     yearly: number;
@@ -89,7 +104,8 @@ export interface IPlanVersion {
     status: 'draft' | 'published';
     features?: Record<string, boolean>;
     limits?: Record<string, number>;
-    quotas?: Record<string, number | IQuotaValue>;
+    /** Legacy: number | IQuotaValue. New schema: IQuotaByInterval (per-interval included/overage/priceId) */
+    quotas?: Record<string, number | IQuotaValue | IQuotaByInterval>;
     basePricing?: IBasePricing;
     stripePrices?: {
         monthlyPriceId?: string;
@@ -106,13 +122,18 @@ export interface IPlanVersion {
     createdAt?: string;
     updatedAt?: string;
     id?: string;
+    stripeProductId?: string;
+}
+/** Plan version summary (e.g. plan.latestVersion from subscription API) with subscriptionItems as IDs. */
+export interface IPlanVersionSummary extends Omit<IPlanVersion, 'subscriptionItems'> {
+    subscriptionItems?: string[];
 }
 export interface IPlan {
     _id: string;
     name: string;
     slug: string;
     description?: string;
-    latestVersion?: IPlanVersion;
+    latestVersion?: IPlanVersionSummary;
     archived?: boolean;
     deleted?: boolean;
     createdAt?: string;
@@ -187,21 +208,23 @@ export interface IPlanGroupVersionWithPlans {
         removedPlans: IPlanVersionWithPlan[];
     };
 }
+export interface IPlanGroupInfo {
+    _id: string;
+    name: string;
+    slug: string;
+    description?: string;
+}
+/** Response from GET workspaces/:id/subscription/plan-group (and by version). */
 export interface IPlanGroupResponse {
-    group: {
-        _id: string;
-        name: string;
-        slug: string;
-    };
-    currentVersion: IPlanGroupVersionWithPlans;
-    availableVersions: IPlanGroupVersionWithPlans[];
+    /** Plan group with latestVersion, archived, deleted, timestamps. */
+    group: IPlanGroup;
+    /** Current group version with populated planVersionIds (or IDs). */
+    groupVersion: IPlanGroupVersion;
+    /** Full plan versions for display (subscriptionItems, basePricing, quotas, etc.). */
+    plans: IPlanVersionWithPlan[];
 }
 export interface IPlanGroupVersionsResponse {
-    group: {
-        _id: string;
-        name: string;
-        slug: string;
-    };
+    group: IPlanGroupInfo;
     currentVersion: IPlanGroupVersionWithPlans;
     availableVersions: IPlanGroupVersionWithPlans[];
 }

package/dist/types/components/beta/api.d.ts

@@ -30,9 +30,8 @@ interface ApiResponse {
     submissionId?: string;
 }
 export declare class BetaForm {
-    private version;
+    private api;
     private orgId;
-    private serverUrl;
     constructor(config: IOsConfig);
     fetchConfig(): Promise<IBetaConfig>;
     submitBetaUser(formData: {

package/dist/types/components/pricing/PricingPage.d.ts

@@ -44,4 +44,4 @@ export interface PricingPageProps {
  * </PricingPage>
  * ```
  */
-export declare function PricingPage({ slug, children, loadingFallback, errorFallback, }: PricingPageProps): import("react/jsx-runtime").JSX.Element;
+export declare function PricingPage({ slug, children, loadingFallback, errorFallback }: PricingPageProps): import("react/jsx-runtime").JSX.Element;

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,21 @@ 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 { formatQuotaWithPrice, getQuotaDisplayValue } from './api/quota-utils';
+export type { FormatQuotaWithPriceOptions, QuotaDisplayValue, } from './api/quota-utils';
+export type { BillingInterval, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, 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, } 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;
@@ -148,4 +157,5 @@ export declare const useSaaSWorkspaces: () => {
         success: boolean;
     }>;
     switching: boolean;
+    switchingToId: string | null;
 };

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

@@ -120,7 +120,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/package.json

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